Dela via

Distribuera ett Java-program med Quarkus i Azure Container Apps

Den här artikeln visar hur du snabbt distribuerar Red Hat Quarkus på Microsoft Azure Container Apps med ett enkelt CRUD-program. Programmet är en "att göra-lista" med en JavaScript-klientdel och en REST-slutpunkt. Azure Database for PostgreSQL – flexibel server tillhandahåller beständighetsskiktet för appen. Artikeln visar hur du testar din app lokalt och distribuerar den till Container Apps.

Förutsättningar

  • En Azure-prenumeration. Om du inte har en Azure-prenumeration kan du skapa ettkostnadsfritt konto innan du börjar.
  • Förbered en lokal dator med Unix-liknande operativsystem installerat , till exempel Ubuntu, macOS eller Windows-undersystem för Linux.
  • Installera en Java SE-implementeringsversion 17 eller senare – till exempel Microsoft-version av OpenJDK.
  • Installera Maven, version 3.9.8 eller senare.
  • Installera Docker- för operativsystemet.
  • Installera jq.
  • Installera cURL.
  • Installera Quarkus CLI, version 3.12.1 eller senare.
  • Installera Azure CLI för att köra Azure CLI-kommandon.
    • Logga in på Azure CLI med hjälp av kommandot az login. Slutför autentiseringsprocessen genom att följa stegen som visas i terminalen. Andra inloggningsalternativ finns i Logga in på Azure med Azure CLI.
    • När du uppmanas att installera Azure CLI-tillägget vid första användningen. Mer information om tillägg finns i Använda och hantera tillägg med Azure CLI.
    • Kör az version för att hitta den version och de beroende bibliotek som är installerade. Om du vill uppgradera till den senaste versionen kör du az upgrade. Den här artikeln kräver minst version 2.61.0 av Azure CLI.

Skapa appprojektet

Använd följande kommandon för att klona Java-exempelprojektet för den här artikeln. Exemplet finns på GitHub.

git clone https://github.com/Azure-Samples/quarkus-azure
cd quarkus-azure
git checkout 2025-05-08
cd aca-quarkus

Om du ser ett meddelande om att vara i detached HEAD-tillstånd går det bra att ignorera det här meddelandet. Eftersom den här artikeln inte kräver några kommandon är detached HEAD läge lämpligt.

Testa Din Quarkus-app lokalt

Stegen i det här avsnittet visar hur du kör appen lokalt.

Quarkus stöder automatisk etablering av okonfigurerade tjänster i utvecklings- och testläge. Quarkus refererar till den här funktionen som dev-tjänster. Anta att du inkluderar en Quarkus-funktion, till exempel att ansluta till en databastjänst. Du vill testa appen, men har ännu inte konfigurerat anslutningen till en riktig databas. Quarkus startar automatiskt en stub-version av den relevanta tjänsten och ansluter ditt program till den. Mer information finns i Översikt över Dev Services i Quarkus-dokumentationen.

Kontrollera att containermiljön körs och använd följande kommando för att ange Quarkus dev-läge:

quarkus dev

I stället quarkus devför kan du utföra samma sak med Maven med hjälp mvn quarkus:devav .

Du kan tillfrågas om du vill skicka telemetri för din användning av Quarkus dev-läge. I så fall svarar du som du vill.

Quarkus dev mode aktiverar live-inläsning med bakgrundskompilering. Om du ändrar någon aspekt av appens källkod och uppdaterar webbläsaren kan du se ändringarna. Om det finns problem med kompilering eller distribution kan du få en felsida. Quarkus dev mode lyssnar efter ett felsökningsprogram på port 5005. Om du vill vänta tills felsökningsprogrammet ska kopplas innan du kör, skickar -Dsuspend du på kommandoraden. Om du inte vill ha felsökningsprogrammet alls kan du använda -Ddebug=false.

Utdata bör se ut som i följande exempel:

