Azure Kubernetes Service kümesinde Quarkus ile Java uygulaması dağıtma

Bu makalede, basit bir CRUD uygulamasıyla Azure Kubernetes Service'te (AKS) Red Hat Quarkus'un nasıl hızla dağıtılacağı gösterilmektedir. Uygulama, JavaScript ön ucu ve REST uç noktası olan bir "yapılacaklar listesidir". PostgreSQL için Azure Veritabanı Esnek Sunucu, uygulama için kalıcılık katmanı sağlar. Makalede uygulamanızı yerel olarak test etme ve AKS'ye dağıtma adımları gösterilmektedir.

Önkoşullar

• Azure aboneliğiniz yoksa başlamadan önce birücretsiz Azure hesabı oluşturun.
• Ubuntu, macOS veya Linux için Windows Alt Sistemi gibi Unix benzeri işletim sistemi yüklü yerel bir makine hazırlayın.
• Java SE uygulama sürümü 17 veya üzerini yükleyin; örneğin, OpenJDK'nin Microsoft derlemesi.
• Maven, sürüm 3.9.8 veya üzerini yükleyin.
• İşletim sisteminiz için Docker'ı yükleyin.
• jq'yi yükleyin.
• cURL'yi yükleyin.
• Quarkus CLI, sürüm 3.12.1 veya üzerini yükleyin.
• Unix benzeri ortamlar için Azure CLI. Bu makale yalnızca Azure CLI'nın Bash değişkenini gerektirir.
  • • Bash
    • PowerShell
    • Visual Studio Code

    Bir geliştiricinin Azure CLI'yi yüklemesi ve kodda DefaultAzureCredential'ı kullanmadan önce Azure'da oturum açmak için az login komutuyla etkileşimli olarak oturum açması gerekir.

    az login
    

  • Bu makale, Azure CLI'nın en az 2.61.0 sürümünü gerektirir.

Uygulama projesini oluşturma

Bu makalenin örnek Java projesini kopyalamak için aşağıdaki komutu kullanın. Örnek GitHub'dadır.

git clone https://github.com/Azure-Samples/quarkus-azure
cd quarkus-azure
git checkout 2024-12-16
cd aks-quarkus

Ayrılmış HEAD durumunda olduğunu belirten bir ileti görürseniz, bu iletiyi yoksaymak güvenlidir. Bu makale herhangi bir işleme gerektirmediğinden, ayrılmış HEAD durumu uygundur.

Quarkus uygulamanızı yerel olarak test edin

Bu bölümdeki adımlarda uygulamayı yerel olarak nasıl çalıştırabileceğiniz gösterilmektedir.

Quarkus, geliştirme ve test modunda yapılandırılmamış hizmetlerin otomatik olarak sağlanmasını destekler. Quarkus bu özelliği geliştirme hizmetleri olarak ifade eder. Veritabanı hizmetine bağlanma gibi bir Quarkus özelliği eklediğinizi varsayalım. Uygulamayı test etmek istiyorsunuz ancak gerçek bir veritabanına bağlantıyı henüz tam olarak yapılandırmadınız. Quarkus, ilgili hizmetin kapsayıcılı saplama sürümünü otomatik olarak başlatır ve uygulamanızı buna bağlar. Daha fazla bilgi için Quarkus belgelerindeki Dev Services'e Genel Bakış bölümüne bakın.

Kapsayıcı ortamınızın çalıştığından emin olun ve Quarkus geliştirme moduna geçmek için aşağıdaki komutu kullanın:

quarkus dev

quarkus devyerine, kullanarak mvn quarkus:devMaven ile aynı şeyi gerçekleştirebilirsiniz.

Quarkus geliştirme modu kullanımınıza yönelik telemetri göndermek isteyip istemediğiniz sorulabilir. Öyleyse, istediğiniz gibi yanıtlayın.

