Bagikan melalui


Skalakan aplikasi Anda dengan aman menggunakan add-on KEDA dan identitas beban kerja di Azure Kubernetes Service (AKS)

Artikel ini menunjukkan cara menskalakan aplikasi dengan aman dengan add-on Dan identitas beban kerja Kubernetes Event-driven Autoscaling (KEDA) di Azure Kubernetes Service (AKS).

Penting

Versi Kubernetes kluster Anda menentukan versi KEDA apa yang akan diinstal pada kluster AKS Anda. Untuk melihat versi KEDA mana yang dipetakan ke setiap versi AKS, lihat kolom add-on terkelola AKS dari tabel versi komponen Kubernetes.

Untuk versi GA Kubernetes, AKS menawarkan dukungan penuh dari versi minor KEDA yang sesuai dalam tabel. Versi pratinjau Kubernetes dan patch KEDA terbaru sebagian dicakup oleh dukungan pelanggan berdasarkan upaya terbaik. Dengan demikian, fitur-fitur ini tidak dimaksudkan untuk penggunaan produksi. Untuk informasi lebih lanjut, lihat artikel dukungan berikut ini:

Sebelum Anda mulai

Buat grup sumber daya

  • Buat grup sumber daya menggunakan az group create perintah . Pastikan Anda mengganti nilai tempat penampung dengan nilai Anda sendiri.

    LOCATION=<azure-region>
    RG_NAME=<resource-group-name>
    
    az group create --name $RG_NAME --location $LOCATION
    

Membuat kluster AKS

  1. Buat kluster AKS dengan add-on KEDA, identitas beban kerja, dan pengeluar sertifikat OIDC diaktifkan menggunakan az aks create perintah dengan --enable-workload-identitybendera , --enable-keda, dan --enable-oidc-issuer . Pastikan Anda mengganti nilai tempat penampung dengan nilai Anda sendiri.

    AKS_NAME=<cluster-name>
    
    az aks create \
        --name $AKS_NAME \
        --resource-group $RG_NAME \
        --enable-workload-identity \
        --enable-oidc-issuer \
        --enable-keda \
        --generate-ssh-keys 
    
  2. Validasi penyebaran berhasil dan pastikan kluster memiliki KEDA, identitas beban kerja, dan penerbit OIDC yang diaktifkan menggunakan az aks show perintah dengan bendera yang --query diatur ke "[workloadAutoScalerProfile, securityProfile, oidcIssuerProfile]".

    az aks show \
        --name $AKS_NAME \
        --resource-group $RG_NAME \
        --query "[workloadAutoScalerProfile, securityProfile, oidcIssuerProfile]"
    
  3. Sambungkan ke kluster menggunakan az aks get-credentials perintah .

    az aks get-credentials \
        --name $AKS_NAME \
        --resource-group $RG_NAME \
        --overwrite-existing
    

Membuat Azure Service Bus

  1. Buat namespace azure Bus Layanan menggunakan az servicebus namespace create perintah . Pastikan untuk mengganti nilai tempat penampung dengan nilai Anda sendiri.

    SB_NAME=<service-bus-name>
    SB_HOSTNAME="${SB_NAME}.servicebus.windows.net"
    
    az servicebus namespace create \
        --name $SB_NAME \
        --resource-group $RG_NAME \
        --disable-local-auth
    
  2. Buat antrean Azure Bus Layanan menggunakan az servicebus queue create perintah . Pastikan untuk mengganti nilai tempat penampung dengan nilai Anda sendiri.

    SB_QUEUE_NAME=<service-bus-queue-name>
    
    az servicebus queue create \
        --name $SB_QUEUE_NAME \
        --namespace $SB_NAME \
        --resource-group $RG_NAME
    

