Bezpečné škálování aplikací pomocí doplňku KEDA a identity úloh ve službě Azure Kubernetes Service (AKS)

Článek
08/02/2024

Tento článek ukazuje, jak bezpečně škálovat aplikace pomocí doplňku KeDA (Event-driven Auto Scale) Kubernetes a identity úloh ve službě Azure Kubernetes Service (AKS).

Důležité

Verze Kubernetes vašeho clusteru určuje, jaká verze KEDA se nainstaluje v clusteru AKS. Pokud chcete zjistit, která verze KEDA se mapuje na každou verzi AKS, podívejte se na sloupec spravovaných doplňků AKS v tabulce verzí komponent Kubernetes.

Pro verze GA Kubernetes nabízí AKS plnou podporu odpovídající podverze KEDA v tabulce. Verze Kubernetes Preview a nejnovější opravy KEDA jsou částečně pokryty zákaznickou podporou na základě maximálního úsilí. Proto tyto funkce nejsou určené pro produkční použití. Další informace najdete v následujících článcích podpory:

Než začnete

Musíte mít předplatné Azure. Pokud ještě nemáte předplatné Azure, můžete si vytvořit bezplatný účet.
Potřebujete nainstalované Rozhraní příkazového řádku Azure.
Ujistěte se, že máte nakonfigurovaná pravidla brány firewall tak, aby povolovala přístup k serveru rozhraní API Kubernetes. Další informace najdete v tématu Odchozí síť a pravidla plně kvalifikovaného názvu domény pro clustery Azure Kubernetes Service (AKS).

Vytvoření skupiny zdrojů

Pomocí příkazu vytvořte skupinu az group create prostředků. Nezapomeňte nahradit zástupné hodnoty vlastními hodnotami.
```
LOCATION=<azure-region>
RG_NAME=<resource-group-name>

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

Vytvoření clusteru AKS

Vytvořte cluster AKS s doplňkem KEDA, identitou úloh a vystavitelem OIDC, který je povolený pomocí az aks create příkazu se značkou --enable-workload-identity, --enable-kedaa --enable-oidc-issuer příznaky. Nezapomeňte nahradit zástupnou hodnotu vlastní hodnotou.
```
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 
```
Ověřte, že nasazení proběhlo úspěšně, a pomocí příkazu s příznakem --query nastaveným "[workloadAutoScalerProfile, securityProfile, oidcIssuerProfile]"příznakem ověřte, že je v clusteru povolená az aks show identita keDA, identita úloh a vystavitel OIDC.
```
az aks show \
    --name $AKS_NAME \
    --resource-group $RG_NAME \
    --query "[workloadAutoScalerProfile, securityProfile, oidcIssuerProfile]"
```

Připojte se ke clusteru az aks get-credentials pomocí příkazu.

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

Vytvoření služby Azure Service Bus

Pomocí příkazu vytvořte obor názvů az servicebus namespace create služby Azure Service Bus. Nezapomeňte nahradit zástupnou hodnotu vlastní hodnotou.

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

Pomocí příkazu vytvořte frontu az servicebus queue create služby Azure Service Bus. Nezapomeňte nahradit zástupnou hodnotu vlastní hodnotou.

SB_QUEUE_NAME=<service-bus-queue-name>

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

Vytvoření spravované identity

Vytvořte spravovanou identitu pomocí az identity create příkazu. Nezapomeňte nahradit zástupnou hodnotu vlastní hodnotou.

MI_NAME=<managed-identity-name>

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

Získejte adresu URL vystavitele OIDC pomocí az aks show příkazu s příznakem nastaveným --query na oidcIssuerProfile.issuerUrl.

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

Pomocí příkazu vytvořte federované přihlašovací údaje mezi spravovanou identitou a oborem názvů a účtem služby používaným úlohou az identity federated-credential create . Nezapomeňte nahradit zástupnou hodnotu vlastní hodnotou.

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

Vytvořte druhé federované přihlašovací údaje mezi spravovanou identitou a účtem oboru názvů a služby používaným operátorem keda pomocí az identity federated-credential create příkazu. Nezapomeňte nahradit zástupnou hodnotu vlastní hodnotou.

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

Vytvoření přiřazení rolí

Získejte ID objektu pro spravovanou az identity show identitu pomocí příkazu s příznakem nastaveným --query na "principalId".

MI_OBJECT_ID=$(az identity show \
    --name $MI_NAME \
    --resource-group $RG_NAME \
    --query "principalId" \
    --output tsv)

Získejte ID prostředku oboru názvů Service Bus pomocí az servicebus namespace show příkazu s příznakem nastaveným --query na "id".
```
SB_ID=$(az servicebus namespace show \
    --name $SB_NAME \
    --resource-group $RG_NAME \
    --query "id" \
    --output tsv)
