Alkalmazások biztonságos skálázása az Azure Kubernetes Service (AKS) KEDA bővítmény- és számításifeladat-identitásával

Cikk
2025-04-09

Ez a cikk bemutatja, hogyan skálázhatja biztonságosan az alkalmazásokat a Kubernetes eseményvezérelt automatikus skálázási (KEDA) bővítményével és számítási feladatainak identitásával az Azure Kubernetes Service-ben (AKS).

Fontos

A Kubernetes-verzió a fürtön határozza meg, hogy milyen KEDA-verzió települ az AKS-fürtön. Az egyes AKS-verziókhoz tartozó KEDA-verziók megtekintéséhez tekintse meg a Kubernetes-összetevő verziótáblájának AKS által felügyelt bővítmények oszlopát.

A GA Kubernetes-verziók esetében az AKS teljes mértékben támogatja a táblázat megfelelő KEDA-alverzióját. A Kubernetes előzetes verzióit és a legújabb KEDA-javításokat részben az ügyfélszolgálat fedezi a legjobb munka érdekében. Ezért ezek a funkciók nem éles használatra vannak szánva. További információkért tekintse meg az alábbi támogatási cikkeket:

Mielőtt elkezdené

Azure-előfizetésre van szüksége. Ha nem rendelkezik Azure-előfizetéssel, létrehozhat egy ingyenes fiókot.
Telepítenie kell az Azure CLI-t.
Győződjön meg arról, hogy tűzfalszabályok vannak konfigurálva a Kubernetes API-kiszolgálóhoz való hozzáférés engedélyezéséhez. További információért lásd: Az Azure Kubernetes Service (AKS) fürtök kimenő hálózati és FQDN-jére vonatkozó szabályok.

Erőforráscsoport létrehozása

Hozzon létre egy erőforráscsoportot a az group create paranccsal. Győződjön meg arról, hogy a helyőrző értékeket a saját értékeire cseréli.
```
LOCATION=<azure-region>
RG_NAME=<resource-group-name>

az group create --name $RG_NAME --location $LOCATION
```

AKS-fürt létrehozása

Hozzon létre egy AKS-fürtöt a KEDA bővítménnyel, a munkafolyamat-identitással és az OIDC-kiállító engedélyezésével a az aks create paranccsal a --enable-workload-identity, --enable-keda és --enable-oidc-issuer jelzőkkel. Győződjön meg arról, hogy a helyőrző értéket saját maga értékére cseréli.
```
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 
```
Ellenőrizze, hogy az üzembe helyezés sikeres volt-e, és győződjön meg arról, hogy a fürtben engedélyezve van a KEDA, a munkaterhelés-azonosság, és az OIDC-kiállító a az aks show parancs és a --query jelző "[workloadAutoScalerProfile, securityProfile, oidcIssuerProfile]"-re állítása révén.
```
az aks show \
    --name $AKS_NAME \
    --resource-group $RG_NAME \
    --query "[workloadAutoScalerProfile, securityProfile, oidcIssuerProfile]"
```

Csatlakozzon a fürthöz a az aks get-credentials parancs használatával.

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

Azure Service Bus létrehozása

Hozzon létre egy Azure Service Bus-névteret a az servicebus namespace create paranccsal. Ügyeljen arra, hogy a helyőrző értéket cserélje le a saját értékére.

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

Hozzon létre egy Azure Service Bus-üzenetsort a az servicebus queue create paranccsal. Ügyeljen arra, hogy a helyőrző értéket helyettesítse a saját értékével.
```
SB_QUEUE_NAME=<service-bus-queue-name>

az servicebus queue create \
    --name $SB_QUEUE_NAME \
    --namespace $SB_NAME \
    --resource-group $RG_NAME
```

Felügyelt identitás létrehozása

Felügyelt identitás létrehozása a az identity create paranccsal. Ügyeljen arra, hogy a helyőrző értéket cserélje le a saját értékére.

MI_NAME=<managed-identity-name>

MI_CLIENT_ID=$(az identity create \
    --name $MI_NAME \
    --resource-group $RG_NAME \
    --query "clientId" \
    --output tsv)

Kérje le az OIDC-kiállító URL-címét a az aks show parancs segítségével, a --query jelölőt oidcIssuerProfile.issuerUrl állapotra állítva.

AKS_OIDC_ISSUER=$(az aks show \
    --name $AKS_NAME \
    --resource-group $RG_NAME \
    --query oidcIssuerProfile.issuerUrl \
    --output tsv)

Federált hitelesítő adat létrehozása a felügyelt identitás és a számítási feladathoz használt névtér és szolgáltatásfiók között a az identity federated-credential create parancs használatával. Ügyeljen arra, hogy a helyőrző értéket cserélje le a saját értékére.

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

Hozzon létre egy második összevont hitelesítő adatot a felügyelt identitás, valamint a keda-operátor által használt névtér és szolgáltatásfiók között a az identity federated-credential create parancs segítségével. Ügyeljen arra, hogy a helyőrző értéket helyettesítse a saját értékével.
```
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
```