Buat identitas terkelola

  1. Buat identitas terkelola menggunakan az identity create perintah . Pastikan untuk mengganti nilai tempat penampung dengan nilai Anda sendiri.

    MI_NAME=<managed-identity-name>
    
    MI_CLIENT_ID=$(az identity create \
        --name $MI_NAME \
        --resource-group $RG_NAME \
        --query "clientId" \
        --output tsv)
    
  2. Dapatkan URL penerbit OIDC menggunakan az aks show perintah dengan bendera diatur --query ke oidcIssuerProfile.issuerUrl.

    AKS_OIDC_ISSUER=$(az aks show \
        --name $AKS_NAME \
        --resource-group $RG_NAME \
        --query oidcIssuerProfile.issuerUrl \
        --output tsv)
    
  3. Buat kredensial federasi antara identitas terkelola dan namespace layanan dan akun layanan yang digunakan oleh beban kerja menggunakan az identity federated-credential create perintah . Pastikan untuk mengganti nilai tempat penampung dengan nilai Anda sendiri.

    FED_WORKLOAD=<federated-credential-workload-name>
    
    az identity federated-credential create \
        --name $FED_WORKLOAD \
        --identity-name $MI_NAME \
        --resource-group $RG_NAME \
        --issuer $AKS_OIDC_ISSUER \
        --subject system:serviceaccount:default:$MI_NAME \
        --audience api://AzureADTokenExchange
    
  4. Buat kredensial federasi kedua antara identitas terkelola dan namespace layanan dan akun layanan yang digunakan oleh operator keda menggunakan az identity federated-credential create perintah . Pastikan untuk mengganti nilai tempat penampung dengan nilai Anda sendiri.

    FED_KEDA=<federated-credential-keda-name>
    
    az identity federated-credential create \
        --name $FED_KEDA \
        --identity-name $MI_NAME \
        --resource-group $RG_NAME \
        --issuer $AKS_OIDC_ISSUER \
        --subject system:serviceaccount:kube-system:keda-operator \
        --audience api://AzureADTokenExchange
    

Membuat penetapan peran

  1. Dapatkan ID objek untuk identitas terkelola menggunakan az identity show perintah dengan bendera diatur --query ke "principalId".

    MI_OBJECT_ID=$(az identity show \
        --name $MI_NAME \
        --resource-group $RG_NAME \
        --query "principalId" \
        --output tsv)
    
  2. Dapatkan ID sumber daya namespace Bus Layanan menggunakan az servicebus namespace show perintah dengan bendera diatur --query ke "id".

    SB_ID=$(az servicebus namespace show \
        --name $SB_NAME \
        --resource-group $RG_NAME \
        --query "id" \
        --output tsv)
    
  3. Tetapkan peran Pemilik Data azure Bus Layanan ke identitas terkelola az role assignment create menggunakan perintah .

    az role assignment create \
        --role "Azure Service Bus Data Owner" \
        --assignee-object-id $MI_OBJECT_ID \
        --assignee-principal-type ServicePrincipal \
        --scope $SB_ID
    

Mengaktifkan Identitas Beban Kerja pada operator KEDA

  1. Setelah membuat kredensial federasi untuk keda-operator ServiceAccount, Anda harus menghidupkan ulang keda-operator pod secara manual untuk memastikan variabel lingkungan Identitas Beban Kerja disuntikkan ke dalam pod.

    kubectl rollout restart deploy keda-operator -n kube-system
    
  2. Mengonfirmasi mulai ulang pod operator keda

    kubectl get pod -n kube-system -lapp=keda-operator -w
    
  3. Setelah Anda mengonfirmasi pod operator keda telah selesai melakukan hit Ctrl+c bergulir untuk memutus perintah jam tangan sebelumnya, lalu konfirmasikan variabel lingkungan Identitas Beban Kerja telah disuntikkan.

    KEDA_POD_ID=$(kubectl get po -n kube-system -l app.kubernetes.io/name=keda-operator -ojsonpath='{.items[0].metadata.name}')
    kubectl describe po $KEDA_POD_ID -n kube-system
    
  4. Anda akan melihat output yang mirip dengan yang berikut ini di bawah Lingkungan.

    ---
    AZURE_CLIENT_ID:
    AZURE_TENANT_ID:               xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxx
    AZURE_FEDERATED_TOKEN_FILE:    /var/run/secrets/azure/tokens/azure-identity-token
    AZURE_AUTHORITY_HOST:          https://login.microsoftonline.com/
    ---
    
  5. Sebarkan sumber daya TriggerAuthentication KEDA yang menyertakan ID Klien Identitas Terkelola yang Ditetapkan Pengguna.

    kubectl apply -f - <<EOF
    apiVersion: keda.sh/v1alpha1
    kind: TriggerAuthentication
    metadata:
      name: azure-servicebus-auth
      namespace: default  # this must be same namespace as the ScaledObject/ScaledJob that will use it
    spec:
      podIdentity:
        provider:  azure-workload
        identityId: $MI_CLIENT_ID
    EOF
    

    Catatan

    Dengan TriggerAuthentication di tempat, KEDA akan dapat mengautentikasi melalui identitas beban kerja. Pod keda-operator menggunakan identityId untuk mengautentikasi terhadap sumber daya Azure saat mengevaluasi pemicu penskalan.

Menerbitkan pesan ke Azure Bus Layanan