```

Pomocí příkazu přiřaďte roli Vlastník dat služby Azure Service Bus ke spravované identitě az role assignment create .

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

Povolení identity úloh v operátoru KEDA

Po vytvoření federovaných přihlašovacích údajů pro keda-operator serviceAccount budete muset pody ručně restartovat keda-operator , abyste zajistili, že se do podu vloží proměnné prostředí identity úloh.
```
kubectl rollout restart deploy keda-operator -n kube-system
```

Potvrzení restartování podů keda-operator

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

Jakmile ověříte, že pody keda-operator dokončily postupné spuštění, Ctrl+c aby se předchozí příkaz kukátku přerušil, ověřte, že se vložily proměnné prostředí identity úloh.
```
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
```

Měl by se zobrazit výstup podobný následujícímu v části Prostředí.

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

Nasaďte prostředek KEDA TriggerAuthentication, který obsahuje ID klienta spravované identity přiřazené uživatelem.
```
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
```
Poznámka:

Když je triggerAuthentication zavedený, keDA se bude moct ověřit prostřednictvím identity úlohy. Pody keda-operator používají identityId při vyhodnocování triggerů škálování ověřování vůči prostředkům Azure.

Publikování zpráv do služby Azure Service Bus

V tomto okamžiku je vše nakonfigurované pro škálování pomocí KEDA a identity úloh Microsoft Entra. Otestujeme to nasazením úloh producenta a spotřebitele.

Vytvořte nový účet ServiceAccount pro úlohy.

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

Nasaďte úlohu pro publikování 100 zpráv.

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

Využívání zpráv ze služby Azure Service Bus

Teď, když jsme publikovali zprávy do fronty služby Azure Service Bus, nasadíme službu ScaledJob, která bude zprávy využívat. Tato škálovaná úloha použije prostředek KEDA TriggerAuthentication k ověření ve frontě služby Azure Service Bus pomocí identity úlohy a horizontální navýšení kapacity každých 10 zpráv.

Nasaďte prostředek ScaledJob pro využívání zpráv. Aktivační událost škálování se nakonfiguruje tak, aby škálovala každých 10 zpráv. Scaler KEDA vytvoří 10 úloh, které spotřebují 100 zpráv.

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

Poznámka:

ScaledJob vytvoří prostředek úlohy Kubernetes vždy, když dojde k události škálování, a proto se při vytváření prostředku musí předat šablona úlohy. Při vytváření nových úloh se pody nasadí s bity identit úloh, které budou přijímat zprávy.

Ověřte, že škálovač KEDA fungoval podle očekávání.
```
kubectl describe scaledjob myconsumer-scaledjob
```

Měly by se zobrazit události podobné následujícímu.

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

Vyčištění prostředků

Po ověření úspěšného nasazení můžete prostředky vyčistit, abyste se vyhnuli účtování nákladů na Azure.

Pomocí příkazu [az group delete][az-group-delete] odstraňte skupinu prostředků Azure a všechny prostředky v ní.
```
az group delete --name $RG_NAME --yes --no-wait
```

Další kroky

Tento článek vám ukázal, jak bezpečně škálovat aplikace pomocí doplňku KEDA a identity úloh v AKS.

Informace o řešení potíží keDA najdete v tématu Řešení potíží s doplňkem KeDA (Event-driven Autoscaling) Kubernetes (KEDA).

Další informace o KEDA najdete v upstreamových dokumentech KEDA.

Sdílet prostřednictvím