Quarkus geliştirme modu, arka plan derlemesi ile canlı yeniden yüklemeyi etkinleştirir. Uygulama kaynak kodunuzun herhangi bir yönünü değiştirir ve tarayıcınızı yenilerseniz değişiklikleri görebilirsiniz. Derleme veya dağıtımla ilgili herhangi bir sorun varsa, bir hata sayfası size bildirir. Quarkus geliştirme modu, 5005 numaralı bağlantı noktasında hata ayıklayıcıyı dinler. Hata ayıklayıcının çalışmadan önce eklenmesini beklemek istiyorsanız komut satırını geçirin -Dsuspend . Hata ayıklayıcısını hiç istemiyorsanız kullanabilirsiniz -Ddebug=false.

Çıktı aşağıdaki örnekteki gibi görünmelidir:

__  ____  __  _____   ___  __ ____  ______
 --/ __ \/ / / / _ | / _ \/ //_/ / / / __/
 -/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/
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>

Quarkus geliştirme modunun çalıştığı terminalde w tuşuna basın. w tuşu, uygulamayı göstermek Todo için varsayılan web tarayıcınızı açar. Uygulama GUI'sine http://localhost:8080 doğrudan da erişebilirsiniz.

Yapılacaklar listesinden birkaç yapılacaklar öğesi seçmeyi deneyin. Kullanıcı arabirimi, üstü çizili metin stiliyle seçimi gösterir. Aşağıdaki ekran görüntüsünde gösterildiği gibi, Todo uygulamalarını doğrula yazıp Enter tuşuna basarak da yapılacaklar listesine yeni bir yapılacaklar öğesi ekleyebilirsiniz:

Yerel PostgreSQL veritabanında depolayan tüm yapılacaklar öğelerini almak için RESTful API'sine (/api) erişin:

curl --verbose http://localhost:8080/api | jq .

Çıktı aşağıdaki örnekteki gibi görünmelidir:

* 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
  }
]

Quarkus geliştirme modundan çıkmak için q tuşuna basın.

Quarkus uygulamasını çalıştırmak için Azure kaynaklarını oluşturma

Bu bölümdeki adımlarda Quarkus örnek uygulamasını çalıştırmak için aşağıdaki Azure kaynaklarının nasıl oluşturulacağı gösterilmektedir:

• esnek sunucu PostgreSQL için Azure Veritabanı
• Azure Container Registry
• Azure Kubernetes Service (AKS)

Bu kaynaklardan bazılarının Azure aboneliği kapsamında benzersiz adlara sahip olması gerekir. Bu benzersizliği sağlamak için baş harfleri, sıra, tarih, sonek desenini kullanabilirsiniz. Bu düzeni uygulamak için, kaynaklarınızın baş harflerini, bir dizi numarasını, bugünün tarihini ve bir tür kaynağa özgü soneki (örneğin, rg "kaynak grubu" için) listeleyerek kaynaklarınızı adlandırın. Aşağıdaki ortam değişkenleri bu düzeni kullanır. yer tutucu değerlerini UNIQUE_VALUE ve LOCATION değerlerini kendi değerlerinizle değiştirin ve terminalinizde aşağıdaki komutları çalıştırın:

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

PostgreSQL için Azure Veritabanı Esnek Sunucu oluşturma

PostgreSQL için Azure Veritabanı Esnek Sunucu, veritabanı yönetimi işlevleri ve yapılandırma ayarları üzerinde daha ayrıntılı denetim ve esneklik sağlamak için tasarlanmış tam olarak yönetilen bir veritabanı hizmetidir. Bu bölümde, Azure CLI kullanarak PostgreSQL için Azure Veritabanı Esnek Sunucu örneğinin nasıl oluşturulacağı gösterilmektedir.

İlk olarak, aşağıdaki komutu kullanarak veritabanı sunucusunu ve diğer kaynakları içerecek bir kaynak grubu oluşturun:

az group create \
    --name $RESOURCE_GROUP_NAME \
    --location $LOCATION

Ardından, aşağıdaki komutu kullanarak PostgreSQL için Azure Veritabanı esnek bir sunucu örneği oluşturun:

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

Sunucu, veritabanı, yönetici kullanıcı ve güvenlik duvarı kurallarının oluşturulması birkaç dakika sürer. Komut başarılı olursa, çıkış aşağıdaki örneğe benzer şekilde görünür:

{
  "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"
}

Uygulamayı PostgreSQL için Azure Veritabanı Esnek Sunucu ile yerel olarak test edin

Önceki bölümde, Docker kapsayıcısı olarak sağlanan bir PostgreSQL veritabanıyla Quarkus uygulamasını geliştirme modunda yerel olarak test ettiniz. Şimdi PostgreSQL için Azure Veritabanı Esnek Sunucu örneğine bağlantıyı yerel olarak test edin.

İlk olarak, aşağıdaki komutları kullanarak geçerli oturum açmış kullanıcıyı Microsoft Entra Admin olarak PostgreSQL için Azure Veritabanı Esnek Sunucu örneğine ekleyin:

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)

Başarılı çıkış, özelliğini "type": "Microsoft.DBforPostgreSQL/flexibleServers/administrators"içeren bir JSON nesnesidir.

Ardından, aşağıdaki adımları izleyerek PostgreSQL için Azure Veritabanı Esnek Sunucu örneği güvenlik duvarı kurallarına yerel IP adresini ekleyin:

1. Quarkus uygulamasını yerel olarak çalıştırdığınız makinenizin yerel IP adresini alın. Örneğin, genel IP v4 adresinizi almak için adresini ziyaret edin https://whatismyipaddress.com .

2. Önceki adımda aldığınız yerel IP adresiyle bir ortam değişkeni tanımlayın.

   export AZ_LOCAL_IP_ADDRESS=<your local IP address>
   

3. PostgreSQL için Azure Veritabanı Esnek Sunucu örneği güvenlik duvarı kurallarına yerel IP adresini eklemek için aşağıdaki komutu çalıştırın:

   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
   

Ardından, önceki terminalinizde aşağıdaki ortam değişkenlerini ayarlayın. Bu ortam değişkenleri yerel olarak çalışan Quarkus uygulamasından PostgreSQL için Azure Veritabanı Esnek Sunucu örneğine bağlanmak için kullanılır:

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}

Şimdi PostgreSQL için Azure Veritabanı Esnek Sunucu örneğine bağlantıyı test etmek için Quarkus uygulamasını yerel olarak çalıştırın. Uygulamayı üretim modunda başlatmak için aşağıdaki komutu kullanın:

quarkus build
java -jar target/quarkus-app/quarkus-run.jar

Todo uygulamasına erişmek için http://localhost:8080 yeni bir web tarayıcısı açın. Uygulamayı geliştirme modunda yerel olarak çalıştırdığınızda gördüklerinize benzer şekilde Todo uygulamasını görmeniz gerekir.

Azure Container Registry örneği oluşturacaksınız

Quarkus bulutta yerel bir teknoloji olduğundan, Kubernetes'te çalışan kapsayıcılar oluşturmak için yerleşik desteğe sahiptir. Kubernetes, tamamen çalıştırılacak kapsayıcı görüntülerini bulduğu bir kapsayıcı kayıt defterine sahip olmasına bağlıdır. AKS, Azure Container Registry için yerleşik desteğe sahiptir.

Kapsayıcı kayıt defteri örneğini oluşturmak için az acr create komutunu kullanın. Aşağıdaki örnek, ortam değişkeninizin ${REGISTRY_NAME}değeriyle adlı bir kapsayıcı kayıt defteri örneği oluşturur:

az acr create \
    --resource-group $RESOURCE_GROUP_NAME \
    --location ${LOCATION} \
    --name $REGISTRY_NAME \
    --sku Basic

Kısa bir süre sonra aşağıdaki satırları içeren JSON çıktısını görmeniz gerekir:

  "provisioningState": "Succeeded",
  "publicNetworkAccess": "Enabled",
  "resourceGroup": "<YOUR_RESOURCE_GROUP>",

Aşağıdaki komutu kullanarak Container Registry örneğinin oturum açma sunucusunu alın:

export LOGIN_SERVER=$(az acr show \
    --name $REGISTRY_NAME \
    --query 'loginServer' \
    --output tsv)
echo $LOGIN_SERVER

Docker'ınızı kapsayıcı kayıt defteri örneğine bağlama

Kapsayıcı kayıt defteri örneğinde oturum açın. Oturum açmak, görüntü göndermenizi sağlar. Kayıt defterinde oturum açmak için aşağıdaki komutu kullanın:

az acr login --name $REGISTRY_NAME

