Delen via

Een Java-toepassing implementeren met Quarkus in Azure Container Apps

  • Artikel

In dit artikel leest u hoe u Red Hat Quarkus snel implementeert in Microsoft Azure Container Apps met een eenvoudige CRUD-toepassing. De toepassing is een takenlijst met een JavaScript-front-end en een REST-eindpunt. Azure Database for PostgreSQL Flexibele server biedt de persistentielaag voor de app. In het artikel wordt beschreven hoe u uw app lokaal test en implementeert in Container Apps.

Vereisten

  • Een Azure-abonnement. Als u geen Azure-abonnement hebt, maakt u een gratis account voordat u begint.
  • Bereid een lokale computer voor waarop unix-achtig besturingssysteem is geïnstalleerd, bijvoorbeeld Ubuntu, macOS of Windows-subsysteem voor Linux.
  • Installeer een Java SE-implementatieversie 17 of hoger, bijvoorbeeld Microsoft-build van OpenJDK.
  • Installeer Maven, versie 3.9.8 of hoger.
  • Installeer Docker- voor uw besturingssysteem.
  • Installeer jq.
  • Installeer cURL.
  • Installeer de Quarkus CLI, versie 3.12.1 of hoger.
  • Installeer de Azure CLI om Azure CLI-opdrachten uit te voeren.
    • Meld u aan bij de Azure CLI met behulp van de opdracht az login. Volg de stappen die worden weergegeven in de terminal, om het verificatieproces te voltooien. Zie Aanmelden bij Azure met Azure CLI voor andere aanmeldingsopties.
    • Installeer de Azure CLI-extensie bij het eerste gebruik, wanneer u hierom wordt gevraagd. Zie Extensies gebruiken en beheren met de Azure CLI voor meer informatie over extensies.
    • Voer az version uit om de versie en afhankelijke bibliotheken te vinden die zijn geïnstalleerd. Voer az upgradeuit om een upgrade uit te voeren naar de nieuwste versie. Voor dit artikel is ten minste versie 2.61.0 van Azure CLI vereist.

Het app-project maken

Gebruik de volgende opdrachten om het Java-voorbeeldproject voor dit artikel te klonen. Het voorbeeld bevindt zich op GitHub.

git clone https://github.com/Azure-Samples/quarkus-azure
cd quarkus-azure
git checkout 2024-10-14
cd aca-quarkus

Als u een bericht ziet over detached HEAD status, is dit bericht veilig te negeren. Omdat voor dit artikel geen commits nodig zijn, is de detached HEAD-status geschikt.

Uw Quarkus-app lokaal testen

In de stappen in deze sectie ziet u hoe u de app lokaal uitvoert.

Quarkus ondersteunt het automatisch inrichten van niet-geconfigureerde services in de ontwikkelings- en testmodus. Quarkus verwijst naar deze mogelijkheid als dev-services. Stel dat u een Quarkus-functie opneemt, zoals verbinding maken met een databaseservice. U wilt de app testen, maar u hebt de verbinding met een echte database nog niet volledig geconfigureerd. Quarkus start automatisch een stub-versie van de relevante service en verbindt uw toepassing hiermee. Zie Dev Services Overview in the Quarkus documentation (Overzicht van Dev Services) voor meer informatie.

Zorg ervoor dat uw containeromgeving wordt uitgevoerd en gebruik de volgende opdracht om de dev-modus Quarkus in te voeren:

quarkus dev

In plaats van quarkus dev, kunt u hetzelfde doen met Maven met behulp van mvn quarkus:dev.

Mogelijk wordt u gevraagd of u telemetrie wilt verzenden van uw gebruik van quarkus dev-modus. Zo ja, antwoord zoals u wilt.

Quarkus dev-modus maakt live opnieuw laden met achtergrondcompilatie mogelijk. Als u een aspect van de broncode van uw app wijzigt en uw browser vernieuwt, ziet u de wijzigingen. Als er problemen zijn met compilatie of implementatie, laat een foutpagina u weten. Quarkus dev-modus luistert naar een foutopsporingsprogramma op poort 5005. Als u wilt wachten totdat het foutopsporingsprogramma wordt toegevoegd voordat u deze uitvoert, geeft -Dsuspend u de opdrachtregel door. Als u het foutopsporingsprogramma helemaal niet wilt, kunt u gebruiken -Ddebug=false.

De uitvoer moet eruitzien als in het volgende voorbeeld:

__  ____  __  _____   ___  __ ____  ______
 --/ __ \/ / / / _ | / _ \/ //_/ / / / __/
 -/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/
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>

Druk op w op de terminal waar de Quarkus-ontwikkelmodus wordt uitgevoerd. Met de w-toets wordt uw standaardwebbrowser geopend om de Todo toepassing weer te geven. U kunt ook rechtstreeks toegang krijgen tot de toepassings-GUI http://localhost:8080 .

Schermopname van de todo-voorbeeld-app.

Selecteer een paar taken in de takenlijst. De gebruikersinterface geeft de selectie aan met een doorhalende tekststijl. U kunt ook een nieuw taakitem toevoegen aan de takenlijst door Todo-apps verifiëren te typen en op Enter te drukken, zoals wordt weergegeven in de volgende schermafbeelding:

Schermopname van de todo-voorbeeld-app met nieuwe items toegevoegd.

Open de RESTful-API (/api) om alle taken op te halen die zijn opgeslagen in de lokale PostgreSQL-database:

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

De uitvoer moet eruitzien als in het volgende voorbeeld:

* 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://learn.microsoft.com/en-us/azure/developer/java/eclipse-microprofile/deploy-microprofile-quarkus-java-app-with-maven-plugin"
  },
  {
    "id": 3,
    "title": "Quarkus on Azure Container Apps",
    "completed": false,
    "order": 2,
    "url": "https://learn.microsoft.com/en-us/training/modules/deploy-java-quarkus-azure-container-app-postgres/"
  },
  {
    "id": 4,
    "title": "Quarkus on Azure Functions",
    "completed": false,
    "order": 3,
    "url": "https://learn.microsoft.com/en-us/azure/azure-functions/functions-create-first-quarkus"
  },
  {
    "id": 5,
    "title": "Verify Todo apps",
    "completed": false,
    "order": 5,
    "url": null
  }
]

Druk op q om quarkus-ontwikkelaarsmodus af te sluiten.

De Azure-resources maken om de Quarkus-app uit te voeren

In de stappen in deze sectie ziet u hoe u de volgende Azure-resources maakt om de Quarkus-voorbeeld-app uit te voeren:

  • Flexibele azure Database for PostgreSQL-server
  • Azure Container Registry
  • Azure Container Apps

Sommige van deze resources moeten unieke namen hebben binnen het bereik van het Azure-abonnement. Om deze uniekheid te garanderen, kunt u het initialen-, reeks-, datum-, achtervoegselpatroon gebruiken. Als u dit patroon wilt toepassen, noemt u uw resources door uw initialen, een reeksnummer, de datum van vandaag en een bepaald type resourcespecifiek achtervoegsel weer te geven, rg bijvoorbeeld voor 'resourcegroep'. In de volgende omgevingsvariabelen wordt dit patroon gebruikt. Vervang de tijdelijke aanduidingen in UNIQUE_VALUE en LOCATION door uw eigen waarden en voer de opdrachten uit in uw terminal.

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

Maak vervolgens een resourcegroep met de volgende opdracht:

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

Een flexibele serverinstantie van Azure Database for PostgreSQL maken

Azure Database for PostgreSQL flexibele server is een volledig beheerde databaseservice die is ontworpen om gedetailleerdere controle en flexibiliteit te bieden voor databasebeheerfuncties en configuratie-instellingen. In deze sectie wordt beschreven hoe u een exemplaar van een flexibele Azure Database for PostgreSQL-server maakt met behulp van de Azure CLI. Zie Quickstart: Een exemplaar van Azure Database for PostgreSQL - Flexible Server makenvoor meer informatie.

Maak een exemplaar van een flexibele Azure Database for PostgreSQL-server met behulp van de volgende opdracht:

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

