Wdrażanie aplikacji Java za pomocą aplikacji Quarkus w klastrze usługi Azure Kubernetes Service
W tym artykule pokazano, jak szybko wdrożyć aplikację Red Hat Quarkus w usłudze Azure Kubernetes Service (AKS) przy użyciu prostej aplikacji CRUD. Aplikacja jest "listą do wykonania" z frontonem JavaScript i punktem końcowym REST. Serwer elastyczny usługi Azure Database for PostgreSQL zapewnia warstwę trwałości dla aplikacji. W artykule pokazano, jak przetestować aplikację lokalnie i wdrożyć ją w usłudze AKS.
Wymagania wstępne
- Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto platformy Azure.
- Przygotuj maszynę lokalną z zainstalowanym systemem operacyjnym przypominającym system Unix — na przykład Ubuntu, macOS lub Podsystem Windows dla systemu Linux.
- Zainstaluj implementację java SE w wersji 17 lub nowszej — na przykład kompilacja microsoft OpenJDK.
- Zainstaluj program Maven w wersji 3.9.8 lub nowszej.
- Zainstaluj platformę Docker dla systemu operacyjnego.
- Zainstaluj pakiet jq.
- Zainstaluj program cURL.
- Zainstaluj interfejs wiersza polecenia quarkus w wersji 3.12.1 lub nowszej.
- Interfejs wiersza polecenia platformy Azure dla środowisk przypominających system Unix. Ten artykuł wymaga tylko wariantu powłoki Bash interfejsu wiersza polecenia platformy Azure.
Deweloper powinien zainstalować interfejs wiersza polecenia platformy Azure i zalogować się interaktywnie za pomocą polecenia az login , aby zalogować się na platformie Azure przed użyciem polecenia DefaultAzureCredential w kodzie. az login- Ten artykuł wymaga co najmniej wersji 2.61.0 interfejsu wiersza polecenia platformy Azure.
Tworzenie projektu aplikacji
Użyj następującego polecenia, aby sklonować przykładowy projekt Java dla tego artykułu. Przykład znajduje się w witrynie GitHub.
git clone https://github.com/Azure-Samples/quarkus-azure
cd quarkus-azure
git checkout 2024-12-16
cd aks-quarkus
Jeśli zostanie wyświetlony komunikat o odłączeniu stanu HEAD , ten komunikat jest bezpieczny do zignorowania. Ponieważ ten artykuł nie wymaga żadnych zatwierdzeń, odłączony stan HEAD jest odpowiedni.
Lokalne testowanie aplikacji Quarkus
W krokach w tej sekcji pokazano, jak uruchomić aplikację lokalnie.
Aplikacja Quarkus obsługuje automatyczną aprowizację nieskonfigurowanych usług w trybie programowania i testowania. Quarkus odnosi się do tej możliwości jako usług deweloperskich. Załóżmy, że dołączysz funkcję Quarkus, taką jak nawiązywanie połączenia z usługą bazy danych. Chcesz przetestować aplikację, ale nie skonfigurowano jeszcze w pełni połączenia z rzeczywistą bazą danych. Aplikacja Quarkus automatycznie uruchamia konteneryzowaną wersję wycinków odpowiedniej usługi i łączy z nią aplikację. Aby uzyskać więcej informacji, zobacz Omówienie usług Dev Services w dokumentacji aplikacji Quarkus.
Upewnij się, że środowisko kontenera jest uruchomione i użyj następującego polecenia, aby wprowadzić tryb deweloperski Quarkus:
quarkus dev
quarkus devZamiast programu można wykonać to samo za pomocą narzędzia Maven przy użyciu polecenia mvn quarkus:dev.
Może pojawić się pytanie, czy chcesz wysłać dane telemetryczne użycia trybu deweloperskiego Quarkus. Jeśli tak, odpowiedz jak chcesz.
Tryb deweloperski Quarkus umożliwia ponowne ładowanie na żywo przy użyciu kompilacji w tle. Jeśli zmodyfikujesz jakikolwiek aspekt kodu źródłowego aplikacji i odświeżysz przeglądarkę, możesz zobaczyć zmiany. Jeśli występują problemy z kompilacją lub wdrożeniem, na stronie błędu pojawi się komunikat o błędzie. Tryb deweloperski Quarkus nasłuchuje debugera na porcie 5005. Jeśli chcesz poczekać na dołączenie debugera przed uruchomieniem, przekaż -Dsuspend go w wierszu polecenia. Jeśli w ogóle nie chcesz debugera, możesz użyć polecenia -Ddebug=false.
Dane wyjściowe powinny wyglądać podobnie do następującego przykładu:
__ ____ __ _____ ___ __ ____ ______
--/ __ \/ / / / _ | / _ \/ //_/ / / / __/
-/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/
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>
Naciśnij w terminalu, w którym jest uruchomiony tryb deweloperski Quarkus. Klucz w otwiera domyślną przeglądarkę internetową, aby wyświetlić aplikację Todo . Możesz również uzyskać bezpośredni dostęp do graficznego interfejsu użytkownika http://localhost:8080 aplikacji.
Spróbuj wybrać kilka zadań do wykonania na liście zadań do wykonania. Interfejs użytkownika wskazuje wybór ze stylem tekstu przekreślenia. Możesz również dodać nowy element zadań do wykonania do listy zadań do wykonania, wpisując polecenie Weryfikuj aplikacje do wykonania i naciskając Enter, jak pokazano na poniższym zrzucie ekranu:
Uzyskaj dostęp do interfejsu API RESTful (/api), aby pobrać wszystkie elementy zadań do wykonania przechowywane w lokalnej bazie danych PostgreSQL:
curl --verbose http://localhost:8080/api | jq .
Dane wyjściowe powinny wyglądać podobnie do następującego przykładu:
* 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
}
]
Naciśnij q , aby zamknąć tryb deweloperski Quarkus.
Tworzenie zasobów platformy Azure w celu uruchomienia aplikacji Quarkus
W krokach w tej sekcji pokazano, jak utworzyć następujące zasoby platformy Azure w celu uruchomienia przykładowej aplikacji Quarkus:
- Serwer elastyczny usługi Azure Database for PostgreSQL
- Azure Container Registry
- Azure Kubernetes Service (AKS)
Uwaga
W tym artykule uwierzytelnianie postgreSQL wyłącza w celu zilustrowania najlepszych rozwiązań w zakresie zabezpieczeń. Identyfikator Entra firmy Microsoft służy do uwierzytelniania połączenia z serwerem. Jeśli musisz włączyć uwierzytelnianie postgreSQL, zobacz Szybki start: Używanie języka Java i JDBC z usługą Azure Database for PostgreSQL — serwer elastyczny i wybierz kartę Hasło .
Niektóre z tych zasobów muszą mieć unikatowe nazwy w zakresie subskrypcji platformy Azure. Aby zapewnić tę unikatowość, możesz użyć inicjałów, sekwencji, daty, wzorca sufiksu . Aby zastosować ten wzorzec, nadaj zasobom nazwę, wyświetlając inicjały, numer sekwencji, bieżącą datę i jakiś sufiks specyficzny dla zasobu — na przykład rg "grupa zasobów". Poniższe zmienne środowiskowe używają tego wzorca. Zastąp wartości zastępcze i LOCATION własnymi wartościamiUNIQUE_VALUE, a następnie uruchom następujące polecenia w terminalu:
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
Tworzenie serwera elastycznego usługi Azure Database for PostgreSQL
Azure Database for PostgreSQL — elastyczny serwer to w pełni zarządzana usługa bazy danych, która zapewnia bardziej szczegółową kontrolę i elastyczność funkcji zarządzania bazami danych i ustawień konfiguracji. W tej sekcji pokazano, jak utworzyć wystąpienie serwera elastycznego usługi Azure Database for PostgreSQL przy użyciu interfejsu wiersza polecenia platformy Azure.
Najpierw utwórz grupę zasobów zawierającą serwer bazy danych i inne zasoby przy użyciu następującego polecenia:
az group create \
--name $RESOURCE_GROUP_NAME \
--location $LOCATION
Następnie utwórz wystąpienie serwera elastycznego usługi Azure Database for PostgreSQL przy użyciu następującego polecenia:
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
Utworzenie serwera, bazy danych, użytkownika administratora i reguł zapory może potrwać kilka minut. Jeśli polecenie zakończy się pomyślnie, dane wyjściowe wyglądają podobnie do następującego przykładu:
{
"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"
}
Testowanie aplikacji lokalnie za pomocą serwera elastycznego usługi Azure Database for PostgreSQL
W poprzedniej sekcji przetestowano lokalnie aplikację Quarkus w trybie programowania przy użyciu bazy danych PostgreSQL aprowizowanej jako kontener platformy Docker. Teraz przetestuj połączenie z wystąpieniem serwera elastycznego usługi Azure Database for PostgreSQL lokalnie.
Najpierw dodaj bieżącego zalogowanego użytkownika jako administratora firmy Microsoft do wystąpienia serwera elastycznego usługi Azure Database for PostgreSQL przy użyciu następujących poleceń:
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)
Pomyślne dane wyjściowe to obiekt JSON, w tym właściwość "type": "Microsoft.DBforPostgreSQL/flexibleServers/administrators".
Następnie dodaj lokalny adres IP do reguł zapory wystąpienia serwera elastycznego usługi Azure Database for PostgreSQL, wykonując następujące kroki:
Uzyskaj lokalny adres IP maszyny, na której uruchamiasz aplikację Quarkus lokalnie. Na przykład odwiedź stronę https://whatismyipaddress.com , aby uzyskać publiczny adres IP w wersji 4.
Zdefiniuj zmienną środowiskową przy użyciu lokalnego adresu IP, który został podany w poprzednim kroku.
export AZ_LOCAL_IP_ADDRESS=<your local IP address>Uruchom następujące polecenie, aby dodać lokalny adres IP do reguł zapory wystąpienia serwera elastycznego usługi Azure Database for PostgreSQL:
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
Następnie ustaw następujące zmienne środowiskowe w poprzednim terminalu. Te zmienne środowiskowe służą do nawiązywania połączenia z wystąpieniem serwera elastycznego usługi Azure Database for PostgreSQL z poziomu aplikacji Quarkus uruchomionej lokalnie:
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}
Uwaga
Wartości zmiennych AZURE_POSTGRESQL_HOSTśrodowiskowych , , AZURE_POSTGRESQL_PORTAZURE_POSTGRESQL_DATABASEi AZURE_POSTGRESQL_USERNAME są odczytywane przez właściwości konfiguracji bazy danych zdefiniowane w pliku src/main/resources/application.properties wprowadzone w poprzedniej sekcji. Te wartości są automatycznie wstrzykiwane do aplikacji w czasie wykonywania przy użyciu rozszerzenia bez hasła łącznika usługi podczas wdrażania aplikacji Quarkus w klastrze usługi AKS w dalszej części tego artykułu.
Teraz uruchom aplikację Quarkus lokalnie, aby przetestować połączenie z wystąpieniem serwera elastycznego usługi Azure Database for PostgreSQL. Użyj następującego polecenia, aby uruchomić aplikację w trybie produkcyjnym:
quarkus build
java -jar target/quarkus-app/quarkus-run.jar
Uwaga
Jeśli uruchomienie aplikacji nie powiedzie się z komunikatem o błędzie podobnym do ERROR [org.hib.eng.jdb.spi.SqlExceptionHelper] (JPA Startup Thread) Acquisition timeout while waiting for new connection, najprawdopodobniej jest to spowodowane ustawieniem sieci komputera lokalnego. Spróbuj ponownie wybrać pozycję Dodaj bieżący adres IP klienta z witryny Azure Portal. Aby uzyskać więcej informacji, zobacz sekcję Tworzenie reguły zapory po utworzeniu serwera w temacie Tworzenie reguł zapory dla usługi Azure Database for PostgreSQL — serwer elastyczny i zarządzanie nimi przy użyciu witryny Azure Portal. Następnie ponownie uruchom aplikację.
Otwórz nową przeglądarkę internetową, aby http://localhost:8080 uzyskać dostęp do aplikacji todo. Powinna zostać wyświetlona aplikacja Todo, podobnie jak w przypadku uruchamiania aplikacji lokalnie w trybie programowania.
Utworzenie wystąpienia usługi Azure Container Registry
Ponieważ Quarkus jest technologią natywną dla chmury, ma wbudowaną obsługę tworzenia kontenerów uruchamianych na platformie Kubernetes. Platforma Kubernetes jest całkowicie zależna od posiadania rejestru kontenerów, z którego zostaną znalezione obrazy kontenerów do uruchomienia. Usługa AKS ma wbudowaną obsługę usługi Azure Container Registry.
Użyj polecenia az acr create, aby utworzyć wystąpienie rejestru kontenerów. Poniższy przykład tworzy wystąpienie rejestru kontenerów o nazwie z wartością zmiennej środowiskowej ${REGISTRY_NAME}:
az acr create \
--resource-group $RESOURCE_GROUP_NAME \
--location ${LOCATION} \
--name $REGISTRY_NAME \
--sku Basic
Po krótkim czasie powinny zostać wyświetlone dane wyjściowe JSON zawierające następujące wiersze:
"provisioningState": "Succeeded",
"publicNetworkAccess": "Enabled",
"resourceGroup": "<YOUR_RESOURCE_GROUP>",
Pobierz serwer logowania dla wystąpienia usługi Container Registry przy użyciu następującego polecenia:
export LOGIN_SERVER=$(az acr show \
--name $REGISTRY_NAME \
--query 'loginServer' \
--output tsv)
echo $LOGIN_SERVER
Łączenie platformy Docker z wystąpieniem rejestru kontenerów
Zaloguj się do wystąpienia rejestru kontenerów. Logowanie umożliwia wypychanie obrazu. Użyj następującego polecenia, aby zalogować się do rejestru:
az acr login --name $REGISTRY_NAME
Jeśli pomyślnie zalogowaliśmy się do wystąpienia rejestru kontenerów, na końcu danych wyjściowych polecenia powinny zostać wyświetlone Login Succeeded dane wyjściowe polecenia.
Tworzenie klastra AKS
Utwórz klaster AKS za pomocą polecenia az aks create. Poniższy przykład tworzy klaster o nazwie z wartością zmiennej środowiskowej ${CLUSTER_NAME} z jednym węzłem. Klaster jest połączony z wystąpieniem rejestru kontenerów utworzonym w poprzednim kroku. Wykonanie tego polecenia trwa kilka minut. Klaster jest uruchamiany z włączoną tożsamością zarządzaną. Ten krok jest niezbędny w przypadku połączenia bez hasła z bazą danych.
az aks create \
--resource-group $RESOURCE_GROUP_NAME \
--name $CLUSTER_NAME \
--attach-acr $REGISTRY_NAME \
--node-count 1 \
--generate-ssh-keys \
--enable-managed-identity
Po kilku minutach polecenie zostanie zakończone i zwróci informacje w formacie JSON dotyczące klastra, w tym następujące dane wyjściowe:
"nodeResourceGroup": "MC_<your resource_group_name>_<your cluster name>_<your region>",
"privateFqdn": null,
"provisioningState": "Succeeded",
"resourceGroup": "<your resource group name>",
Nawiązywanie połączenia z klastrem usługi AKS
Aby zarządzać klastrem Kubernetes, należy użyć kubectlklienta wiersza polecenia Kubernetes. Aby zainstalować kubectl lokalnie, użyj polecenia az aks install-cli , jak pokazano w poniższym przykładzie:
az aks install-cli
Aby uzyskać więcej informacji na temat kubectlprogramu , zobacz Narzędzie wiersza polecenia (kubectl) w dokumentacji platformy Kubernetes.
Aby skonfigurować kubectl połączenie z klastrem Kubernetes, użyj polecenia az aks get-credentials , jak pokazano w poniższym przykładzie. To polecenie powoduje pobranie poświadczeń i zastosowanie ich w konfiguracji interfejsu wiersza polecenia Kubernetes.
az aks get-credentials \
--resource-group $RESOURCE_GROUP_NAME \
--name $CLUSTER_NAME \
--overwrite-existing \
--admin
Pomyślne dane wyjściowe zawierają tekst podobny do następującego przykładu:
Merged "ejb010718aks-admin" as current context in /Users/edburns/.kube/config
Przydatne może być aliasy k w pliku kubectl. Jeśli tak, użyj następującego polecenia:
alias k=kubectl
Aby zweryfikować połączenie z klastrem, użyj kubectl get polecenia , aby zwrócić listę węzłów klastra, jak pokazano w poniższym przykładzie:
kubectl get nodes
Poniższe przykładowe dane wyjściowe zawierają jeden węzeł utworzony w poprzednich krokach. Upewnij się, że stan węzła to Gotowy:
NAME STATUS ROLES AGE VERSION
aks-nodepool1-xxxxxxxx-yyyyyyyyyy Ready agent 76s v1.28.9
Tworzenie nowej przestrzeni nazw w usłudze AKS
Użyj następującego polecenia, aby utworzyć nową przestrzeń nazw w usłudze Kubernetes dla aplikacji Quarkus:
kubectl create namespace ${AKS_NS}
Dane wyjściowe powinny wyglądać podobnie do następującego przykładu:
namespace/<your namespace> created
Tworzenie połączenia usługi w usłudze AKS za pomocą łącznika usługi
W tej sekcji utworzysz połączenie usługi między klastrem AKS i serwerem elastycznym usługi Azure Database for PostgreSQL przy użyciu Tożsamość obciążeń Microsoft Entra z łącznikiem usługi. To połączenie umożliwia klastrowi usługi AKS dostęp do serwera elastycznego usługi Azure Database for PostgreSQL bez korzystania z uwierzytelniania SQL.
Uruchom następujące polecenia, aby utworzyć połączenie między klastrem AKS i bazą danych PostgreSQL przy użyciu Tożsamość obciążeń Microsoft Entra z łącznikiem usługi:
# 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
Obecność następującego kodu JSON w danych wyjściowych ostatniego polecenia w poprzednich krokach wskazuje pomyślną instalację łącznika usługi:
"name": "akspostgresconn",
"provisioningState": "Succeeded",
Uwaga
Zalecamy używanie Tożsamość obciążeń Microsoft Entra do bezpiecznego dostępu do serwera elastycznego usługi Azure Database for PostgreSQL bez używania uwierzytelniania nazwy użytkownika/hasła. Jeśli musisz użyć uwierzytelniania nazwy użytkownika/hasła, zignoruj poprzednie kroki w tej sekcji i użyj nazwy użytkownika i hasła, aby nawiązać połączenie z bazą danych.
Pobieranie konta usługi i wpisu tajnego utworzonego przez łącznik usługi
Aby uwierzytelnić się na serwerze elastycznym usługi Azure Database for PostgreSQL, musisz pobrać konto usługi i wpis tajny Kubernetes utworzony przez łącznik usługi. Postępuj zgodnie z instrukcjami w sekcji Aktualizowanie kontenera w artykule Samouczek: łączenie aplikacji usługi AKS z usługą Azure SQL Database. Wybierz opcję Bezpośrednie tworzenie wdrożenia przy użyciu udostępnionego przykładowego fragmentu kodu YAML i wykonaj następujący krok:
Z wyróżnionych sekcji w przykładowym wdrożeniu kubernetes YAML skopiuj wartości
serviceAccountNameisecretRef.name, reprezentowane jako<service-account-name>i<secret-name>w poniższym przykładzie:serviceAccountName: <service-account-name> containers: - name: raw-linux envFrom: - secretRef: name: <secret-name>Te wartości są używane w następnej sekcji w celu wdrożenia aplikacji Quarkus w klastrze usługi AKS.
Dostosowywanie natywnej konfiguracji chmury
Jako technologia natywna dla chmury firma Quarkus oferuje możliwość automatycznego konfigurowania zasobów dla standardowych platform Kubernetes, Red Hat OpenShift i Knative. Aby uzyskać więcej informacji, zobacz Przewodnik po usłudze Quarkus Kubernetes, Przewodnik quarkus OpenShift i Przewodnik po knacie Quarkus. Deweloperzy mogą wdrażać aplikację w docelowym klastrze Kubernetes, stosując wygenerowane manifesty.
Aby wygenerować odpowiednie zasoby kubernetes, użyj następującego polecenia, aby dodać quarkus-kubernetes rozszerzenia i container-image-jib w terminalu lokalnym:
quarkus ext add kubernetes container-image-jib
Funkcja Quarkus modyfikuje funkcję POM, aby upewnić się, że te rozszerzenia są wyświetlane jako <dependencies>. Jeśli zostanie wyświetlony monit o zainstalowanie czegoś o nazwie JBang, odpowiedz tak i zezwól na jego zainstalowanie.
Dane wyjściowe powinny wyglądać podobnie do następującego przykładu:
[SUCCESS] ✅ Extension io.quarkus:quarkus-kubernetes has been installed
[SUCCESS] ✅ Extension io.quarkus:quarkus-container-image-jib has been installed
Aby sprawdzić, czy rozszerzenia są dodawane, możesz uruchomić git diff polecenie i zbadać dane wyjściowe.
Jako natywna dla chmury technologia Quarkus obsługuje pojęcie profilów konfiguracji. Aplikacja Quarkus ma następujące trzy wbudowane profile:
dev- Aktywowane w trybie programowaniatest- Aktywowane podczas uruchamiania testówprod— Profil domyślny, gdy nie działa w trybie programowania lub testowania
Funkcja Quarkus obsługuje dowolną liczbę nazwanych profilów zgodnie z potrzebami.
Pozostałe kroki w tej sekcji umożliwiają dostosowanie wartości w pliku src/main/resources/application.properties .
Prefiks prod. wskazuje, że te właściwości są aktywne podczas uruchamiania prod w profilu. Aby uzyskać więcej informacji na temat profilów konfiguracji, zobacz dokumentację aplikacji Quarkus.
Konfiguracja bazy danych
Sprawdź następujące zmienne konfiguracji bazy danych. Właściwości %prod.quarkus.datasource.jdbc.url powiązane z połączeniem bazy danych i %prod.quarkus.datasource.username odczytane wartości z zmiennych środowiskowych AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASEi AZURE_POSTGRESQL_USERNAME, odpowiednio. Te zmienne środowiskowe są mapowe na wartości wpisów tajnych, które przechowują informacje o połączeniu z bazą danych. Ze względów bezpieczeństwa są one generowane automatycznie przy użyciu rozszerzenia bez hasła łącznika usługi, jak pokazano w innym miejscu tego artykułu.
# 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
Konfiguracja rozwiązania Kubernetes
Zapoznaj się z następującymi zmiennymi konfiguracji platformy Kubernetes. service-type jest ustawiona na wartość w celu load-balancer uzyskania dostępu do aplikacji zewnętrznie. Zastąp wartości <service-account-name> i <secret-name> wartościami wartości rzeczywistych skopiowanych w poprzedniej sekcji.
# 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
Inne konfiguracje platformy Kubernetes określają mapowanie wartości wpisów tajnych na zmienne środowiskowe w aplikacji Quarkus. Wpis <secret-name> tajny zawiera informacje o połączeniu z bazą danych. Klucze AZURE_POSTGRESQL_CLIENTID, , AZURE_POSTGRESQL_PORTAZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_DATABASE, i AZURE_POSTGRESQL_USERNAME w mapie wpisów tajnych odpowiednio do AZURE_CLIENT_IDzmiennych środowiskowych , AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORTAZURE_POSTGRESQL_DATABASE, i AZURE_POSTGRESQL_USERNAME .
Aby zbadać wpisy tajne bezpośrednio za pomocą narzędzia kubectl, użyj poleceń podobnych do następującego przykładu:
kubectl -n ${AKS_NS} get secret <secret-name> -o jsonpath="{.data.AZURE_POSTGRESQL_USERNAME}" | base64 --decode
Konfiguracja obrazu kontenera
Jako technologia natywna dla chmury aplikacja Quarkus obsługuje generowanie obrazów kontenerów OCI zgodnych z platformą Docker. Zastąp wartość <LOGIN_SERVER_VALUE> wartością rzeczywistą zmiennej środowiskowej ${LOGIN_SERVER} .
# Container Image Build
%prod.quarkus.container-image.build=true
%prod.quarkus.container-image.image=<LOGIN_SERVER_VALUE>/todo-quarkus-aks:1.0
Podczas ostatniego sprawdzania po zakończeniu wszystkich niezbędnych podstawień w pliku application.properties nie może występować żadne wystąpienia < znaku. Jeśli istnieją, sprawdź dokładnie, czy wszystkie niezbędne podstawy zostały ukończone.
Skompiluj obraz kontenera i wypchnij go do rejestru kontenerów
Teraz użyj następującego polecenia, aby skompilować samą aplikację. To polecenie używa rozszerzeń Kubernetes i Jib do kompilowania obrazu kontenera.
quarkus build --no-tests
Dane wyjściowe powinny kończyć się ciągiem BUILD SUCCESS. Pliki manifestu kubernetes są generowane w lokalizacji docelowej/kubernetes, jak pokazano w poniższym przykładzie:
tree target/kubernetes
target/kubernetes
├── kubernetes.json
└── kubernetes.yml
0 directories, 2 files
Możesz sprawdzić, czy obraz kontenera jest również generowany przy użyciu docker wiersza polecenia (CLI). Dane wyjściowe wyglądają podobnie do następującego przykładu:
docker images | grep todo-quarkus-aks
<LOGIN_SERVER_VALUE>/todo-quarkus-aks 1.0 b13c389896b7 18 minutes ago 422MB
Wypchnij obrazy kontenerów do rejestru kontenerów przy użyciu następującego polecenia:
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
Dane wyjściowe powinny wyglądać mniej więcej tak jak w tym przykładzie:
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
Teraz, gdy aplikacja została wypchnięta do rejestru kontenerów, możesz poinformować usługę AKS o uruchomieniu aplikacji.
Wdrażanie aplikacji Quarkus w usłudze AKS
W krokach w tej sekcji pokazano, jak uruchomić przykładową aplikację Quarkus w utworzonych zasobach platformy Azure.
Wdrażanie aplikacji Quarkus w usłudze AKS przy użyciu narzędzia kubectl apply
Wdróż zasoby platformy Kubernetes przy użyciu polecenia kubectl w wierszu polecenia, jak pokazano w poniższym przykładzie:
kubectl apply -f target/kubernetes/kubernetes.yml -n ${AKS_NS}
Dane wyjściowe powinny wyglądać podobnie do następującego przykładu:
service/quarkus-todo-demo-app-aks created
deployment.apps/quarkus-todo-demo-app-aks created
Sprawdź, czy aplikacja jest uruchomiona przy użyciu następującego polecenia:
kubectl -n $AKS_NS get pods
Jeśli wartość STATUS pola zawiera inne elementy niż Running, przed kontynuowaniem rozwiąż problem i rozwiąż ten problem. Może to pomóc w zbadania dzienników zasobników przy użyciu następującego polecenia:
kubectl -n $AKS_NS logs $(kubectl -n $AKS_NS get pods | grep quarkus-todo-demo-app-aks | cut -d " " -f1)
EXTERNAL-IP Aby uzyskać dostęp do aplikacji todo, użyj następującego polecenia:
kubectl get svc -n ${AKS_NS}
Dane wyjściowe powinny wyglądać podobnie do następującego przykładu:
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
Możesz użyć następującego polecenia, aby zapisać wartość EXTERNAL-IP zmiennej środowiskowej jako w pełni kwalifikowany adres URL:
export QUARKUS_URL=http://$(kubectl get svc -n ${AKS_NS} | grep quarkus-todo-demo-app-aks | cut -d " " -f10)
echo $QUARKUS_URL
Otwórz nową przeglądarkę internetową na wartość ${QUARKUS_URL}. Następnie dodaj nowy element zadań do wykonania z tekstem Deployed the Todo app to AKS. Ponadto wybierz element jako ukończony Introduction to Quarkus Todo App .
Uzyskaj dostęp do interfejsu API RESTful (/api), aby pobrać wszystkie elementy zadań do wykonania przechowywane w bazie danych Azure PostgreSQL, jak pokazano w poniższym przykładzie:
curl --verbose ${QUARKUS_URL}/api | jq .
Dane wyjściowe powinny wyglądać podobnie do następującego przykładu:
* 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
}
]
Sprawdź, czy baza danych została zaktualizowana
Uruchom następujące polecenie, aby sprawdzić, czy baza danych jest teraz poprawnie aktualizowana:
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;"
Jeśli zostanie wyświetlony monit o zainstalowanie rozszerzenia, odpowiedz Y.
Dane wyjściowe powinny wyglądać podobnie do poniższego przykładu i powinny zawierać te same elementy w graficznym interfejsie użytkownika aplikacji Todo i dane wyjściowe curl polecenia wcześniej:
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
}
]
Po zakończeniu usuń regułę zapory, która zezwala lokalnemu adresowi IP na dostęp do wystąpienia serwera elastycznego usługi Azure Database for PostgreSQL przy użyciu następującego polecenia:
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
Czyszczenie zasobów
Aby uniknąć opłat za platformę Azure, należy wyczyścić niepotrzebne zasoby. Gdy klaster nie jest już potrzebny, użyj polecenia az group delete , aby usunąć grupę zasobów, usługę kontenera, rejestr kontenerów i wszystkie powiązane zasoby.
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
Możesz również użyć polecenia docker rmi , aby usunąć obrazy kontenerów postgres i testcontainers wygenerować je w trybie deweloperskim Quarkus.
Następne kroki
Azure Kubernetes Service