Kapsayıcı kayıt defteri örneğinde başarıyla oturum açtıysanız, komut çıktısının sonunda görmeniz Login Succeeded gerekir.

AKS kümesi oluşturma

AKS kümesi oluşturmak için az aks create komutunu kullanın. Aşağıdaki örnek, tek düğümlü ortam değişkeninizin ${CLUSTER_NAME} değeriyle adlı bir küme oluşturur. Küme, önceki adımda oluşturduğunuz kapsayıcı kayıt defteri örneğine bağlıdır. Bu komutun tamamlanması birkaç dakika sürer. Küme, yönetilen kimlik etkin olarak başlatılır. Bu adım parolasız veritabanı bağlantısı için gereklidir.

az aks create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $CLUSTER_NAME \
    --attach-acr $REGISTRY_NAME \
    --node-count 1 \
    --generate-ssh-keys \
    --enable-managed-identity

Birkaç dakika sonra komut tamamlanıp aşağıdaki çıkış da dahil olmak üzere küme hakkında JSON biçimli bilgileri döndürür:

  "nodeResourceGroup": "MC_<your resource_group_name>_<your cluster name>_<your region>",
  "privateFqdn": null,
  "provisioningState": "Succeeded",
  "resourceGroup": "<your resource group name>",

AKS kümesine bağlanma

Kubernetes kümesini yönetmek için Kubernetes komut satırı istemcisini kullanırsınız kubectl. Yerel olarak yüklemek kubectl için aşağıdaki örnekte gösterildiği gibi az aks install-cli komutunu kullanın:

az aks install-cli

hakkında kubectldaha fazla bilgi için Kubernetes belgelerindeki Komut satırı aracına (kubectl) bakın.

Kubernetes kümenize bağlanacak şekilde yapılandırmak kubectl için aşağıdaki örnekte gösterildiği gibi az aks get-credentials komutunu kullanın. Bu komut kimlik bilgilerini indirir ve Kubernetes CLI'yi bunları kullanacak şekilde yapılandırmaktadır.

az aks get-credentials \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $CLUSTER_NAME \
    --overwrite-existing \
    --admin

Başarılı çıktı aşağıdaki örneğe benzer bir metin içerir:

Merged "ejb010718aks-admin" as current context in /Users/edburns/.kube/config

için diğer ad k kubectlkullanmak yararlı olabilir. Öyleyse, aşağıdaki komutu kullanın:

alias k=kubectl

Kümenize bağlantıyı doğrulamak için komutunu kullanarak kubectl get aşağıdaki örnekte gösterildiği gibi küme düğümlerinin listesini döndürin:

kubectl get nodes

Aşağıdaki örnekte önceki adımlarda oluşturulan tek düğüm gösterilmiştir. Düğümün durumunun Hazır olduğundan emin olun:

NAME                                STATUS   ROLES   AGE     VERSION
aks-nodepool1-xxxxxxxx-yyyyyyyyyy   Ready    agent   76s     v1.28.9

AKS'de yeni ad alanı oluşturma

Quarkus uygulamanız için Kubernetes hizmetinizde yeni bir ad alanı oluşturmak için aşağıdaki komutu kullanın:

kubectl create namespace ${AKS_NS}

Çıktı aşağıdaki örnekteki gibi görünmelidir:

namespace/<your namespace> created

Hizmet Bağlayıcısı ile AKS'de hizmet bağlantısı oluşturma

Bu bölümde, Hizmet Bağlayıcısı ile Microsoft Entra İş Yükü Kimliği kullanarak AKS kümesi ile PostgreSQL için Azure Veritabanı Esnek Sunucu arasında bir hizmet bağlantısı oluşturacaksınız. Bu bağlantı, AKS kümesinin SQL kimlik doğrulaması kullanmadan PostgreSQL için Azure Veritabanı Esnek Sunucu'ya erişmesini sağlar.

Hizmet Bağlayıcısı ile Microsoft Entra İş Yükü Kimliği kullanarak AKS kümesi ile PostgreSQL veritabanı arasında bağlantı oluşturmak için aşağıdaki komutları çalıştırın:

# 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

