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 lub narzędzie Podman 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-07-08
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 wersję wycinkową odpowiedniej usługi i łączy aplikację z nią. Aby uzyskać więcej informacji, zobacz Omówienie usług Dev Services w dokumentacji aplikacji Quarkus.
Upewnij się, że środowisko kontenera, docker lub Podman, 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żesz zapytać, 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 (ACR)
- Azure Kubernetes Service (AKS)
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 symboli zastępczych , LOCATIONi DB_PASSWORD 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 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
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. Aby uzyskać więcej informacji, zobacz Szybki start: tworzenie wystąpienia usługi Azure Database for PostgreSQL — serwer elastyczny 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 \
--resource-group $RESOURCE_GROUP_NAME \
--admin-user $DB_ADMIN \
--admin-password $DB_PASSWORD \
--database-name $DB_NAME \
--public-access 0.0.0.0 \
--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://<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"
}
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 (ACR).
Użyj polecenia az acr create, aby utworzyć wystąpienie usługi ACR. Poniższy przykład tworzy wystąpienie usługi ACR o nazwie z wartością zmiennej środowiskowej ${REGISTRY_NAME}:
az acr create \
--resource-group $RESOURCE_GROUP_NAME \
--location ${LOCATION} \
--name $REGISTRY_NAME \
--sku Basic \
--admin-enabled
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>",
Łączenie platformy Docker z wystąpieniem usługi ACR
Zaloguj się do wystąpienia usługi ACR. Logowanie umożliwia wypychanie obrazu. Użyj następujących poleceń, aby zweryfikować połączenie:
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
Jeśli używasz narzędzia Podman zamiast platformy Docker, wprowadź niezbędne zmiany w poleceniu.
Jeśli pomyślnie zalogowałeś się do wystąpienia usługi ACR, powinien zostać wyświetlony Login Succeeded na końcu danych wyjściowych 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 usługi ACR utworzonym w poprzednim kroku. Wykonanie tego polecenia trwa kilka minut.
az aks create \
--resource-group $RESOURCE_GROUP_NAME \
--location ${LOCATION} \
--name $CLUSTER_NAME \
--attach-acr $REGISTRY_NAME \
--node-count 1 \
--generate-ssh-keys
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 wpisu tajnego dla połączenia z bazą danych w usłudze AKS
Utwórz wpis tajny db-secret w przestrzeni nazw usługi AKS, aby przechowywać informacje o połączeniu z bazą danych. Użyj następującego polecenia, aby utworzyć wpis tajny:
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}
Dane wyjściowe powinny wyglądać podobnie do następującego przykładu:
secret/db-secret created
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ą usunięcie komentarza i dostosowanie wartości w pliku src/main/resources/application.properties . Upewnij się, że wszystkie wiersze rozpoczynające się od # %prod. ciągu są niezakomentowane przez usunięcie wiodącego #ciągu .
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
Dodaj następujące zmienne konfiguracji bazy danych. Właściwości %prod.quarkus.datasource.jdbc.urlpowiązane z połączeniem bazy danych , %prod.quarkus.datasource.usernamei %prod.quarkus.datasource.password odczytują wartości z zmiennych środowiskowych DB_JDBC_URL, DB_USERNAMEi DB_PASSWORD, odpowiednio. Te zmienne środowiskowe są mapowane na wartości wpisów tajnych, które przechowują informacje o połączeniu z bazą danych ze względów bezpieczeństwa, które zostały opisane w następnej sekcji.
# 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
Konfiguracja rozwiązania Kubernetes
Dodaj następujące zmienne konfiguracji platformy Kubernetes. Upewnij się, że ustawiono opcję service-type , aby load-balancer uzyskać dostęp do aplikacji zewnętrznie.
# 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
Inne konfiguracje platformy Kubernetes określają mapowanie wartości wpisów tajnych na zmienne środowiskowe w aplikacji Quarkus. Wpis db-secret tajny zawiera informacje o połączeniu z bazą danych. Klucze jdbcurl, dbusernamei dbpassword w mapie wpisu tajnego DB_JDBC_URLodpowiednio na zmienne środowiskowe , DB_USERNAMEi DB_PASSWORD .
Konfiguracja obrazu kontenera
Jako technologia natywna dla chmury aplikacja Quarkus obsługuje generowanie obrazów kontenerów OCI zgodnych z platformami Docker i Podman. Dodaj następujące zmienne obrazu kontenera. Zastąp wartości <LOGIN_SERVER_VALUE> i <USER_NAME_VALUE> wartościami wartości rzeczywistych ${LOGIN_SERVER} zmiennych środowiskowych i ${USER_NAME} odpowiednio.
# 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
Skompiluj obraz kontenera i wypchnij go do usługi ACR
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 podman wiersza polecenia lub wiersza polecenia. Dane wyjściowe wyglądają podobnie do następującego przykładu:
docker images | grep todo
<LOGIN_SERVER_VALUE>/<USER_NAME_VALUE>/todo-quarkus-aks 1.0 b13c389896b7 18 minutes ago 424MB
Wypchnij obrazy kontenerów do usługi ACR 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>/<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
Teraz, gdy aplikacja została wypchnięta do usługi ACR, 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:
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 przy użyciu usługi Azure Cloud Shell
Otwórz usługę Azure Cloud Shell w witrynie Azure Portal, wybierając ikonę usługi Cloud Shell , jak pokazano na poniższym zrzucie ekranu:
Uruchom następujące polecenie lokalnie i wklej wynik w usłudze Azure Cloud Shell:
echo psql --host=${DB_SERVER_NAME}.postgres.database.azure.com --port=5432 --username=${DB_ADMIN} --dbname=${DB_NAME}
Po wyświetleniu monitu o hasło użyj wartości użytej podczas tworzenia bazy danych.
Użyj następującego zapytania, aby pobrać wszystkie elementy zadań do wykonania:
select * from todo;
Dane wyjściowe powinny wyglądać podobnie do poniższego przykładu i powinny zawierać te same elementy w wyświetlonym wcześniej graficznym interfejsie użytkownika aplikacji Todo:
Jeśli zobaczysz MORE w danych wyjściowych, wpisz q , aby zamknąć pager.
Wprowadź \q , aby zamknąć psql program i wrócić do usługi Cloud Shell.
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 group delete --name $RESOURCE_GROUP_NAME --yes --no-wait
Możesz również użyć docker rmi polecenia , aby usunąć obrazy kontenerów postgres i testcontainers wygenerować je w trybie deweloperskim Quarkus.
Następne kroki
Azure Kubernetes Service