Het duurt enkele minuten om de server, database, beheerder en firewallregels te maken. Als de opdracht is geslaagd, ziet de uitvoer er ongeveer als volgt uit:

{
  "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"
}

Voeg de huidige aangemelde gebruiker toe als Microsoft Entra-beheerder aan het exemplaar van Azure Database for PostgreSQL Flexible Server met behulp van de volgende opdrachten:

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)

Geslaagde uitvoer is een JSON-object met inbegrip van de eigenschap "type": "Microsoft.DBforPostgreSQL/flexibleServers/administrators".

Een Microsoft Azure Container Registry-exemplaar maken

Omdat Quarkus een systeemeigen cloudtechnologie is, biedt het ingebouwde ondersteuning voor het maken van containers die worden uitgevoerd in Container Apps. Container Apps is volledig afhankelijk van het hebben van een containerregister waaruit de containerinstallatiekopieën moeten worden uitgevoerd. Container Apps biedt ingebouwde ondersteuning voor Azure Container Registry.

Gebruik de opdracht az acr create om het Container Registry-exemplaar te maken. In het volgende voorbeeld wordt een Container Registry-exemplaar gemaakt met de waarde van uw omgevingsvariabele ${REGISTRY_NAME}:

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

Na korte tijd ziet u JSON-uitvoer die de volgende regels bevat:

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

Haal de loginserver voor de containerregisterinstantie op door de volgende commando te gebruiken:

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

Uw Docker met de Azure Container Registry-instantie verbinden

Meld u aan bij de containerregisterinstantie. Als u zich aanmeldt, kunt u een afbeelding pushen. Gebruik de volgende opdracht om u aan te melden bij het register:

az acr login --name $REGISTRY_NAME

Als u succesvol bent aangemeld bij het containerregister, ziet u Login Succeeded aan het einde van de opdrachtuitvoer.

Een omgeving maken

Een omgeving in Azure Container Apps maakt een veilige grens rond een groep container-apps. Container Apps die in dezelfde omgeving zijn geïmplementeerd, worden geïmplementeerd in hetzelfde virtuele netwerk en schrijven logboeken naar dezelfde Log Analytics-werkruimte.

Als dit de eerste keer is dat u een Azure Container Apps-omgeving maakt, moet u waarschijnlijk de Microsoft.App en Microsoft.OperationalInsights naamruimten registreren. Gebruik de volgende opdrachten om de naamruimten te registreren:

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

Gebruik nu de opdracht az containerapp env create om een omgeving te maken, zoals wordt weergegeven in het volgende voorbeeld:

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

Als u wordt gevraagd om een extensie te installeren, beantwoordt u Y.

De cloudeigen configuratie aanpassen

Quarkus biedt als cloudeigen technologie de mogelijkheid om automatisch containerinstallatiekopieën te genereren. Zie Containerinstallatiekopieën voor meer informatie. Ontwikkelaars kunnen vervolgens de installatiekopieën van de toepassing implementeren op een doelplatform in een container, bijvoorbeeld Azure Container Apps.

Als u de containerinstallatiekopieën wilt genereren, gebruikt u de volgende opdracht om de extensie toe te voegen in uw container-image-jib lokale terminal:

quarkus ext add container-image-jib

Quarkus wijzigt de POM om ervoor te zorgen dat de extensie wordt opgenomen in de <dependencies>. Als u wordt gevraagd iets met de naam JBangte installeren, antwoordt u ja en staat u toe dat deze wordt geïnstalleerd.

De uitvoer moet eruitzien als in het volgende voorbeeld:

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

Open het pom.xml-bestand en u ziet de volgende afhankelijkheden die zijn toegevoegd door de container-image-jib extensie:

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

Voeg vervolgens de volgende afhankelijkheden toe aan het pom.xml-bestand ter ondersteuning van verificatie zonder wachtwoord met Azure Database for PostgreSQL Flexible Server:

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

Quarkus ondersteunt als cloudeigen technologie het begrip configuratieprofielen. Quarkus heeft de volgende drie ingebouwde profielen:

  • dev - Geactiveerd wanneer deze zich in de ontwikkelmodus bevindt.
  • test - Geactiveerd bij het uitvoeren van tests.
  • prod - Het standaardprofiel wanneer het niet wordt uitgevoerd in de ontwikkelings- of testmodus.