__  ____  __  _____   ___  __ ____  ______
 --/ __ \/ / / / _ | / _ \/ //_/ / / / __/
 -/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/
INFO  [io.quarkus] (Quarkus Main Thread) quarkus-todo-demo-app-aca 1.0.0-SNAPSHOT on JVM (powered by Quarkus 3.2.0.Final) started in 14.826s. Listening on: http://localhost:8080
INFO  [io.quarkus] (Quarkus Main Thread) Profile dev activated. Live Coding activated.
INFO  [io.quarkus] (Quarkus Main Thread) Installed features: [agroal, cdi, hibernate-orm, hibernate-validator, jdbc-postgresql, narayana-jta, resteasy-reactive, resteasy-reactive-jackson, smallrye-context-propagation, vertx]

--
Tests paused
Press [e] to edit command line args (currently ''), [r] to resume testing, [o] Toggle test output, [:] for the terminal, [h] for more options>

Tryck på w på terminalen där Quarkus dev mode körs. W-nyckeln öppnar standardwebbläsaren Todo för att visa programmet. Du kan också komma åt programmets GUI http://localhost:8080 direkt.

Skärmbild av Todo-exempelappen.

Prova att välja några att göra-objekt i att göra-listan. Användargränssnittet anger markering med en genomstrukningstextformat. Du kan också lägga till ett nytt att göra-objekt i att göra-listan genom att skriva Verifiera Todo-appar och trycka på RETUR, som du ser på följande skärmbild:

Skärmbild av Todo-exempelappen med nya objekt tillagda.

Få åtkomst till RESTful API (/api) för att hämta alla att göra-objekt som lagras i den lokala PostgreSQL-databasen:

curl --verbose http://localhost:8080/api | jq .

Utdata bör se ut som i följande exempel:

* Connected to localhost (127.0.0.1) port 8080 (#0)
> GET /api HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.88.1
> Accept: */*
>
< HTTP/1.1 200 OK
< content-length: 664
< Content-Type: application/json;charset=UTF-8
<
{ [664 bytes data]
100   664  100   664    0     0  13278      0 --:--:-- --:--:-- --:--:-- 15441
* Connection #0 to host localhost left intact
[
  {
    "id": 1,
    "title": "Introduction to Quarkus Todo App",
    "completed": false,
    "order": 0,
    "url": null
  },
  {
    "id": 2,
    "title": "Quarkus on Azure App Service",
    "completed": false,
    "order": 1,
    "url": "https://free.blessedness.top/en-us/azure/app-service/quickstart-java"
  },
  {
    "id": 3,
    "title": "Quarkus on Azure Container Apps",
    "completed": false,
    "order": 2,
    "url": "https://free.blessedness.top/en-us/training/modules/deploy-java-quarkus-azure-container-app-postgres/"
  },
  {
    "id": 4,
    "title": "Quarkus on Azure Functions",
    "completed": false,
    "order": 3,
    "url": "https://free.blessedness.top/en-us/azure/azure-functions/functions-create-first-quarkus"
  },
  {
    "id": 5,
    "title": "Verify Todo apps",
    "completed": false,
    "order": 5,
    "url": null
  }
]

Tryck på q för att avsluta Quarkus utvecklingsläge.

Skapa Azure-resurserna för att köra Quarkus-appen

Stegen i det här avsnittet visar hur du skapar följande Azure-resurser för att köra Quarkus-exempelappen:

  • Flexibel Server för Azure Database for PostgreSQL
  • Azure Container Registry
  • Azure Container Apps

Vissa av dessa resurser måste ha unika namn inom azure-prenumerationens omfång. För att säkerställa den här unikheten kan du använda mönstret initialer, sekvens, datum och suffix . Om du vill använda det här mönstret namnger du dina resurser genom att ange dina initialer, ett visst sekvensnummer, dagens datum och någon form av resursspecifikt suffix , till exempel rg för "resursgrupp". Följande miljövariabler använder det här mönstret. Ersätt platshållarvärdena i UNIQUE_VALUE och LOCATION med dina egna värden och kör kommandona i terminalen.

export UNIQUE_VALUE=<your unique value, such as mjg101424>
export RESOURCE_GROUP_NAME=${UNIQUE_VALUE}rg-passwordless
export LOCATION=<your desired Azure region for deploying your resources - for example, eastus>
export REGISTRY_NAME=${UNIQUE_VALUE}regpasswordless
export DB_SERVER_NAME=${UNIQUE_VALUE}dbpasswordless
export DB_NAME=demodb
export ACA_ENV=${UNIQUE_VALUE}envpasswordless
export ACA_NAME=${UNIQUE_VALUE}acapasswordless

Skapa sedan en resursgrupp med hjälp av följande kommando:

az group create \
    --name $RESOURCE_GROUP_NAME \
    --location $LOCATION

Skapa en Azure Database for PostgreSQL flexibel serverinstans

Azure Database for PostgreSQL – flexibel server är en fullständigt hanterad databastjänst som är utformad för att ge mer detaljerad kontroll och flexibilitet när det gäller databashanteringsfunktioner och konfigurationsinställningar. Det här avsnittet visar hur du skapar en flexibel Azure Database for PostgreSQL-serverinstans med hjälp av Azure CLI. Mer information finns i Snabbstart: Skapa en instans av Azure Database for PostgreSQL – flexibel server.

Skapa en flexibel Azure Database for PostgreSQL-serverinstans med hjälp av följande kommando:

az postgres flexible-server create \
    --name $DB_SERVER_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --database-name $DB_NAME \
    --public-access None \
    --sku-name Standard_B1ms \
    --tier Burstable \
    --active-directory-auth Enabled

Det tar några minuter att skapa regler för server, databas, administratör och brandvägg. Om kommandot lyckas ser utdata ut ungefär som i följande exempel:

{
  "connectionString": "postgresql://REDACTED:REDACTED@<DB_SERVER_NAME>.postgres.database.azure.com/<DB_NAME>?sslmode=require",
  "databaseName": "<DB_NAME>",
  "host": "<DB_SERVER_NAME>.postgres.database.azure.com",
  "id": "/subscriptions/REDACTED/resourceGroups/<RESOURCE_GROUP_NAME>/providers/Microsoft.DBforPostgreSQL/flexibleServers/<DB_SERVER_NAME>",
  "location": "East US",
  "password": "REDACTED",
  "resourceGroup": "<RESOURCE_GROUP_NAME>",
  "skuname": "Standard_B1ms",
  "username": "REDACTED",
  "version": "13"
}

Lägg till den aktuella inloggade användaren som Microsoft Entra-administratör i Azure Database for PostgreSQL – flexibel serverinstans med hjälp av följande kommandon:

ENTRA_ADMIN_NAME=$(az ad signed-in-user show --query userPrincipalName -o tsv)
az postgres flexible-server ad-admin create \
    --resource-group $RESOURCE_GROUP_NAME \
    --server-name $DB_SERVER_NAME \
    --display-name $ENTRA_ADMIN_NAME \
    --object-id $(az ad signed-in-user show --query id -o tsv)

Lyckade utdata är ett JSON-objekt inklusive egenskapen "type": "Microsoft.DBforPostgreSQL/flexibleServers/administrators".

Skapa en Microsoft Azure Container Registry-instans

Eftersom Quarkus är en molnbaserad teknik har den inbyggt stöd för att skapa containrar som körs i Container Apps. Container Apps är helt beroende av att ha ett containerregister som containeravbildningarna ska köras från. Container Apps har inbyggt stöd för Azure Container Registry.

Använd kommandot az acr create för att skapa Container Registry-instansen. I följande exempel skapas n Container Registry-instans med namnet med värdet för miljövariabeln ${REGISTRY_NAME}:

az acr create \
    --resource-group $RESOURCE_GROUP_NAME \
    --location ${LOCATION} \
    --name $REGISTRY_NAME \
    --sku Basic

Efter en kort tid bör du se JSON-utdata som innehåller följande rader:

  "provisioningState": "Succeeded",
  "publicNetworkAccess": "Enabled",
  "resourceGroup": "<YOUR_RESOURCE_GROUP>",

Hämta inloggningsservern för containerregisterinstansen med hjälp av följande kommando:

export LOGIN_SERVER=$(az acr show \
    --name $REGISTRY_NAME \
    --query 'loginServer' \
    --output tsv)
echo $LOGIN_SERVER

Ansluta Docker till Azure Container Registry-instansen

Logga in på containerregisterinstansen. När du loggar in kan du push-överföra en bild. Använd följande kommando för att logga in i registret:

az acr login --name $REGISTRY_NAME

Om du har loggat in på containerregisterinstansen bör du se Login Succeeded i slutet av kommandoutdata.

Skapa en miljö

En miljö i Azure Container Apps skapar en säker gräns runt en grupp med containerappar. Container Apps som distribueras till samma miljö distribueras i samma virtuella nätverk och skriver loggar till samma Log Analytics-arbetsyta.

Om det här är första gången du skapar en Azure Container Apps-miljö måste du förmodligen registrera Microsoft.App och Microsoft.OperationalInsights namnområden. Använd följande kommandon för att registrera namnrymderna:

az provider register --namespace Microsoft.App --wait
az provider register --namespace Microsoft.OperationalInsights --wait

Använd nu kommandot az containerapp env create för att skapa en miljö, som du ser i följande exempel:

az containerapp env create \
    --resource-group $RESOURCE_GROUP_NAME \
    --location $LOCATION \
    --name $ACA_ENV

Om du uppmanas att installera ett tillägg svarar du Y.

Anpassa den inbyggda molnkonfigurationen

Som molnbaserad teknik erbjuder Quarkus möjligheten att automatiskt generera containeravbildningar. Mer information finns i Containeravbildningar. Utvecklare kan sedan distribuera programavbildningen till en containerbaserad målplattform , till exempel Azure Container Apps.

Om du vill generera containeravbildningen använder du följande kommando för att lägga container-image-jib till tillägget i den lokala terminalen:

quarkus ext add container-image-jib

Quarkus ändrar POM för att säkerställa att tillägget ingår i <dependencies>. Om du uppmanas att installera något som heter JBangsvarar du ja och tillåter att det installeras.

Utdata bör se ut som i följande exempel:

[SUCCESS] ✅  Extension io.quarkus:quarkus-container-image-jib has been installed

Öppna filen pom.xml så bör du se följande beroenden som lagts till av container-image-jib tillägget:

<dependency>
  <groupId>io.quarkus</groupId>
  <artifactId>quarkus-container-image-jib</artifactId>
</dependency>

Lägg sedan till följande beroenden i pom.xml-filen för att stödja lösenordslös autentisering med Azure Database for PostgreSQL – flexibel server:

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity-extensions</artifactId>
    <version>1.1.20</version>
</dependency>

Som molnbaserad teknik stöder Quarkus begreppet konfigurationsprofiler. Quarkus har följande tre inbyggda profiler:

  • dev – Aktiverad i utvecklingsläge.
  • test – Aktiverad vid körning av tester.
  • prod – Standardprofilen när den inte körs i utvecklings- eller testläge.

Quarkus stöder valfritt antal namngivna profiler efter behov.

De återstående stegen i det här avsnittet leder dig till att ta bort kommentarer och anpassa värden i filen src/main/resources/application.properties . Se till att alla rader som börjar med # %prod. är avkommenterade genom att ta bort det ledande tecknet #.

Prefixet %prod. anger att dessa egenskaper är aktiva när de körs i profilen prod . Mer information om konfigurationsprofiler finns i Quarkus-dokumentationen.

Granska databaskonfigurationen

När du har avmarkerat egenskaperna bör databaskonfigurationen i src/main/resources/application.properties fil se ut som i följande exempel:

# Database configurations
%prod.quarkus.datasource.db-kind=postgresql
%prod.quarkus.datasource.jdbc.url=
%prod.quarkus.datasource.username=
%prod.quarkus.datasource.password=
%prod.quarkus.hibernate-orm.database.generation=create
%prod.quarkus.hibernate-orm.sql-load-script=no-file

Ta bort egenskapen %prod.quarkus.datasource.password eftersom den inte krävs när du använder lösenordslös autentisering med Azure Database for PostgreSQL – flexibel server. Uppdatera de andra databasanslutningsrelaterade egenskaperna %prod.quarkus.datasource.jdbc.url och %prod.quarkus.datasource.username med de värden som visas i följande exempel. Den slutliga konfigurationen bör se ut som i följande exempel:

# Database configurations
%prod.quarkus.datasource.db-kind=postgresql
%prod.quarkus.datasource.jdbc.url=jdbc:postgresql://${AZURE_POSTGRESQL_HOST}:${AZURE_POSTGRESQL_PORT}/${AZURE_POSTGRESQL_DATABASE}?\
authenticationPluginClassName=com.azure.identity.extensions.jdbc.postgresql.AzurePostgresqlAuthenticationPlugin\
&sslmode=require
%prod.quarkus.datasource.username=${AZURE_POSTGRESQL_USERNAME}
%prod.quarkus.hibernate-orm.database.generation=create
%prod.quarkus.hibernate-orm.sql-load-script=no-file

Värdet ${AZURE_POSTGRESQL_HOST}för , ${AZURE_POSTGRESQL_PORT}, ${AZURE_POSTGRESQL_DATABASE}och ${AZURE_POSTGRESQL_USERNAME} tillhandahålls av Azure Container Apps-miljön vid körning med hjälp av det lösenordslösa tillägget för Service Connector senare i den här artikeln.

I allmänhet förväntar du dig inte att data som sparas i databasen tas bort och fylls i igen med exempeldata i en produktionsmiljö. Därför kan du se att schemat för quarkus.hibernate-orm.database.generation anges så create att appen bara skapar schemat när det inte finns vid den första starten. Dessutom fylls databasen inte i förväg med några exempeldata eftersom hibernate-orm.sql-load-script anges som no-file. Den här inställningen skiljer sig från när du körde appen lokalt i utvecklingsläge tidigare. Standardvärdena i utvecklingsläge för quarkus.hibernate-orm.database.generation respektive hibernate-orm.sql-load-scriptdrop-and-create ärimport.sql, vilket innebär att appen alltid släpper och återskapar databasschemat och läser in de data som definierats i import.sql. Filen import.sql är en bekvämlighetsanläggning från Quarkus. Om filen src/main/resources/import.sql finns i Quarkus jar och värdet hibernate-orm.sql-load-script för egenskapen är import.sql, körs SQL DML-uttrycken i den här filen vid starttiden för appen.

Testa Din Quarkus-app lokalt med Azure Database for PostgreSQL – flexibel server

Innan du distribuerar Quarkus-appen till Azure Container Apps testar du anslutningen till azure database for PostgreSQL– flexibel serverinstans lokalt.

Lägg först till den lokala IP-adressen i brandväggsreglerna för Azure Database for PostgreSQL-flexibel serverinstans med hjälp av följande kommandon:

export AZ_LOCAL_IP_ADDRESS=$(curl -s https://whatismyip.akamai.com)

az postgres flexible-server firewall-rule create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $DB_SERVER_NAME \
    --rule-name $DB_SERVER_NAME-database-allow-local-ip \
    --start-ip-address $AZ_LOCAL_IP_ADDRESS \
    --end-ip-address $AZ_LOCAL_IP_ADDRESS

Ange sedan följande miljövariabler i din tidigare terminal. Dessa miljövariabler används för att ansluta till azure database for PostgreSQL– flexibel serverinstans från Quarkus-appen som körs lokalt:

export AZURE_POSTGRESQL_HOST=${DB_SERVER_NAME}.postgres.database.azure.com
export AZURE_POSTGRESQL_PORT=5432
export AZURE_POSTGRESQL_DATABASE=${DB_NAME}
export AZURE_POSTGRESQL_USERNAME=${ENTRA_ADMIN_NAME}

Kör Quarkus-appen lokalt för att testa anslutningen till den flexibla serverinstansen Azure Database for PostgreSQL. Använd följande kommandon för att starta appen i produktionsläge:

mvn clean package -DskipTests
java -jar target/quarkus-app/quarkus-run.jar

Om du vill komma åt Todo-programmet, öppna en ny webbläsare och gå till http://localhost:8080. Du bör se samma Todo-app som du såg när du körde appen lokalt i utvecklingsläge, utan några Todo-objekt.

Om du vill stoppa appen trycker du på Control+C.

Skapa containeravbildningen och skicka den till containerregistret

Använd nu följande kommando för att skapa själva programmet. Det här kommandot använder Jib-tillägget för att skapa containeravbildningen.

export TODO_QUARKUS_IMAGE_NAME=todo-quarkus-aca
export TODO_QUARKUS_IMAGE_TAG=${LOGIN_SERVER}/${TODO_QUARKUS_IMAGE_NAME}:1.0
quarkus build -Dquarkus.container-image.build=true -Dquarkus.container-image.image=${TODO_QUARKUS_IMAGE_TAG} --no-tests

Utdata ska sluta med BUILD SUCCESS.

Du kan kontrollera om containeravbildningen också genereras med hjälp av kommandoraden docker (CLI), som du ser i följande exempel:

docker images | grep ${TODO_QUARKUS_IMAGE_NAME}

Utdata ser ut ungefär som i följande exempel:

<LOGIN_SERVER_VALUE>/todo-quarkus-aca   1.0       0804dfd834fd   2 minutes ago   407MB

Push containerbilderna till containerregistret med hjälp av följande kommando:

docker push ${TODO_QUARKUS_IMAGE_TAG}

Utdata bör se ut ungefär som följande exempel:

The push refers to repository [<LOGIN_SERVER_VALUE>/todo-quarkus-aca]
188a550fce3d: Pushed
4e3afea591e2: Pushed
1db0eba807a6: Pushed
c72d9ccda0b2: Pushed
d7819b8a2d18: Pushed
d0e5cba6b262: Pushed
e0bac91f0f10: Pushed
1.0: digest: sha256:f9ccb476e2388efa0dfdf817625a94f2247674148a69b7e4846793e63c8be994 size: 1789

Distribuera Quarkus-appen till Azure Container Apps

Nu när du har push-överfört appavbildningen till containerregistret använder du följande kommando för att skapa en Azure Container Apps-instans för att köra appen när du har hämtat avbildningen från containerregistret:

az containerapp create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $ACA_NAME \
    --image $TODO_QUARKUS_IMAGE_TAG \
    --environment $ACA_ENV \
    --registry-server $LOGIN_SERVER \
    --registry-identity system \
    --target-port 8080 \
    --ingress 'external' \
    --min-replicas 1

Lyckade utdata är ett JSON-objekt inklusive egenskapen "type": "Microsoft.App/containerApps".

Anslut sedan Azure Database for PostgreSQL Flexible Server-instansen till containerappen med hjälp av Service Connector med hjälp av följande steg:

  1. Installera det lösenordslösa tillägget för Service Connector för Azure CLI med hjälp av följande kommando:

    az extension add --name serviceconnector-passwordless --upgrade --allow-preview true

  2. Anslut databasen till containerappen med en systemtilldelad hanterad identitet med hjälp av följande kommando:

    az containerapp connection create postgres-flexible \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $ACA_NAME \
    --target-resource-group $RESOURCE_GROUP_NAME \
    --server $DB_SERVER_NAME \
    --database $DB_NAME \
    --system-identity \
    --container $ACA_NAME

    Lyckade utdata är ett JSON-objekt inklusive egenskapen "type": "microsoft.servicelinker/linkers".

Hämta en fullständigt kvalificerad URL för att få åtkomst till Todo-programmet med hjälp av följande kommando:

export QUARKUS_URL=https://$(az containerapp show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $ACA_NAME \
    --query properties.configuration.ingress.fqdn -o tsv)
echo $QUARKUS_URL

Öppna en ny webbläsare till värdet ${QUARKUS_URL}. Om webbsidan inte återges korrekt väntar du ett tag och uppdaterar sidan.

Lägg sedan till ett nytt att göra-objekt med texten Deployed the Todo app to Container Apps. Markera det här objektet för att markera det som slutfört.

Skärmbild av todo-exempelappen som körs i Container Apps.

Få åtkomst till RESTful API (/api) för att hämta alla att göra-objekt som lagras i Azure Database for PostgreSQL, som du ser i följande exempel:

curl --verbose -k ${QUARKUS_URL}/api | jq .

Utdata bör se ut som i följande exempel:

* Connected to <aca-name>.<random-id>.eastus.azurecontainerapps.io (20.231.235.79) port 443 (#0)
> GET /api HTTP/2
> Host: <aca-name>.<random-id>.eastus.azurecontainerapps.io
> user-agent: curl/7.88.1
> accept: */*
>
< HTTP/2 200
< content-length: 88
< content-type: application/json;charset=UTF-8
<
[
  {
    "id": 1,
    "title": "Deployed the Todo app to Container Apps",
    "completed": true,
    "order": 1,
    "url": null
  }
]

Kontrollera att databasen har uppdaterats

Använd följande kommando för att kontrollera att databasen har uppdaterats med det nya att göra-objektet:

export ACCESS_TOKEN=$(az account get-access-token --resource-type oss-rdbms --output tsv --query accessToken)
az postgres flexible-server execute \
    --admin-user $ENTRA_ADMIN_NAME \
    --admin-password $ACCESS_TOKEN \
    --name $DB_SERVER_NAME \
    --database-name $DB_NAME \
    --querytext "select * from todo;"

Om du uppmanas att installera ett tillägg svarar du Y.

Utdata bör se ut ungefär som i följande exempel och bör innehålla samma objekt i användargränssnittet för Todo-appen som visades tidigare:

Successfully connected to <DB_SERVER_NAME>.
Ran Database Query: 'select * from todo;'
Retrieving first 30 rows of query output, if applicable.
Closed the connection to <DB_SERVER_NAME>
[
  {
    "completed": true,
    "id": 1,
    "ordering": 1,
    "title": "Deployed the Todo app to Container Apps",
    "url": null
  }
]

När du är klar tar du bort brandväggsregeln som gör att din lokala IP-adress kan komma åt azure database for PostgreSQL– flexibel serverinstans med hjälp av följande kommando:

az postgres flexible-server firewall-rule delete \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $DB_SERVER_NAME \
    --rule-name $DB_SERVER_NAME-database-allow-local-ip \
    --yes

Rensa resurser

För att undvika Azure-avgifter bör du rensa onödiga resurser. När klustret inte längre behövs använder du kommandot az group delete för att ta bort resursgruppen, containertjänsten, containerregistret och alla relaterade resurser.

git reset --hard
docker rmi ${TODO_QUARKUS_IMAGE_TAG}
az group delete --name $RESOURCE_GROUP_NAME --yes --no-wait

Du kanske också vill använda docker rmi för att ta bort containeravbildningarna postgres och testcontainers som genereras av Quarkus utvecklingsläge.

Nästa steg