Yukarıdaki adımlarda son komuttan elde edilen çıktıda aşağıdaki JSON'un bulunması, hizmet bağlayıcısının başarıyla yüklenmesini gösterir:

"name": "akspostgresconn",
"provisioningState": "Succeeded",

Hizmet Bağlayıcısı tarafından oluşturulan hizmet hesabını ve gizli diziyi alma

PostgreSQL için Azure Veritabanı Esnek Sunucusunda kimlik doğrulaması yapmak için Hizmet Bağlayıcısı tarafından oluşturulan hizmet hesabını ve Kubernetes gizli dizisini almanız gerekir. Öğretici: AKS uygulamasını Azure SQL Veritabanı'ye bağlama bölümünün Kapsayıcınızı güncelleştirme bölümündeki yönergeleri izleyin. Sağlanan YAML örnek kod parçacığını kullanarak Doğrudan dağıtım oluşturma seçeneğini kullanın ve aşağıdaki adımı kullanın:

• Örnek Kubernetes dağıtımı YAML'deki vurgulanan bölümlerden aşağıdaki örnekte ve olarak <service-account-name> temsil edilen ve <secret-name> secretRef.namedeğerlerini serviceAccountName kopyalayın:

  serviceAccountName: <service-account-name>
  containers:
  - name: raw-linux
      envFrom:
         - secretRef:
            name: <secret-name>
  

  Bu değerler sonraki bölümde Quarkus uygulamasını AKS kümesine dağıtmak için kullanılır.

Bulut yerel yapılandırmasını özelleştirme

Bulutta yerel bir teknoloji olarak Quarkus standart Kubernetes, Red Hat OpenShift ve Knative için kaynakları otomatik olarak yapılandırma olanağı sunar. Daha fazla bilgi için Bkz . Quarkus Kubernetes kılavuzu, Quarkus OpenShift kılavuzu ve Quarkus Knative kılavuzu. Geliştiriciler, oluşturulan bildirimleri uygulayarak uygulamayı hedef Kubernetes kümesine dağıtabilir.

Uygun Kubernetes kaynaklarını oluşturmak için aşağıdaki komutu kullanarak ve uzantılarını yerel terminalinize ekleyin quarkus-kubernetes container-image-jib :

quarkus ext add kubernetes container-image-jib

Quarkus, bu uzantıların olarak <dependencies>listelenmiş olduğundan emin olmak için POM'yi değiştirir. adlı JBangbir şey yüklemeniz istenirse evet yanıtlayın ve yüklenmesine izin verin.

Çıktı aşağıdaki örnekteki gibi görünmelidir:

[SUCCESS] ✅  Extension io.quarkus:quarkus-kubernetes has been installed
[SUCCESS] ✅  Extension io.quarkus:quarkus-container-image-jib has been installed

Uzantıların eklendiğini doğrulamak için çalıştırabilir git diff ve çıkışı inceleyebilirsiniz.

Quarkus, bulutta yerel bir teknoloji olarak yapılandırma profillerini destekler. Quarkus aşağıdaki üç yerleşik profile sahiptir:

• dev - Geliştirme modundayken etkinleştirilir
• test - Testleri çalıştırırken etkinleştirildi
• prod - Geliştirme veya test modunda çalışmadığında varsayılan profil

Quarkus gerektiğinde herhangi bir sayıda adlandırılmış profili destekler.

Bu bölümdeki kalan adımlar sizi src/main/resources/application.properties dosyasındaki değerleri özelleştirmeye yönlendirir.

Ön ek, prod. profilde çalıştırılırken bu özelliklerin prod etkin olduğunu gösterir. Yapılandırma profilleri hakkında daha fazla bilgi için Quarkus belgelerine bakın.

Veritabanı yapılandırması

Aşağıdaki veritabanı yapılandırma değişkenlerini inceleyin. Veritabanı bağlantısıyla ilgili özellikler %prod.quarkus.datasource.jdbc.url ve %prod.quarkus.datasource.username okuma değerleri sırasıyla , AZURE_POSTGRESQL_PORTAZURE_POSTGRESQL_DATABASE, ve AZURE_POSTGRESQL_USERNAMEortam değişkenlerindenAZURE_POSTGRESQL_HOST. Bu ortam değişkenleri, veritabanı bağlantı bilgilerini depolayan gizli dizi değerleriyle eşler. Güvenlik nedeniyle, bu makalenin başka bir yerinde gösterildiği gibi Hizmet Bağlayıcısı parolasız uzantısı kullanılarak otomatik olarak oluşturulur.