Szerepkörök hozzárendelése

Szerezze meg a felügyelt identitás objektumazonosítóját a az identity show parancs segítségével úgy, hogy a --query jelölő "principalId" értékű legyen.
```
MI_OBJECT_ID=$(az identity show \
    --name $MI_NAME \
    --resource-group $RG_NAME \
    --query "principalId" \
    --output tsv)
```
A az servicebus namespace show parancs használatával, ahol a --query jelölő "id" értékre van állítva, kérje le a Service Bus névtér erőforrás-azonosítóját.
```
SB_ID=$(az servicebus namespace show \
    --name $SB_NAME \
    --resource-group $RG_NAME \
    --query "id" \
    --output tsv)
```

Rendelje hozzá az Azure Service Bus adattulajdonosi szerepkört a felügyelt identitáshoz a az role assignment create paranccsal.

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

Számítási feladatok identitásának engedélyezése a KEDA-operátoron

Miután létrehozta a ServiceAccount számára a federált hitelesítő adatot keda-operator, manuálisan újra kell indítania a keda-operator podokat, hogy biztosítva legyen a Workload Identity környezeti változók beágyazása a podba.
```
kubectl rollout restart deploy keda-operator -n kube-system
```
Ellenőrizze, hogy a keda-operátor podjai újraindulnak-e
```
kubectl get pod -n kube-system -lapp=keda-operator -w
```
Miután meggyőződött arról, hogy a keda-operátor podok frissítése befejeződött, üsse le a Ctrl+c-t az előző figyelőparancs megszakításához, majd ellenőrizze, hogy a Workload Identity környezeti változók be lettek-e injektálva.
```
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
```

A következőhöz hasonló kimenetnek kell megjelennie a Környezet területen.

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

Helyezzen üzembe egy KEDA TriggerAuthentication erőforrást, amely tartalmazza a felhasználó által hozzárendelt felügyelt identitás ügyfél-azonosítóját.
```
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
```
Feljegyzés

A TriggerAuthentication használatával a KEDA képes lesz a számítási feladatok identitásán keresztüli hitelesítésre. A keda-operator tárolók a identityId elemet használják az Azure-erőforrások elleni hitelesítéshez a skálázási triggerek kiértékelésekor.

Üzenetek közzététele az Azure Service Busban

Ezen a ponton minden a KEDA és a Microsoft Entra Workload Identity szerinti skálázáshoz van beállítva. Ezt a gyártói és fogyasztói számítási feladatok üzembe helyezésével fogjuk tesztelni.

Hozzon létre egy új ServiceAccount-fiókot a számítási feladatokhoz.

kubectl apply -f - <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
  annotations:
    azure.workload.identity/client-id: $MI_CLIENT_ID
  name: $MI_NAME
EOF

Feladat üzembe helyezése 100 üzenet közzétételéhez.

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

Üzenetek fogadása az Azure Service Busból

Most, hogy közzétettük az üzeneteket az Azure Service Bus-üzenetsoron, üzembe helyezünk egy ScaledJob-et az üzenetek felhasználásához. Ez a ScaledJob a KEDA TriggerAuthentication erőforrást fogja használni az Azure Service Bus üzenetsoron való hitelesítéshez a számítási feladat identitásának alkalmazásával, és 10 üzenetenként skálázódik fel.

ScaledJob-erőforrás üzembe helyezése az üzenetek felhasználásához. A méretezési eseményindító úgy lesz konfigurálva, hogy 10 üzenetenként felskálázható legyen. A KEDA-skálázó 10 feladatot hoz létre a 100 üzenet felhasználásához.

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

Megjegyzés

A ScaledJob létrehoz egy Kubernetes-feladaterőforrást, amikor skálázási esemény történik, és így egy feladatsablont kell átadni az erőforrás létrehozásakor. Amikor új munkafolyamatok jönnek létre, a podok munkaterhelési identitáselemekkel lesznek üzembe helyezve az üzenetek feldolgozásához.

Ellenőrizze, hogy a KEDA-skálázó a kívánt módon működött-e.
```
kubectl describe scaledjob myconsumer-scaledjob
```

Az alábbiakhoz hasonló eseményeket kell látnia.

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

Az erőforrások megtisztítása

Az üzembe helyezés sikerességének ellenőrzése után törölheti az erőforrásokat az Azure-költségek elkerülése érdekében.

Törölje az Azure-erőforráscsoportot és a benne lévő összes erőforrást az [az group delete][az-group-delete] paranccsal.
```
az group delete --name $RG_NAME --yes --no-wait
```

Következő lépések

Ez a cikk bemutatta, hogyan skálázhatja biztonságosan az alkalmazásokat a KEDA bővítmény és a számítási feladatok identitásának használatával az AKS-ben.

A KEDA hibaelhárításával kapcsolatos információkért tekintse meg a Kubernetes eseményvezérelt automatikus skálázási (KEDA) bővítmény hibaelhárítását.

A KEDA-ról további információt a felsőbb rétegbeli KEDA-dokumentációkban talál.

Megosztás a következőn keresztül: