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 podsistem za 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 eller Podman 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-07-08
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 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, Docker eller Podman, 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 bli tillfrågad 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 (ACR)
- Azure Kubernetes Service (AKS)
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, LOCATIONoch DB_PASSWORD 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 DB_ADMIN=demouser
export DB_PASSWORD='<your desired password for the database server - for example, Secret123456>'
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. Mer information finns i Snabbstart: Skapa en Azure Database for PostgreSQL – flexibel serverinstans med 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 \
--resource-group $RESOURCE_GROUP_NAME \
--admin-user $DB_ADMIN \
--admin-password $DB_PASSWORD \
--database-name $DB_NAME \
--public-access 0.0.0.0 \
--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://<DB_ADMIN>:<DB_PASSWORD>@<DB_SERVER_NAME>.postgres.database.azure.com/<DB_NAME>?sslmode=require",
"databaseName": "<DB_NAME>",
"firewallName": "AllowAllAzureServicesAndResourcesWithinAzureIps_2024-7-5_14-39-45",
"host": "<DB_SERVER_NAME>.postgres.database.azure.com",
"id": "/subscriptions/REDACTED/resourceGroups/<RESOURCE_GROUP_NAME>/providers/Microsoft.DBforPostgreSQL/flexibleServers/<DB_SERVER_NAME>",
"location": "North Europe",
"password": "<DB_PASSWORD>",
"resourceGroup": "<RESOURCE_GROUP_NAME>",
"skuname": "Standard_D2s_v3",
"username": "<DB_ADMIN>",
"version": "13"
}
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 (ACR).
Använd kommandot az acr create för att skapa ACR-instansen. I följande exempel skapas en ACR-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 \
--admin-enabled
Efter en kort tid bör du se JSON-utdata som innehåller följande rader:
"provisioningState": "Succeeded",
"publicNetworkAccess": "Enabled",
"resourceGroup": "<YOUR_RESOURCE_GROUP>",
Ansluta docker till ACR-instansen
Logga in på ACR-instansen. När du loggar in kan du push-överföra en bild. Använd följande kommandon för att verifiera anslutningen:
export LOGIN_SERVER=$(az acr show \
--name $REGISTRY_NAME \
--query 'loginServer' \
--output tsv)
echo $LOGIN_SERVER
export USER_NAME=$(az acr credential show \
--name $REGISTRY_NAME \
--query 'username' \
--output tsv)
echo $USER_NAME
export PASSWORD=$(az acr credential show \
--name $REGISTRY_NAME \
--query 'passwords[0].value' \
--output tsv)
echo $PASSWORD
docker login $LOGIN_SERVER -u $USER_NAME -p $PASSWORD
Om du använder Podman i stället för Docker gör du nödvändiga ändringar i kommandot.
Om du har loggat in på ACR-instansen 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 ACR-instans som du skapade i ett föregående steg. Det tar flera minuter att slutföra det här kommandot.
az aks create \
--resource-group $RESOURCE_GROUP_NAME \
--location ${LOCATION} \
--name $CLUSTER_NAME \
--attach-acr $REGISTRY_NAME \
--node-count 1 \
--generate-ssh-keys
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 hemlighet för databasanslutning i AKS
Skapa en hemlighet db-secret i AKS-namnområdet för att lagra databasanslutningsinformationen. Använd följande kommando för att skapa hemligheten:
kubectl create secret generic db-secret \
-n ${AKS_NS} \
--from-literal=jdbcurl=jdbc:postgresql://${DB_SERVER_NAME}.postgres.database.azure.com:5432/${DB_NAME}?sslmode=require \
--from-literal=dbusername=${DB_ADMIN} \
--from-literal=dbpassword=${DB_PASSWORD}
Utdata bör se ut som i följande exempel:
secret/db-secret created
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 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. inte är inkommenterade genom att ta bort inledande #.
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
Lägg till följande databaskonfigurationsvariabler. De databasanslutningsrelaterade egenskaperna %prod.quarkus.datasource.jdbc.url, %prod.quarkus.datasource.usernameoch %prod.quarkus.datasource.password läsvärdena från miljövariablerna DB_JDBC_URL, DB_USERNAMErespektive DB_PASSWORD. Dessa miljövariabler mappas till hemliga värden som lagrar databasanslutningsinformationen av säkerhetsskäl, vilket beskrivs i nästa avsnitt.
# Database configurations
%prod.quarkus.datasource.db-kind=postgresql
%prod.quarkus.datasource.jdbc.driver=org.postgresql.Driver
%prod.quarkus.datasource.jdbc.url=${DB_JDBC_URL}
%prod.quarkus.datasource.username=${DB_USERNAME}
%prod.quarkus.datasource.password=${DB_PASSWORD}
%prod.quarkus.hibernate-orm.database.generation=drop-and-create
%prod.quarkus.hibernate-orm.sql-load-script=import.sql
Kubernetes-konfiguration
Lägg till följande Kubernetes-konfigurationsvariabler. Se till att ställa in service-type load-balancer på för att komma åt appen externt.
# Kubernetes configurations
%prod.quarkus.kubernetes.deployment-target=kubernetes
%prod.quarkus.kubernetes.service-type=load-balancer
%prod.quarkus.kubernetes.env.secrets=db-secret
%prod.quarkus.kubernetes.env.mapping.DB_JDBC_URL.from-secret=db-secret
%prod.quarkus.kubernetes.env.mapping.DB_JDBC_URL.with-key=jdbcurl
%prod.quarkus.kubernetes.env.mapping.DB_USERNAME.from-secret=db-secret
%prod.quarkus.kubernetes.env.mapping.DB_USERNAME.with-key=dbusername
%prod.quarkus.kubernetes.env.mapping.DB_PASSWORD.from-secret=db-secret
%prod.quarkus.kubernetes.env.mapping.DB_PASSWORD.with-key=dbpassword
De andra Kubernetes-konfigurationerna anger mappningen av de hemliga värdena till miljövariablerna i Quarkus-programmet. Hemligheten db-secret innehåller information om databasanslutningen. Nycklarna jdbcurl, dbusernameoch dbpassword i den hemliga kartan till DB_JDBC_URLmiljövariablerna , DB_USERNAMErespektive DB_PASSWORD .
Konfiguration av containeravbildning
Som molnbaserad teknik stöder Quarkus generering av OCI-containeravbildningar som är kompatibla med Docker och Podman. Lägg till följande containeravbildningsvariabler. Ersätt värdena <LOGIN_SERVER_VALUE> för och <USER_NAME_VALUE> med värdena för de faktiska värdena för ${LOGIN_SERVER} miljövariablerna respektive miljövariablerna ${USER_NAME} .
# Container Image Build
%prod.quarkus.container-image.build=true
%prod.quarkus.container-image.registry=<LOGIN_SERVER_VALUE>
%prod.quarkus.container-image.group=<USER_NAME_VALUE>
%prod.quarkus.container-image.name=todo-quarkus-aks
%prod.quarkus.container-image.tag=1.0
Skapa containeravbildningen och push-överför den till ACR
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 eller podman kommandoraden (CLI). Utdata ser ut ungefär som i följande exempel:
docker images | grep todo
<LOGIN_SERVER_VALUE>/<USER_NAME_VALUE>/todo-quarkus-aks 1.0 b13c389896b7 18 minutes ago 424MB
Skicka containeravbildningarna till ACR 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>/<USER_NAME_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 ACR 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 har skapat.
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:
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 dig 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 med Azure Cloud Shell
Öppna Azure Cloud Shell i Azure-portalen genom att välja Cloud Shell-ikonen , enligt följande skärmbild:
Kör följande kommando lokalt och klistra in resultatet i Azure Cloud Shell:
echo psql --host=${DB_SERVER_NAME}.postgres.database.azure.com --port=5432 --username=${DB_ADMIN} --dbname=${DB_NAME}
När du tillfrågas om lösenordet använder du det värde som du använde när du skapade databasen.
Använd följande fråga för att hämta alla att göra-objekt:
select * from todo;
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:
Om du ser MORE i utdata skriver du q för att avsluta sidsökaren.
Ange \q för att avsluta programmet psql och återgå till Cloud Shell.
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 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
Feedback
Kommer snart: Under hela 2024 kommer vi att fasa ut GitHub-problem som feedbackmekanism för innehåll och ersätta det med ett nytt feedbacksystem. Mer information finns i: https://aka.ms/ContentUserFeedback.
Skicka och visa feedback för