# Database configurations
%prod.quarkus.datasource.jdbc.url=jdbc:postgresql://${AZURE_POSTGRESQL_HOST}:${AZURE_POSTGRESQL_PORT}/${AZURE_POSTGRESQL_DATABASE}?\
authenticationPluginClassName=com.azure.identity.extensions.jdbc.postgresql.AzurePostgresqlAuthenticationPlugin\
&sslmode=require
%prod.quarkus.datasource.username=${AZURE_POSTGRESQL_USERNAME}
%prod.quarkus.datasource.jdbc.acquisition-timeout=10
%prod.quarkus.hibernate-orm.database.generation=drop-and-create
%prod.quarkus.hibernate-orm.sql-load-script=import.sql

Kubernetes yapılandırması

Aşağıdaki Kubernetes yapılandırma değişkenlerini inceleyin. service-type , uygulamaya dışarıdan erişecek şekilde ayarlanır load-balancer . ve <secret-name> değerlerini <service-account-name> önceki bölümde kopyaladığınız gerçek değerlerin değerleriyle değiştirin.

# 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

Diğer Kubernetes yapılandırmaları, gizli dizi değerlerinin Quarkus uygulamasındaki ortam değişkenlerine eşleneceğini belirtir. Gizli <secret-name> dizi, veritabanı bağlantı bilgilerini içerir. Gizli AZURE_POSTGRESQL_CLIENTIDdizideki , AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASEve AZURE_POSTGRESQL_USERNAME anahtarları sırasıyla , AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASEve AZURE_POSTGRESQL_USERNAME ortam değişkenleriyle eşlerAZURE_CLIENT_ID.

Gizli dizileri doğrudan kubectl ile incelemek için aşağıdaki örneğe benzer komutları kullanın:

kubectl -n ${AKS_NS} get secret <secret-name> -o jsonpath="{.data.AZURE_POSTGRESQL_USERNAME}" | base64 --decode

Kapsayıcı görüntüsü yapılandırması

Bulutta yerel bir teknoloji olarak Quarkus, Docker ile uyumlu OCI kapsayıcı görüntüleri oluşturmayı destekler. değerini <LOGIN_SERVER_VALUE> ortam değişkeninin gerçek değeriyle ${LOGIN_SERVER} değiştirin.

# Container Image Build
%prod.quarkus.container-image.build=true
%prod.quarkus.container-image.image=<LOGIN_SERVER_VALUE>/todo-quarkus-aks:1.0

Son denetim olarak, application.properties dosyasındaki tüm gerekli değiştirmeleri tamamladığınızda, karakterin < yinelenmemesi gerekir. Varsa, tüm gerekli değiştirmeleri tamamladığınızdan bir kez daha kontrol edin.

Kapsayıcı görüntüsünü oluşturma ve kapsayıcı kayıt defterine gönderme

Şimdi uygulamanın kendisini oluşturmak için aşağıdaki komutu kullanın. Bu komut, kapsayıcı görüntüsünü oluşturmak için Kubernetes ve Jib uzantılarını kullanır.

quarkus build --no-tests

Çıktı ile BUILD SUCCESSbitmelidir. Kubernetes bildirim dosyaları, aşağıdaki örnekte gösterildiği gibi target/kubernetes içinde oluşturulur:

tree target/kubernetes
target/kubernetes
├── kubernetes.json
└── kubernetes.yml

0 directories, 2 files

Komut satırını (CLI) kullanarak docker kapsayıcı görüntüsünün oluşturulup oluşturulmadığını doğrulayabilirsiniz. Çıktı aşağıdaki örneğe benzer:

docker images | grep todo-quarkus-aks
<LOGIN_SERVER_VALUE>/todo-quarkus-aks   1.0       b13c389896b7   18 minutes ago   422MB

Aşağıdaki komutu kullanarak kapsayıcı görüntülerini kapsayıcı kayıt defterine gönderin:

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

Çıkış aşağıdaki örneğe benzer görünmelidir:

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

Uygulamayı kapsayıcı kayıt defterine ilettiğinize göre AKS'ye uygulamayı çalıştırmasını söyleyebilirsiniz.

Quarkus uygulamasını AKS'ye dağıtma

Bu bölümdeki adımlarda quarkus örnek uygulamasını oluşturduğunuz Azure kaynakları üzerinde nasıl çalıştırabileceğiniz gösterilmektedir.

Quarkus uygulamasını AKS'ye dağıtmak için kubectl apply kullanma

Aşağıdaki örnekte gösterildiği gibi komut satırında kullanarak kubectl Kubernetes kaynaklarını dağıtın:

kubectl apply -f target/kubernetes/kubernetes.yml -n ${AKS_NS}

Çıktı aşağıdaki örnekteki gibi görünmelidir:

service/quarkus-todo-demo-app-aks created
deployment.apps/quarkus-todo-demo-app-aks created

Aşağıdaki komutu kullanarak uygulamanın çalıştığını doğrulayın:

kubectl -n $AKS_NS get pods

alanının değeri STATUS dışında Runningbir şey gösteriyorsa devam etmeden önce sorunu giderin ve çözün. Aşağıdaki komutu kullanarak pod günlüklerini incelemeye yardımcı olabilir:

kubectl -n $AKS_NS logs $(kubectl -n $AKS_NS get pods | grep quarkus-todo-demo-app-aks | cut -d " " -f1)

EXTERNAL-IP Todo uygulamasına erişmek için aşağıdaki komutu kullanın:

kubectl get svc -n ${AKS_NS}

Çıktı aşağıdaki örnekteki gibi görünmelidir:

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

değerini bir ortam değişkenine EXTERNAL-IP tam URL olarak kaydetmek için aşağıdaki komutu kullanabilirsiniz:

export QUARKUS_URL=http://$(kubectl get svc -n ${AKS_NS} | grep quarkus-todo-demo-app-aks | cut -d " " -f10)
echo $QUARKUS_URL

değerine ${QUARKUS_URL}yeni bir web tarayıcısı açın. Ardından, metniyle Deployed the Todo app to AKSyeni bir yapılacaklar öğesi ekleyin. Ayrıca, öğeyi Introduction to Quarkus Todo App tamamlandı olarak seçin.

Aşağıdaki örnekte gösterildiği gibi Azure PostgreSQL veritabanında depolanan tüm yapılacaklar öğelerini almak için RESTful API'sine (/api) erişin:

curl --verbose ${QUARKUS_URL}/api | jq .

Çıktı aşağıdaki örnekteki gibi görünmelidir:

* 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
  }
]

Veritabanının güncelleştirildiğini doğrulayın

Veritabanının şimdi doğru güncelleştirildiğini doğrulamak için aşağıdaki komutu çalıştırın:

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;"

Uzantı yüklemeniz istenirse Y yanıtlayın.

Çıktı aşağıdaki örneğe benzer görünmelidir ve todo uygulama GUI'sine ve komutun çıktısına curl daha önce aynı öğeleri içermelidir:

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
  }
]

İşiniz bittiğinde, aşağıdaki komutu kullanarak yerel IP adresinizin PostgreSQL için Azure Veritabanı Esnek Sunucu örneğine erişmesine izin veren güvenlik duvarı kuralını silin:

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

Kaynakları temizleme

Azure ücretlerinden kaçınmak için gereksiz kaynakları temizlemeniz gerekir. Küme artık gerekli olmadığında az group delete komutunu kullanarak kaynak grubunu, kapsayıcı hizmetini, kapsayıcı kayıt defterini ve tüm ilgili kaynakları kaldırın.

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

Kapsayıcı görüntülerini postgres silmek ve testcontainers Quarkus geliştirme modu tarafından oluşturulanları silmek için de kullanmak docker rmi isteyebilirsiniz.

Sonraki adımlar

• Azure Kubernetes Service
• Azure İşlevleri üzerinde Quarkus ile sunucusuz Java uygulamaları dağıtma
• Quarkus
• Kubernetes Uzantısı
• Jib Seçenekleri
• Azure'da Jakarta EE