Quarkus ondersteunt een willekeurig aantal benoemde profielen, indien nodig.

De resterende stappen in deze sectie leiden u naar het verwijderen van opmerkingen en het aanpassen van waarden in het bestand src/main/resources/application.properties . Zorg ervoor dat alle regels die beginnen met # %prod. worden ontgrendeld door het voorloopteken # te verwijderen.

Het %prod. voorvoegsel geeft aan dat deze eigenschappen actief zijn wanneer ze in het prod profiel worden uitgevoerd. Zie de Quarkus-documentatie voor meer informatie over configuratieprofielen.

De databaseconfiguratie onderzoeken

Nadat u de opmerkingen bij de eigenschappen hebt verwijderd, moet de databaseconfiguratie in de src/main/resources/application.properties bestand er als volgt uitzien:

# 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

Verwijder de eigenschap %prod.quarkus.datasource.password omdat deze niet vereist is bij het gebruik van verificatie zonder wachtwoord met flexibele Azure Database for PostgreSQL-server. Werk de andere eigenschappen %prod.quarkus.datasource.jdbc.url van de databaseverbinding en %prod.quarkus.datasource.username de waarden bij, zoals wordt weergegeven in het volgende voorbeeld. De uiteindelijke configuratie moet eruitzien als in het volgende voorbeeld:

# 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

De waarde van, ${AZURE_POSTGRESQL_HOST}, en ${AZURE_POSTGRESQL_PORT}${AZURE_POSTGRESQL_DATABASE} worden tijdens runtime geleverd door de Azure Container Apps-omgeving met behulp van ${AZURE_POSTGRESQL_USERNAME}de extensie serviceconnector zonder wachtwoord verderop in dit artikel.

Over het algemeen verwacht u niet dat de gegevens die in de database zijn opgeslagen, worden verwijderd en opnieuw worden gevuld met de voorbeeldgegevens in een productieomgeving. Daarom kunt u zien dat het schema voor quarkus.hibernate-orm.database.generation is opgegeven, create zodat de app alleen het schema maakt wanneer het niet bestaat bij het eerste opstarten. Bovendien wordt de database niet vooraf gevuld met voorbeeldgegevens, omdat hibernate-orm.sql-load-script is opgegeven als no-file. Deze instelling is anders dan wanneer u de app eerder lokaal in de ontwikkelmodus hebt uitgevoerd. De standaardwaarden in de ontwikkelingsmodus voor quarkus.hibernate-orm.database.generation en hibernate-orm.sql-load-script respectievelijk zijn drop-and-create , import.sql wat betekent dat de app altijd het databaseschema verwijdert en opnieuw maakt en de gegevens laadt die zijn gedefinieerd in import.sql. Het bestand import.sql is een gemaksfaciliteit van Quarkus. Als het bestand src/main/resources/import.sql bestaat in het Jar-bestand Quarkus en de waarde van de hibernate-orm.sql-load-script eigenschap is import.sql, worden de SQL DML-instructies in dit bestand uitgevoerd tijdens het opstarten van de app.

Uw Quarkus-app lokaal testen met een flexibele Azure Database for PostgreSQL-server

Voordat u de Quarkus-app implementeert in Azure Container Apps, test u lokaal de verbinding met de flexibele serverinstance van Azure Database for PostgreSQL.

Voeg eerst het lokale IP-adres toe aan de firewallregels voor het flexibele serverexemplaar van Azure Database for PostgreSQL met de volgende opdrachten.

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

Stel vervolgens de volgende omgevingsvariabelen in uw vorige terminal in. Deze omgevingsvariabelen worden gebruikt om verbinding te maken met het flexibele Server-exemplaar van Azure Database for PostgreSQL vanuit de Quarkus-app die lokaal wordt uitgevoerd:

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}

Voer de Quarkus-app lokaal uit om de verbinding met het flexibele serverexemplaar van Azure Database for PostgreSQL te testen. Gebruik de volgende opdrachten om de app te starten in de productiemodus:

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

