Wdrażanie aplikacji Java za pomocą aplikacji Quarkus w usłudze Azure Container Apps
W tym artykule pokazano, jak szybko wdrożyć aplikację Red Hat Quarkus w usłudze Microsoft Azure Container Apps przy użyciu prostej aplikacji CRUD. Aplikacja jest "listą do wykonania" z frontonem JavaScript i punktem końcowym REST. Elastyczny serwer 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 Container Apps.
Wymagania wstępne
- Subskrypcja platformy Azure. Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.
- 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 Docker na swoim systemie operacyjnym.
- Zainstaluj pakiet jq.
- Zainstaluj program cURL.
- Zainstaluj interfejs wiersza polecenia quarkus w wersji 3.12.1 lub nowszej.
- Zainstaluj interfejs wiersza polecenia platformy Azure, aby uruchomić polecenia interfejsu wiersza polecenia platformy Azure.
- Zaloguj się do Azure CLI, używając polecenia
az login. Aby ukończyć proces uwierzytelniania, wykonaj kroki wyświetlane w terminalu. Aby uzyskać inne opcje logowania, zobacz Logowanie się do platformy Azure przy użyciu interfejsu wiersza polecenia platformy Azure. - Po wyświetleniu monitu zainstaluj rozszerzenie interfejsu wiersza polecenia platformy Azure podczas pierwszego użycia. Aby uzyskać więcej informacji na temat rozszerzeń, zobacz Używanie rozszerzeń i zarządzanie nimi za pomocą interfejsu wiersza polecenia platformy Azure.
- Uruchom
az version, aby znaleźć zainstalowaną wersję i biblioteki zależne. Aby przeprowadzić uaktualnienie do najnowszej wersji, uruchom polecenieaz upgrade. Ten artykuł wymaga co najmniej wersji 2.61.0 interfejsu wiersza polecenia platformy Azure.
- Zaloguj się do Azure CLI, używając polecenia
Tworzenie projektu aplikacji
Użyj następujących poleceń, 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-10-14
cd aca-quarkus
Jeśli zostanie wyświetlony komunikat o stanie detached HEAD, ten komunikat jest bezpieczny do zignorowania. Ponieważ ten artykuł nie wymaga żadnych zatwierdzeń, stan detached 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 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-aca 1.0.0-SNAPSHOT on JVM (powered by Quarkus 3.2.0.Final) started in 14.826s. Listening on: http://localhost:8080
INFO [io.quarkus] (Quarkus Main Thread) Profile dev activated. Live Coding activated.
INFO [io.quarkus] (Quarkus Main Thread) Installed features: [agroal, cdi, hibernate-orm, hibernate-validator, jdbc-postgresql, narayana-jta, resteasy-reactive, resteasy-reactive-jackson, smallrye-context-propagation, vertx]
--
Tests paused
Press [e] to edit command line args (currently ''), [r] to resume testing, [o] Toggle test output, [:] for the terminal, [h] for more options>
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 Container Apps
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 we właściwościach UNIQUE_VALUE i LOCATION własnymi wartościami i uruchom polecenia w terminalu.
export UNIQUE_VALUE=<your unique value, such as mjg101424>
export RESOURCE_GROUP_NAME=${UNIQUE_VALUE}rg-passwordless
export LOCATION=<your desired Azure region for deploying your resources - for example, eastus>
export REGISTRY_NAME=${UNIQUE_VALUE}regpasswordless
export DB_SERVER_NAME=${UNIQUE_VALUE}dbpasswordless
export DB_NAME=demodb
export ACA_ENV=${UNIQUE_VALUE}envpasswordless
export ACA_NAME=${UNIQUE_VALUE}acapasswordless
Następnie utwórz grupę zasobów przy użyciu następującego polecenia:
az group create \
--name $RESOURCE_GROUP_NAME \
--location $LOCATION
Tworzenie wystąpienia serwera elastycznego usługi Azure Database for PostgreSQL
Serwer elastyczny usługi Azure Database for PostgreSQL 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ć elastyczne wystąpienie serwera w usłudze Azure Database for PostgreSQL przy użyciu Azure CLI. Aby uzyskać więcej informacji, zobacz Szybki start: tworzenie wystąpienia usługi Azure Database for PostgreSQL — serwer elastyczny.
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 \
--database-name $DB_NAME \
--public-access None \
--sku-name Standard_B1ms \
--tier Burstable \
--active-directory-auth Enabled
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:REDACTED@<DB_SERVER_NAME>.postgres.database.azure.com/<DB_NAME>?sslmode=require",
"databaseName": "<DB_NAME>",
"host": "<DB_SERVER_NAME>.postgres.database.azure.com",
"id": "/subscriptions/REDACTED/resourceGroups/<RESOURCE_GROUP_NAME>/providers/Microsoft.DBforPostgreSQL/flexibleServers/<DB_SERVER_NAME>",
"location": "East US",
"password": "REDACTED",
"resourceGroup": "<RESOURCE_GROUP_NAME>",
"skuname": "Standard_B1ms",
"username": "REDACTED",
"version": "13"
}
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 ad signed-in-user show --query userPrincipalName -o tsv)
az postgres flexible-server ad-admin create \
--resource-group $RESOURCE_GROUP_NAME \
--server-name $DB_SERVER_NAME \
--display-name $ENTRA_ADMIN_NAME \
--object-id $(az ad signed-in-user show --query id -o tsv)
Pomyślne dane wyjściowe to obiekt JSON, w tym właściwość "type": "Microsoft.DBforPostgreSQL/flexibleServers/administrators".
Tworzenie wystąpienia usługi Microsoft Azure Container Registry
Ponieważ Quarkus jest technologią natywną dla chmury, ma wbudowaną obsługę tworzenia kontenerów uruchamianych w usłudze Container Apps. Usługa Container Apps jest całkowicie zależna od posiadania rejestru kontenerów, z którego zostaną znalezione obrazy kontenerów do uruchomienia. Usługa Container Apps ma wbudowaną obsługę usługi Azure Container Registry.
Użyj polecenia az acr create, aby utworzyć instancję Container Registry. Poniższy przykład tworzy n wystąpienia usługi Container Registry 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 instancji rejestru kontenerów przy użyciu następującego polecenia:
export LOGIN_SERVER=$(az acr show \
--name $REGISTRY_NAME \
--query 'loginServer' \
--output tsv)
echo $LOGIN_SERVER
Połącz swojego Dockera z instancją usługi Azure Container Registry
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 zalogowałeś się do wystąpienia rejestru kontenerów, powinieneś zobaczyć Login Succeeded na końcu danych wyjściowych polecenia.
Utwórz środowisko
Środowisko w usłudze Azure Container Apps tworzy bezpieczną granicę wokół grupy aplikacji kontenera. Aplikacje kontenera wdrożone w tym samym środowisku są wdrażane w tej samej sieci wirtualnej i zapisują dzienniki w tym samym obszarze roboczym usługi Log Analytics.
Jeśli po raz pierwszy utworzysz środowisko usługi Azure Container Apps, prawdopodobnie musisz zarejestrować Microsoft.App i Microsoft.OperationalInsights przestrzeni nazw. Użyj następujących poleceń, aby zarejestrować przestrzenie nazw:
az provider register --namespace Microsoft.App --wait
az provider register --namespace Microsoft.OperationalInsights --wait
Teraz użyj polecenia az containerapp env create, aby utworzyć środowisko, jak pokazano w poniższym przykładzie:
az containerapp env create \
--resource-group $RESOURCE_GROUP_NAME \
--location $LOCATION \
--name $ACA_ENV
Jeśli zostanie wyświetlony monit o zainstalowanie rozszerzenia, odpowiedz Y.
Dostosowywanie natywnej konfiguracji chmury
Jako technologia natywna dla chmury firma Quarkus oferuje możliwość automatycznego generowania obrazów kontenerów. Aby uzyskać więcej informacji, zobacz Container Images (Obrazy kontenerów). Deweloperzy mogą następnie wdrożyć obraz aplikacji na docelowej platformie konteneryzowanej — na przykład azure Container Apps.
Aby wygenerować obraz kontenera, użyj następującego polecenia, aby dodać container-image-jib rozszerzenie w terminalu lokalnym:
quarkus ext add container-image-jib
Funkcja Quarkus modyfikuje moduł POM, aby upewnić się, że rozszerzenie jest uwzględnione w obiekcie <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-container-image-jib has been installed
Otwórz plik pom.xml i powinny zostać wyświetlone następujące zależności dodane przez container-image-jib rozszerzenie:
<dependency>
<groupId>io.quarkus</groupId>
<artifactId>quarkus-container-image-jib</artifactId>
</dependency>
Następnie dodaj następujące zależności do pliku pom.xml w celu obsługi uwierzytelniania bez hasła za pomocą serwera elastycznego usługi Azure Database for PostgreSQL:
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-identity-extensions</artifactId>
<version>1.1.20</version>
</dependency>
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 programowania. -
test- Aktywowane podczas uruchamiania testów. -
prod— 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. są niezakomentowane przez usunięcie wiodącego znaku #.
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.
Badanie konfiguracji bazy danych
Po usunięciu komentarza właściwości konfiguracja bazy danych w pliku src/main/resources/application.properties powinna wyglądać podobnie do następującego przykładu:
# Database configurations
%prod.quarkus.datasource.db-kind=postgresql
%prod.quarkus.datasource.jdbc.url=
%prod.quarkus.datasource.username=
%prod.quarkus.datasource.password=
%prod.quarkus.hibernate-orm.database.generation=create
%prod.quarkus.hibernate-orm.sql-load-script=no-file
Usuń właściwość %prod.quarkus.datasource.password, ponieważ nie jest wymagana w przypadku korzystania z uwierzytelniania bez hasła z elastycznym serwerem usługi Azure Database for PostgreSQL. Zaktualizuj inne właściwości %prod.quarkus.datasource.jdbc.url powiązane z połączeniem z bazą danych i %prod.quarkus.datasource.username wartościami, jak pokazano w poniższym przykładzie. Ostateczna konfiguracja powinna wyglądać podobnie do poniższego przykładu:
# Database configurations
%prod.quarkus.datasource.db-kind=postgresql
%prod.quarkus.datasource.jdbc.url=jdbc:postgresql://${AZURE_POSTGRESQL_HOST}:${AZURE_POSTGRESQL_PORT}/${AZURE_POSTGRESQL_DATABASE}?\
authenticationPluginClassName=com.azure.identity.extensions.jdbc.postgresql.AzurePostgresqlAuthenticationPlugin\
&sslmode=require
%prod.quarkus.datasource.username=${AZURE_POSTGRESQL_USERNAME}
%prod.quarkus.hibernate-orm.database.generation=create
%prod.quarkus.hibernate-orm.sql-load-script=no-file
Wartość ${AZURE_POSTGRESQL_HOST}, ${AZURE_POSTGRESQL_PORT}, ${AZURE_POSTGRESQL_DATABASE}i ${AZURE_POSTGRESQL_USERNAME} jest dostarczana przez środowisko Azure Container Apps w czasie wykonywania przy użyciu rozszerzenia bez hasła łącznika usługi w dalszej części tego artykułu.
Ogólnie rzecz biorąc, nie oczekuje się, że dane utrwalone w bazie danych zostaną usunięte i ponownie wypełnione przykładowymi danymi w środowisku produkcyjnym. Dlatego można zobaczyć, że schemat dla quarkus.hibernate-orm.database.generation parametru jest określony tak create , aby aplikacja tworzyła schemat tylko wtedy, gdy nie istnieje podczas początkowego uruchamiania. Poza tym baza danych nie jest wypełniana wcześniej żadnymi przykładowymi danymi, ponieważ hibernate-orm.sql-load-script jest określona jako no-file. To ustawienie różni się od tego, kiedy aplikacja była uruchamiana lokalnie w trybie programowania wcześniej. Wartości domyślne w trybie programowania i quarkus.hibernate-orm.database.generationhibernate-orm.sql-load-script są i drop-and-create są import.sql odpowiednio, co oznacza, że aplikacja zawsze odrzuca i ponownie utworzy schemat bazy danych i ładuje dane zdefiniowane w import.sql.
Plik import.sql jest wygodnym obiektem od Quarkus.
Jeśli plik src/main/resources/import.sql istnieje w pliku Jar Quarkus, a wartość hibernate-orm.sql-load-script właściwości to import.sql, instrukcje DML SQL w tym pliku są wykonywane w czasie uruchamiania aplikacji.
Testowanie aplikacji Quarkus lokalnie przy użyciu elastycznego serwera usługi Azure Database for PostgreSQL
Przed wdrożeniem aplikacji Quarkus w usłudze Azure Container Apps, przetestuj lokalnie połączenie z elastycznym serwerem Azure Database for PostgreSQL.
Najpierw dodaj lokalny adres IP do reguł zapory elastycznego wystąpienia serwera usługi Azure Database for PostgreSQL przy użyciu następujących poleceń:
export AZ_LOCAL_IP_ADDRESS=$(curl -s https://whatismyip.akamai.com)
az postgres flexible-server firewall-rule create \
--resource-group $RESOURCE_GROUP_NAME \
--name $DB_SERVER_NAME \
--rule-name $DB_SERVER_NAME-database-allow-local-ip \
--start-ip-address $AZ_LOCAL_IP_ADDRESS \
--end-ip-address $AZ_LOCAL_IP_ADDRESS
Następnie ustaw następujące zmienne środowiskowe w poprzednim terminalu. Te zmienne środowiskowe służą do połączenia się z elastycznym wystąpieniem serwera usługi Azure Database for PostgreSQL z 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}
Uruchom aplikację Quarkus lokalnie, aby przetestować połączenie z wystąpieniem serwera elastycznego usługi Azure Database for PostgreSQL. Użyj następujących poleceń, aby uruchomić aplikację w trybie produkcyjnym:
mvn clean package -DskipTests
java -jar target/quarkus-app/quarkus-run.jar
Aby uzyskać dostęp do aplikacji Todo, otwórz nową przeglądarkę internetową i przejdź na http://localhost:8080. Powinna zostać wyświetlona ta sama aplikacja do wykonania, jak pokazano podczas lokalnego uruchamiania aplikacji w trybie programowania bez żadnych elementów zadań do wykonania.
Aby zatrzymać aplikację, naciśnij Control+C.
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 rozszerzenia Jib do skompilowania obrazu kontenera.
export TODO_QUARKUS_IMAGE_NAME=todo-quarkus-aca
export TODO_QUARKUS_IMAGE_TAG=${LOGIN_SERVER}/${TODO_QUARKUS_IMAGE_NAME}:1.0
quarkus build -Dquarkus.container-image.build=true -Dquarkus.container-image.image=${TODO_QUARKUS_IMAGE_TAG} --no-tests
Dane wyjściowe powinny kończyć się ciągiem BUILD SUCCESS.
Możesz również sprawdzić, czy obraz kontenera jest generowany, używając docker wiersza polecenia (CLI), jak pokazano w poniższym przykładzie:
docker images | grep ${TODO_QUARKUS_IMAGE_NAME}
Dane wyjściowe wyglądają podobnie do następującego przykładu:
<LOGIN_SERVER_VALUE>/todo-quarkus-aca 1.0 0804dfd834fd 2 minutes ago 407MB
Wypchnij obrazy kontenerów do rejestru kontenerów przy użyciu następującego polecenia:
docker push ${TODO_QUARKUS_IMAGE_TAG}
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-aca]
188a550fce3d: Pushed
4e3afea591e2: Pushed
1db0eba807a6: Pushed
c72d9ccda0b2: Pushed
d7819b8a2d18: Pushed
d0e5cba6b262: Pushed
e0bac91f0f10: Pushed
1.0: digest: sha256:f9ccb476e2388efa0dfdf817625a94f2247674148a69b7e4846793e63c8be994 size: 1789
Wdrażanie aplikacji Quarkus w usłudze Azure Container Apps
Po wypchnięciu obrazu aplikacji do rejestru kontenerów użyj następującego polecenia, aby utworzyć wystąpienie usługi Azure Container Apps w celu uruchomienia aplikacji po ściągnięciu obrazu z rejestru kontenerów:
az containerapp create \
--resource-group $RESOURCE_GROUP_NAME \
--name $ACA_NAME \
--image $TODO_QUARKUS_IMAGE_TAG \
--environment $ACA_ENV \
--registry-server $LOGIN_SERVER \
--registry-identity system \
--target-port 8080 \
--ingress 'external' \
--min-replicas 1
Pomyślne dane wyjściowe to obiekt JSON, w tym właściwość "type": "Microsoft.App/containerApps".
Następnie połącz wystąpienie serwera elastycznego usługi Azure Database for PostgreSQL z aplikacją kontenera przy użyciu łącznika usługi, wykonując następujące kroki:
Zainstaluj rozszerzenie bez hasła łącznika usługi dla interfejsu wiersza polecenia platformy Azure przy użyciu następującego polecenia:
az extension add --name serviceconnector-passwordless --upgrade --allow-preview truePołącz bazę danych z aplikacją kontenera przy użyciu tożsamości zarządzanej przypisanej przez system przy użyciu następującego polecenia:
az containerapp connection create postgres-flexible \ --resource-group $RESOURCE_GROUP_NAME \ --name $ACA_NAME \ --target-resource-group $RESOURCE_GROUP_NAME \ --server $DB_SERVER_NAME \ --database $DB_NAME \ --system-identity \ --container $ACA_NAMEPomyślne dane wyjściowe to obiekt JSON, w tym właściwość
"type": "microsoft.servicelinker/linkers".
Uzyskaj w pełni kwalifikowany adres URL, aby uzyskać dostęp do aplikacji todo przy użyciu następującego polecenia:
export QUARKUS_URL=https://$(az containerapp show \
--resource-group $RESOURCE_GROUP_NAME \
--name $ACA_NAME \
--query properties.configuration.ingress.fqdn -o tsv)
echo $QUARKUS_URL
Otwórz nową przeglądarkę internetową na wartość ${QUARKUS_URL}. Jeśli strona internetowa nie jest poprawnie renderowana, poczekaj chwilę i odśwież stronę.
Następnie dodaj nowy element zadań do wykonania z tekstem Deployed the Todo app to Container Apps. Wybierz ten element, aby oznaczyć go jako ukończony.
Uzyskaj dostęp do interfejsu API RESTful (/api), aby pobrać wszystkie elementy zadań do wykonania przechowywane w usłudze Azure Database for PostgreSQL, jak pokazano w poniższym przykładzie:
curl --verbose -k ${QUARKUS_URL}/api | jq .
Dane wyjściowe powinny wyglądać podobnie do następującego przykładu:
* Connected to <aca-name>.<random-id>.eastus.azurecontainerapps.io (20.231.235.79) port 443 (#0)
> GET /api HTTP/2
> Host: <aca-name>.<random-id>.eastus.azurecontainerapps.io
> user-agent: curl/7.88.1
> accept: */*
>
< HTTP/2 200
< content-length: 88
< content-type: application/json;charset=UTF-8
<
[
{
"id": 1,
"title": "Deployed the Todo app to Container Apps",
"completed": true,
"order": 1,
"url": null
}
]
Sprawdź, czy baza danych została zaktualizowana
Użyj następującego polecenia, aby sprawdzić, czy baza danych została zaktualizowana przy użyciu nowego elementu zadań do wykonania:
export ACCESS_TOKEN=$(az account get-access-token --resource-type oss-rdbms --output tsv --query accessToken)
az postgres flexible-server execute \
--admin-user $ENTRA_ADMIN_NAME \
--admin-password $ACCESS_TOKEN \
--name $DB_SERVER_NAME \
--database-name $DB_NAME \
--querytext "select * from todo;"
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ć ten sam element w wyświetlonym wcześniej graficznym interfejsie użytkownika aplikacji todo:
Successfully connected to <DB_SERVER_NAME>.
Ran Database Query: 'select * from todo;'
Retrieving first 30 rows of query output, if applicable.
Closed the connection to <DB_SERVER_NAME>
[
{
"completed": true,
"id": 1,
"ordering": 1,
"title": "Deployed the Todo app to Container Apps",
"url": null
}
]
Po zakończeniu usuń regułę zapory, która umożliwia lokalnemu adresowi IP uzyskiwanie dostępu 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_IMAGE_TAG}
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 wygenerowane przez tryb deweloperski Quarkus.