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

Artikel
08/02/2024

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

Anda memerlukan langganan Azure. Jika Anda tidak memiliki langganan Azure, Anda dapat membuat akun gratis.
Anda memerlukan Azure CLI yang terinstal.
Pastikan Anda memiliki aturan firewall yang dikonfigurasi untuk mengizinkan akses ke server API Kubernetes. Untuk informasi selengkapnya, lihat Aturan jaringan keluar dan FQDN untuk kluster Azure Kubernetes Service (AKS).

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

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 
```
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]"
```

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

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

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

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)

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)

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

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

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)

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)

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

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
```

Mengonfirmasi mulai ulang pod operator keda

kubectl get pod -n kube-system -lapp=keda-operator -w

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
```

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/
---

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.

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

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.

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.

Verifikasi bahwa penskala KEDA berfungsi seperti yang dimaksudkan.
```
kubectl describe scaledjob myconsumer-scaledjob
```

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.

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.

Bagikan melalui