Pada titik ini semuanya dikonfigurasi untuk penskalaan dengan KEDA dan Identitas Beban Kerja Microsoft Entra. Kami akan menguji ini dengan menyebarkan beban kerja produsen dan konsumen.

  1. Buat ServiceAccount baru untuk beban kerja.

    kubectl apply -f - <<EOF
    apiVersion: v1
    kind: ServiceAccount
    metadata:
      annotations:
        azure.workload.identity/client-id: $MI_CLIENT_ID
      name: $MI_NAME
    EOF
    
  2. Sebarkan Pekerjaan untuk menerbitkan 100 pesan.

    kubectl apply -f - <<EOF
    apiVersion: batch/v1
    kind: Job
    metadata:
      name: myproducer
    spec:
      template:
        metadata:
          labels:
            azure.workload.identity/use: "true"
        spec:
          serviceAccountName: $MI_NAME
          containers:
          - image: ghcr.io/azure-samples/aks-app-samples/servicebusdemo:latest
            name: myproducer
            resources: {}
            env:
            - name: OPERATION_MODE
              value: "producer"
            - name: MESSAGE_COUNT
              value: "100"
            - name: AZURE_SERVICEBUS_QUEUE_NAME
              value: $SB_QUEUE_NAME
            - name: AZURE_SERVICEBUS_HOSTNAME
              value: $SB_HOSTNAME
          restartPolicy: Never
    EOF
    

Menggunakan pesan dari Azure Bus Layanan

Sekarang setelah kita menerbitkan pesan ke antrean Azure Bus Layanan, kita akan menyebarkan ScaledJob untuk menggunakan pesan. ScaledJob ini akan menggunakan sumber daya KEDA TriggerAuthentication untuk mengautentikasi terhadap antrean Azure Bus Layanan menggunakan identitas beban kerja dan meluaskan skala setiap 10 pesan.

  1. Sebarkan sumber daya ScaledJob untuk menggunakan pesan. Pemicu skala akan dikonfigurasi untuk meluaskan skala setiap 10 pesan. Penskala KEDA akan membuat 10 pekerjaan untuk mengonsumsi 100 pesan.

    kubectl apply -f - <<EOF
    apiVersion: keda.sh/v1alpha1
    kind: ScaledJob
    metadata:
      name: myconsumer-scaledjob
    spec:
      jobTargetRef:
        template:
          metadata:
            labels:
              azure.workload.identity/use: "true"
          spec:
            serviceAccountName: $MI_NAME
            containers:
            - image: ghcr.io/azure-samples/aks-app-samples/servicebusdemo:latest
              name: myconsumer
              env:
              - name: OPERATION_MODE
                value: "consumer"
              - name: MESSAGE_COUNT
                value: "10"
              - name: AZURE_SERVICEBUS_QUEUE_NAME
                value: $SB_QUEUE_NAME
              - name: AZURE_SERVICEBUS_HOSTNAME
                value: $SB_HOSTNAME
            restartPolicy: Never
      triggers:
      - type: azure-servicebus
        metadata:
          queueName: $SB_QUEUE_NAME
          namespace: $SB_NAME
          messageCount: "10"
        authenticationRef:
          name: azure-servicebus-auth
    EOF
    

    Catatan

    ScaledJob membuat sumber daya Pekerjaan Kubernetes setiap kali peristiwa penskalakan terjadi dan dengan demikian templat Pekerjaan perlu diteruskan saat membuat sumber daya. Saat Pekerjaan baru dibuat, Pod akan disebarkan dengan bit identitas beban kerja untuk menggunakan pesan.

  2. Verifikasi bahwa penskala KEDA berfungsi seperti yang dimaksudkan.

    kubectl describe scaledjob myconsumer-scaledjob
    
  3. Anda akan melihat peristiwa yang mirip dengan yang berikut ini.

    Events:
    Type     Reason              Age   From           Message
    ----     ------              ----  ----           -------
    Normal   KEDAScalersStarted  10m   scale-handler  Started scalers watch
    Normal   ScaledJobReady      10m   keda-operator  ScaledJob is ready for scaling
    Warning  KEDAScalerFailed    10m   scale-handler  context canceled
    Normal   KEDAJobsCreated     10m   scale-handler  Created 10 jobs
    

Membersihkan sumber daya

Setelah memverifikasi bahwa penyebaran berhasil, Anda dapat membersihkan sumber daya untuk menghindari timbulnya biaya Azure.

  1. Hapus grup sumber daya Azure dan semua sumber daya di dalamnya menggunakan perintah [az group delete][az-group-delete].

    az group delete --name $RG_NAME --yes --no-wait
    

Langkah berikutnya

Artikel ini menunjukkan kepada Anda cara menskalakan aplikasi Anda dengan aman menggunakan add-on KEDA dan identitas beban kerja di AKS.

Untuk informasi tentang pemecahan masalah KEDA, lihat Memecahkan masalah add-on Autoscaling berbasis Peristiwa (KEDA) Kubernetes.

Untuk mempelajari selengkapnya tentang KEDA, lihat dokumen KEDA hulu.