Om toegang te krijgen tot de Todo-toepassing, opent u een nieuwe webbrowser naar http://localhost:8080. U zou dezelfde taken-app moeten zien als u hebt gezien toen u de app lokaal in de ontwikkelmodus uitvoerde, zonder takenitems.

Als u de app wilt stoppen, drukt u op Control+C.

Bouw de containerafbeelding en push deze naar het containerregister

Gebruik nu de volgende opdracht om de toepassing zelf te bouwen. Met deze opdracht wordt de Jib-extensie gebruikt om de containerinstallatiekopieën te bouwen.

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

De uitvoer moet eindigen op BUILD SUCCESS.

U kunt controleren of de containerimage wordt gegenereerd met de opdrachtregel docker, zoals weergegeven in het volgende voorbeeld:

docker images | grep ${TODO_QUARKUS_IMAGE_NAME}

De uitvoer ziet er ongeveer als volgt uit:

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

Verplaats de containerafbeeldingen naar het containerregister met behulp van de volgende commando:

docker push ${TODO_QUARKUS_IMAGE_TAG}

De uitvoer moet er als in het volgende voorbeeld uitzien:

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

De Quarkus-app implementeren in Azure Container Apps

Nu u de installatiekopie van de app naar het containerregister hebt gepusht, gebruikt u de volgende opdracht om een Azure Container Apps-exemplaar te maken om de app uit te voeren nadat u de installatiekopie uit het containerregister hebt opgehaald:

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

Geslaagde uitvoer is een JSON-object met inbegrip van de eigenschap "type": "Microsoft.App/containerApps".

Verbind vervolgens het Azure Database for PostgreSQL Flexible Server-exemplaar met de container-app met behulp van Service Connector met behulp van de volgende stappen:

  1. Installeer de serviceconnector-extensie zonder wachtwoord voor de Azure CLI met behulp van de volgende opdracht:

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

  2. Verbind de database met de container-app met een door het systeem toegewezen beheerde identiteit met behulp van de volgende opdracht:

    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

    Geslaagde uitvoer is een JSON-object met inbegrip van de eigenschap "type": "microsoft.servicelinker/linkers".

Haal een volledig gekwalificeerde URL op voor toegang tot de Todo-toepassing met behulp van de volgende opdracht:

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

Open een nieuwe webbrowser met de waarde van ${QUARKUS_URL}. Als de webpagina niet correct wordt weergegeven, wacht u even en vernieuwt u de pagina.

Voeg vervolgens een nieuw taakitem toe met de tekst Deployed the Todo app to Container Apps. Selecteer dit item om het als voltooid te markeren.

Schermopname van de todo-voorbeeld-app die wordt uitgevoerd in Container Apps.

Open de RESTful-API (/api) om alle taken op te halen die zijn opgeslagen in Azure Database for PostgreSQL, zoals wordt weergegeven in het volgende voorbeeld:

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

De uitvoer moet eruitzien als in het volgende voorbeeld:

* 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
  }
]

Controleer of de database is bijgewerkt

Gebruik het volgende commando om te controleren of de database is bijgewerkt met de nieuwe taak:

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;"

Als u wordt gevraagd om een extensie te installeren, beantwoordt u Y.

De uitvoer moet er ongeveer uitzien als in het volgende voorbeeld en moet hetzelfde item bevatten in de todo-app-GUI die eerder is weergegeven:

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
  }
]

Wanneer u klaar bent, verwijdert u de firewallregel waarmee uw lokale IP-adres toegang heeft tot het flexibele serverexemplaren van Azure Database for PostgreSQL met behulp van de volgende opdracht:

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

Resources opschonen

Om Azure-kosten te vermijden, moet u overbodige resources opschonen. Wanneer het cluster niet meer nodig is, gebruikt u de opdracht az group delete om de resourcegroep, de containerservice, het containerregister en alle gerelateerde resources te verwijderen.

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

Mogelijk wilt u ook de docker rmipostgres installatiekopieën testcontainers en containerinstallatiekopieën verwijderen die zijn gegenereerd door de dev-modus quarkus.

Volgende stappen