Distribuera ett Java-program med Quarkus i ett Azure Kubernetes Service-kluster
Den här artikeln visar hur du snabbt distribuerar Red Hat Quarkus på Azure Kubernetes Service (AKS) 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 AKS.
Förutsättningar
- Om du inte har en Azure-prenumeration skapar du ett kostnadsfritt Azure-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.
- Azure CLI för Unix-liknande miljöer. Den här artikeln kräver endast Bash-varianten av Azure CLI.
En utvecklare bör installera Azure CLI och logga in interaktivt med kommandot az login för att logga in på Azure innan du använder StandardAzureCredential i koden. az login- Den här artikeln kräver minst version 2.61.0 av Azure CLI.
Skapa appprojektet
Använd följande kommando 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 2024-12-16
cd aks-quarkus
Om du ser ett meddelande om att vara i frånkopplat HEAD-tillstånd är det här meddelandet säkert att ignorera. Eftersom den här artikeln inte kräver några incheckningar är frånkopplat HEAD-tillstånd 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 containerbaserad 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-aks 1.0.0-SNAPSHOT on JVM (powered by Quarkus 3.2.0.Final) started in 3.377s. 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-orm-panache, 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.
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:
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://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
}
]
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 Kubernetes Service (AKS)
Kommentar
Den här artikeln inaktiverar PostgreSQL-autentisering för att illustrera metodtips för säkerhet. Microsoft Entra-ID används för att autentisera anslutningen till servern. Om du behöver aktivera PostgreSQL-autentisering kan du läsa Snabbstart: Använda Java och JDBC med Azure Database for PostgreSQL – flexibel server och välj fliken Lösenord .
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 UNIQUE_VALUE och LOCATION med dina egna värden och kör sedan följande kommandon i terminalen:
export UNIQUE_VALUE=<your unique value, such as ejb010717>
export RESOURCE_GROUP_NAME=${UNIQUE_VALUE}rg
export LOCATION=<your desired Azure region for deploying your resources - for example, northeurope>
export REGISTRY_NAME=${UNIQUE_VALUE}reg
export DB_SERVER_NAME=${UNIQUE_VALUE}db
export DB_NAME=demodb
export CLUSTER_NAME=${UNIQUE_VALUE}aks
export AKS_NS=${UNIQUE_VALUE}ns
Skapa en flexibel Azure Database for PostgreSQL-server
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 över databashanteringsfunktioner och konfigurationsinställningar. Det här avsnittet visar hur du skapar en Azure Database for PostgreSQL – flexibel serverinstans med hjälp av Azure CLI.
Skapa först en resursgrupp som ska innehålla databasservern och andra resurser med hjälp av följande kommando:
az group create \
--name $RESOURCE_GROUP_NAME \
--location $LOCATION
Skapa sedan en flexibel Azure Database for PostgreSQL-serverinstans med hjälp av följande kommando:
az postgres flexible-server create \
--name $DB_SERVER_NAME \
--database-name $DB_NAME \
--resource-group $RESOURCE_GROUP_NAME \
--location $LOCATION \
--public-access 0.0.0.0 \
--sku-name Standard_B1ms \
--tier Burstable \
--active-directory-auth Enabled \
--yes
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@ejb011212qdb.postgres.database.azure.com/demodb?sslmode=require",
"databaseName": "demodb",
"firewallName": "AllowAllAzureServicesAndResourcesWithinAzureIps_2024-12-12_14-30-22",
"host": "ejb011212qdb.postgres.database.azure.com",
"id": "/subscriptions/c7844e91-b11d-4a7f-ac6f-996308fbcdb9/resourceGroups/ejb011211sfi/providers/Microsoft.DBforPostgreSQL/flexibleServers/ejb011212qdb",
"location": "East US 2",
"password": "REDACTED",
"resourceGroup": "ejb011211sfi",
"skuname": "Standard_B1ms",
"username": "sorrycamel2",
"version": "16"
}
Testa appen lokalt med Azure Database for PostgreSQL – flexibel server
I föregående avsnitt testade du Quarkus-appen lokalt i utvecklingsläge med en PostgreSQL-databas etablerad som en Docker-container. Testa nu anslutningen till Azure Database for PostgreSQL – flexibel serverinstans lokalt.
Lägg först 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 account show --query user.name --output 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 --output tsv)
Lyckade utdata är ett JSON-objekt inklusive egenskapen "type": "Microsoft.DBforPostgreSQL/flexibleServers/administrators".
Lägg sedan till den lokala IP-adressen i brandväggsreglerna för Azure Database for PostgreSQL Flexible Server-instansen genom att följa dessa steg:
Hämta den lokala IP-adressen för din dator där du kör Quarkus-appen lokalt. Besök till exempel https://whatismyipaddress.com för att hämta din offentliga IP v4-adress.
Definiera en miljövariabel med den lokala IP-adress som du fick i föregående steg.
export AZ_LOCAL_IP_ADDRESS=<your local IP address>Kör följande kommando för att lägga till den lokala IP-adressen i brandväggsreglerna för Azure Database for PostgreSQL–flexibel serverinstans:
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 server-instans 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}
Kommentar
Värdena för miljövariablerna AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASEoch AZURE_POSTGRESQL_USERNAME läss av databaskonfigurationsegenskaper som definierats i filen src/main/resources/application.properties som introducerades i föregående avsnitt. Dessa värden matas automatiskt in i appen vid körning med hjälp av det lösenordslösa tillägget för Service Connector när du distribuerar Quarkus-appen till AKS-klustret senare i den här artikeln.
Kör nu Quarkus-appen lokalt för att testa anslutningen till Azure Database for PostgreSQL – flexibel serverinstans. Använd följande kommando för att starta appen i produktionsläge:
quarkus build
java -jar target/quarkus-app/quarkus-run.jar
Kommentar
Om appen inte kan börja med ett felmeddelande som liknar ERROR [org.hib.eng.jdb.spi.SqlExceptionHelper] (JPA Startup Thread) Acquisition timeout while waiting for new connectionär det troligtvis på grund av nätverksinställningen för den lokala datorn. Försök att välja Lägg till aktuell klient-IP-adress från Azure Portal igen. Mer information finns i avsnittet Skapa en brandväggsregel när servern har skapats i Skapa och hantera brandväggsregler för Azure Database for PostgreSQL – flexibel server med hjälp av Azure Portal. Kör sedan appen igen.
Öppna en ny webbläsare för att http://localhost:8080 få åtkomst till Todo-programmet. Du bör se Todo-appen som liknar det du såg när du körde appen lokalt i utvecklingsläge.
Skapa en Azure Container Registry-instans
Eftersom Quarkus är en molnbaserad teknik har den inbyggt stöd för att skapa containrar som körs i Kubernetes. Kubernetes är helt beroende av att ha ett containerregister som containeravbildningarna ska köras från. AKS har inbyggt stöd för Azure Container Registry.
Använd kommandot az acr create för att skapa containerregisterinstansen. I följande exempel skapas en containerregisterinstans 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 Container Registry-instansen 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 containerregisterinstansen
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 ett AKS-kluster
Använd kommandot az aks create för att skapa ett AKS-kluster. I följande exempel skapas ett kluster med namnet med värdet för miljövariabeln ${CLUSTER_NAME} med en nod. Klustret är anslutet till den containerregisterinstans som du skapade i ett föregående steg. Det tar flera minuter att slutföra det här kommandot. Klustret startas med hanterad identitet aktiverad. Det här steget är nödvändigt för den lösenordslösa databasanslutningen.
az aks create \
--resource-group $RESOURCE_GROUP_NAME \
--name $CLUSTER_NAME \
--attach-acr $REGISTRY_NAME \
--node-count 1 \
--generate-ssh-keys \
--enable-managed-identity
Efter några minuter slutförs kommandot och returnerar JSON-formaterad information om klustret, inklusive följande utdata:
"nodeResourceGroup": "MC_<your resource_group_name>_<your cluster name>_<your region>",
"privateFqdn": null,
"provisioningState": "Succeeded",
"resourceGroup": "<your resource group name>",
Ansluta till AKS-klustret
Om du vill hantera ett Kubernetes-kluster använder kubectldu kommandoradsklienten Kubernetes. Om du vill installera kubectl lokalt använder du kommandot az aks install-cli , som du ser i följande exempel:
az aks install-cli
Mer information om kubectlfinns i Kommandoradsverktyget (kubectl) i Kubernetes-dokumentationen.
Om du vill konfigurera kubectl för att ansluta till kubernetes-klustret använder du kommandot az aks get-credentials , som du ser i följande exempel. Det här kommandot laddar ned autentiseringsuppgifter och konfigurerar Kubernetes CLI för att använda dem.
az aks get-credentials \
--resource-group $RESOURCE_GROUP_NAME \
--name $CLUSTER_NAME \
--overwrite-existing \
--admin
Lyckade utdata innehåller text som liknar följande exempel:
Merged "ejb010718aks-admin" as current context in /Users/edburns/.kube/config
Du kanske tycker att det är användbart för alias k till kubectl. I så fall använder du följande kommando:
alias k=kubectl
Om du vill verifiera anslutningen till klustret använder du kubectl get kommandot för att returnera en lista över klusternoderna, som du ser i följande exempel:
kubectl get nodes
Följande exempelutdata visar den enskilda nod som skapades i föregående steg. Kontrollera att status för noden är Klar:
NAME STATUS ROLES AGE VERSION
aks-nodepool1-xxxxxxxx-yyyyyyyyyy Ready agent 76s v1.28.9
Skapa ett nytt namnområde i AKS
Använd följande kommando för att skapa ett nytt namnområde i Kubernetes-tjänsten för din Quarkus-app:
kubectl create namespace ${AKS_NS}
Utdata bör se ut som i följande exempel:
namespace/<your namespace> created
Skapa en tjänstanslutning i AKS med Service Connector
I det här avsnittet skapar du en tjänstanslutning mellan AKS-klustret och Azure Database for PostgreSQL – flexibel server med microsoft entra-arbetsbelastnings-ID med Service Connector. Med den här anslutningen kan AKS-klustret komma åt Azure Database for PostgreSQL – flexibel server utan att använda SQL-autentisering.
Kör följande kommandon för att skapa en anslutning mellan AKS-klustret och PostgreSQL-databasen med microsoft entra-arbetsbelastnings-ID med Service Connector:
# Register the Service Connector and Kubernetes Configuration resource providers
az provider register --namespace Microsoft.ServiceLinker --wait
az provider register --namespace Microsoft.KubernetesConfiguration --wait
# Install the Service Connector passwordless extension
az extension add --name serviceconnector-passwordless --upgrade --allow-preview true
# Retrieve the AKS cluster and Azure SQL Server resource IDs
export AKS_CLUSTER_RESOURCE_ID=$(az aks show \
--resource-group $RESOURCE_GROUP_NAME \
--name $CLUSTER_NAME \
--query id \
--output tsv)
export AZURE_POSTGRESQL_RESOURCE_ID=$(az postgres flexible-server show \
--resource-group $RESOURCE_GROUP_NAME \
--name $DB_SERVER_NAME \
--query id \
--output tsv)
# Create a user-assigned managed identity used for workload identity
export USER_ASSIGNED_IDENTITY_NAME=workload-identity-uami
az identity create \
--resource-group ${RESOURCE_GROUP_NAME} \
--name ${USER_ASSIGNED_IDENTITY_NAME}
# Retrieve the user-assigned managed identity resource ID
export UAMI_RESOURCE_ID=$(az identity show \
--resource-group ${RESOURCE_GROUP_NAME} \
--name ${USER_ASSIGNED_IDENTITY_NAME} \
--query id \
--output tsv)
# Create a service connection between your AKS cluster and your PostgreSQL database using Microsoft Entra Workload ID
az aks connection create postgres-flexible \
--connection akspostgresconn \
--kube-namespace $AKS_NS \
--source-id $AKS_CLUSTER_RESOURCE_ID \
--target-id $AZURE_POSTGRESQL_RESOURCE_ID/databases/$DB_NAME \
--workload-identity $UAMI_RESOURCE_ID
Förekomsten av följande JSON i utdata från det sista kommandot i föregående steg anger en lyckad installation av tjänstanslutningen:
"name": "akspostgresconn",
"provisioningState": "Succeeded",
Kommentar
Vi rekommenderar att du använder Microsoft Entra-arbetsbelastnings-ID för säker åtkomst till din flexibla Azure Database for PostgreSQL-server utan att använda autentisering med användarnamn/lösenord. Om du behöver använda autentisering med användarnamn/lösenord ignorerar du föregående steg i det här avsnittet och använder användarnamnet och lösenordet för att ansluta till databasen.
Hämta tjänstkonto och hemlighet som skapats av Service Connector
Om du vill autentisera till Azure Database for PostgreSQL – flexibel server måste du hämta tjänstkontot och Kubernetes-hemligheten som skapats av Service Connector. Följ anvisningarna i avsnittet Uppdatera containern i Självstudie: Ansluta en AKS-app till Azure SQL Database. Välj alternativet Skapa en distribution direkt med hjälp av YAML-exempelkodfragmentet och använd följande steg:
Från de markerade avsnitten i kubernetes-exempeldistributionens YAML kopierar du värdena
serviceAccountNameför ochsecretRef.name, som representeras som<service-account-name>och<secret-name>i följande exempel:serviceAccountName: <service-account-name> containers: - name: raw-linux envFrom: - secretRef: name: <secret-name>Dessa värden används i nästa avsnitt för att distribuera Quarkus-programmet till AKS-klustret.
Anpassa den inbyggda molnkonfigurationen
Som molnbaserad teknik erbjuder Quarkus möjligheten att automatiskt konfigurera resurser för Kubernetes, Red Hat OpenShift och Knative. Mer information finns i Quarkus Kubernetes-guiden, Quarkus OpenShift-guiden och Quarkus Knative-guiden. Utvecklare kan distribuera programmet till ett Kubernetes-målkluster genom att använda de genererade manifesten.
Om du vill generera lämpliga Kubernetes-resurser använder du följande kommando för att lägga till tilläggen quarkus-kubernetes och container-image-jib i den lokala terminalen:
quarkus ext add kubernetes container-image-jib
Quarkus ändrar POM för att säkerställa att dessa tillägg visas som <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-kubernetes has been installed
[SUCCESS] ✅ Extension io.quarkus:quarkus-container-image-jib has been installed
Om du vill kontrollera att tilläggen har lagts till kan du köra git diff och undersöka utdata.
Som molnbaserad teknik stöder Quarkus begreppet konfigurationsprofiler. Quarkus har följande tre inbyggda profiler:
dev– Aktiverad i utvecklingslägetest– Aktiverad när tester körsprod– 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 instruerar dig att anpassa värden i filen src/main/resources/application.properties .
Prefixet prod. anger att dessa egenskaper är aktiva när de körs i profilen prod . Mer information om konfigurationsprofiler finns i Quarkus-dokumentationen.
Konfiguration av databas
Granska följande databaskonfigurationsvariabler. De databasanslutningsrelaterade egenskaperna %prod.quarkus.datasource.jdbc.url och %prod.quarkus.datasource.username läsvärdena från miljövariablerna AZURE_POSTGRESQL_HOST, , AZURE_POSTGRESQL_PORTAZURE_POSTGRESQL_DATABASErespektive .AZURE_POSTGRESQL_USERNAME Dessa miljövariabler mappas till hemliga värden som lagrar databasanslutningsinformationen. Av säkerhetsskäl genereras de automatiskt med hjälp av det lösenordslösa tillägget för Service Connector, vilket visas någon annanstans i den här artikeln.
# Database configurations
%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.datasource.jdbc.acquisition-timeout=10
%prod.quarkus.hibernate-orm.database.generation=drop-and-create
%prod.quarkus.hibernate-orm.sql-load-script=import.sql
Kubernetes-konfiguration
Granska följande Kubernetes-konfigurationsvariabler. service-type är inställd load-balancer på för att komma åt appen externt. Ersätt värdena <service-account-name> för och <secret-name> med värdena för de faktiska värden som du kopierade i föregående avsnitt.
# Kubernetes configurations
%prod.quarkus.kubernetes.deployment-target=kubernetes
%prod.quarkus.kubernetes.service-type=load-balancer
%prod.quarkus.kubernetes.labels."azure.workload.identity/use"=true
%prod.quarkus.kubernetes.service-account=<service-account-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_CLIENT_ID.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_CLIENT_ID.with-key=AZURE_POSTGRESQL_CLIENTID
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_HOST.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_HOST.with-key=AZURE_POSTGRESQL_HOST
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_PORT.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_PORT.with-key=AZURE_POSTGRESQL_PORT
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_DATABASE.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_DATABASE.with-key=AZURE_POSTGRESQL_DATABASE
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_USERNAME.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_USERNAME.with-key=AZURE_POSTGRESQL_USERNAME
De andra Kubernetes-konfigurationerna anger mappningen av de hemliga värdena till miljövariablerna i Quarkus-programmet. Hemligheten <secret-name> innehåller information om databasanslutningen. Nycklarna AZURE_POSTGRESQL_CLIENTID, AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASEoch AZURE_POSTGRESQL_USERNAME i den hemliga kartan till AZURE_CLIENT_IDmiljövariablerna , AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASErespektive AZURE_POSTGRESQL_USERNAME .
Om du vill undersöka hemligheterna direkt med kubectl använder du kommandon som liknar följande exempel:
kubectl -n ${AKS_NS} get secret <secret-name> -o jsonpath="{.data.AZURE_POSTGRESQL_USERNAME}" | base64 --decode
Konfiguration av containeravbildning
Som molnbaserad teknik stöder Quarkus generering av OCI-containeravbildningar som är kompatibla med Docker. Ersätt värdet <LOGIN_SERVER_VALUE> för med det faktiska värdet för ${LOGIN_SERVER} miljövariabeln.
# Container Image Build
%prod.quarkus.container-image.build=true
%prod.quarkus.container-image.image=<LOGIN_SERVER_VALUE>/todo-quarkus-aks:1.0
Som en sista kontroll, när du slutför alla nödvändiga ersättningar i application.properties, får det inte finnas några förekomster av < tecknet. Om det finns det kontrollerar du att du har slutfört alla nödvändiga ersättningar.
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 Kubernetes- och Jib-tilläggen för att skapa containeravbildningen.
quarkus build --no-tests
Utdata ska sluta med BUILD SUCCESS. Kubernetes-manifestfilerna genereras i mål/kubernetes, som du ser i följande exempel:
tree target/kubernetes
target/kubernetes
├── kubernetes.json
└── kubernetes.yml
0 directories, 2 files
Du kan kontrollera om containeravbildningen också genereras med hjälp av docker kommandoraden (CLI). Utdata ser ut ungefär som i följande exempel:
docker images | grep todo-quarkus-aks
<LOGIN_SERVER_VALUE>/todo-quarkus-aks 1.0 b13c389896b7 18 minutes ago 422MB
Skicka containeravbildningarna till containerregistret med hjälp av följande kommando:
export TODO_QUARKUS_TAG=$(docker images | grep todo-quarkus-aks | head -n1 | cut -d " " -f1)
echo ${TODO_QUARKUS_TAG}
docker push ${TODO_QUARKUS_TAG}:1.0
Utdata bör se ut ungefär som följande exempel:
The push refers to repository [<LOGIN_SERVER_VALUE>/todo-quarkus-aks]
dfd615499b3a: Pushed
56f5cf1aa271: Pushed
4218d39b228e: Pushed
b0538737ed64: Pushed
d13845d85ee5: Pushed
60609ec85f86: Pushed
1.0: digest: sha256:0ffd70d6d5bb3a4621c030df0d22cf1aa13990ca1880664d08967bd5bab1f2b6 size: 1995
Nu när du har push-överfört appen till containerregistret kan du be AKS att köra appen.
Distribuera Quarkus-appen till AKS
Stegen i det här avsnittet visar hur du kör Quarkus-exempelappen på de Azure-resurser som du skapade.
Använda kubectl apply för att distribuera Quarkus-appen till AKS
Distribuera Kubernetes-resurserna med på kubectl kommandoraden, som du ser i följande exempel:
kubectl apply -f target/kubernetes/kubernetes.yml -n ${AKS_NS}
Utdata bör se ut som i följande exempel:
service/quarkus-todo-demo-app-aks created
deployment.apps/quarkus-todo-demo-app-aks created
Kontrollera att appen körs med hjälp av följande kommando:
kubectl -n $AKS_NS get pods
Om värdet för fältet STATUS visar något annat än Runningfelsöker du och löser problemet innan du fortsätter. Det kan hjälpa att undersöka poddloggarna med hjälp av följande kommando:
kubectl -n $AKS_NS logs $(kubectl -n $AKS_NS get pods | grep quarkus-todo-demo-app-aks | cut -d " " -f1)
EXTERNAL-IP Hämta för att få åtkomst till Todo-programmet med hjälp av följande kommando:
kubectl get svc -n ${AKS_NS}
Utdata bör se ut som i följande exempel:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
quarkus-todo-demo-app-aks LoadBalancer 10.0.236.101 20.12.126.200 80:30963/TCP 37s
Du kan använda följande kommando för att spara värdet EXTERNAL-IP för i en miljövariabel som en fullständigt kvalificerad URL:
export QUARKUS_URL=http://$(kubectl get svc -n ${AKS_NS} | grep quarkus-todo-demo-app-aks | cut -d " " -f10)
echo $QUARKUS_URL
Öppna en ny webbläsare till värdet ${QUARKUS_URL}. Lägg sedan till ett nytt att göra-objekt med texten Deployed the Todo app to AKS. Välj också objektet Introduction to Quarkus Todo App som slutfört.
Få åtkomst till RESTful API (/api) för att hämta alla att göra-objekt som lagras i Azure PostgreSQL-databasen, som du ser i följande exempel:
curl --verbose ${QUARKUS_URL}/api | jq .
Utdata bör se ut som i följande exempel:
* Connected to 20.237.68.225 (20.237.68.225) port 80 (#0)
> GET /api HTTP/1.1
> Host: 20.237.68.225
> User-Agent: curl/7.88.1
> Accept: */*
>
< HTTP/1.1 200 OK
< content-length: 828
< Content-Type: application/json;charset=UTF-8
<
[
{
"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": "Deployed the Todo app to AKS",
"completed": false,
"order": 5,
"url": null
},
{
"id": 1,
"title": "Introduction to Quarkus Todo App",
"completed": true,
"order": 0,
"url": null
}
]
Kontrollera att databasen har uppdaterats
Kör följande kommando för att kontrollera att databasen nu har uppdaterats korrekt:
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 och utdata från curl kommandot 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": false,
"id": 2,
"ordering": 1,
"title": "Quarkus on Azure App Service",
"url": "https://learn.microsoft.com/en-us/azure/developer/java/eclipse-microprofile/deploy-microprofile-quarkus-java-app-with-maven-plugin"
},
{
"completed": false,
"id": 3,
"ordering": 2,
"title": "Quarkus on Azure Container Apps",
"url": "https://learn.microsoft.com/en-us/training/modules/deploy-java-quarkus-azure-container-app-postgres/"
},
{
"completed": false,
"id": 4,
"ordering": 3,
"title": "Quarkus on Azure Functions",
"url": "https://learn.microsoft.com/en-us/azure/azure-functions/functions-create-first-quarkus"
},
{
"completed": false,
"id": 5,
"ordering": 5,
"title": "Deployed the Todo app to AKS",
"url": null
},
{
"completed": true,
"id": 1,
"ordering": 0,
"title": "Introduction to Quarkus Todo App",
"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 server-instans 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_TAG}:1.0
docker rmi postgres
az identity delete --ids ${UAMI_RESOURCE_ID}
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 genereras av Quarkus dev-läge.
Nästa steg
Azure Kubernetes Service