Skala dina program på ett säkert sätt med hjälp av KEDA-tillägget och arbetsbelastningsidentiteten i Azure Kubernetes Service (AKS)

Artikel
11/22/2024

Den här artikeln visar hur du på ett säkert sätt skalar dina program med tillägget Kubernetes Händelsedriven autoskalning (KEDA) och arbetsbelastningsidentitet i Azure Kubernetes Service (AKS).

Viktigt!

Kubernetes-klustret avgör vilken KEDA-version som ska installeras i AKS-klustret. Information om vilken KEDA-version som mappas till varje AKS-version finns i kolumnen AKS-hanterade tillägg i kubernetes-komponentversionstabellen.

För GA Kubernetes-versioner erbjuder AKS fullt stöd för motsvarande KEDA-delversion i tabellen. Förhandsversioner av Kubernetes och den senaste KEDA-korrigeringen omfattas delvis av kundsupport på bästa sätt. Därför är dessa funktioner inte avsedda för produktionsanvändning. Mer information finns i följande supportartiklar:

Innan du börjar

Du behöver en Azure-prenumerationen. Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto.
Du behöver Azure CLI installerat.
Se till att du har konfigurerat brandväggsregler för att tillåta åtkomst till Kubernetes API-servern. Mer information finns i Utgående nätverk och FQDN-regler för AKS-kluster (Azure Kubernetes Service).

Skapa en resursgrupp

Skapa en resursgrupp med kommandot az group create . Se till att du ersätter platshållarvärdena med dina egna värden.
```
LOCATION=<azure-region>
RG_NAME=<resource-group-name>

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

Skapa ett AKS-kluster

Skapa ett AKS-kluster med KEDA-tillägget, arbetsbelastningsidentiteten och OIDC-utfärdaren az aks create aktiverade med kommandot med flaggorna --enable-workload-identity, --enable-kedaoch --enable-oidc-issuer . Se till att du ersätter platshållarvärdet med ditt eget värde.
```
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 
```
Verifiera att distributionen lyckades och kontrollera att klustret har KEDA, arbetsbelastningsidentitet och OIDC-utfärdare aktiverat med kommandot az aks show med --query flaggan inställd på "[workloadAutoScalerProfile, securityProfile, oidcIssuerProfile]".
```
az aks show \
    --name $AKS_NAME \
    --resource-group $RG_NAME \
    --query "[workloadAutoScalerProfile, securityProfile, oidcIssuerProfile]"
```

Anslut till klustret med kommandot az aks get-credentials .

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

Skapa en Azure Service Bus

Skapa ett Azure Service Bus-namnområde med hjälp av az servicebus namespace create kommandot . Ersätt platshållarvärdet med ditt eget värde.

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

Skapa en Azure Service Bus-kö med kommandot az servicebus queue create . Ersätt platshållarvärdet med ditt eget värde.

SB_QUEUE_NAME=<service-bus-queue-name>

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

Skapa en hanterad identitet

Skapa en hanterad identitet med kommandot az identity create . Ersätt platshållarvärdet med ditt eget värde.

MI_NAME=<managed-identity-name>

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

Hämta OIDC-utfärdarens az aks show URL med kommandot med --query flaggan inställd på oidcIssuerProfile.issuerUrl.

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

Skapa en federerad autentiseringsuppgift mellan den hanterade identiteten och namnområdet och tjänstkontot som används av arbetsbelastningen med hjälp av az identity federated-credential create kommandot . Ersätt platshållarvärdet med ditt eget värde.

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

Skapa en andra federerad autentiseringsuppgift mellan den hanterade identiteten och namnområdet och tjänstkontot som används av keda-operatorn med hjälp av az identity federated-credential create kommandot . Ersätt platshållarvärdet med ditt eget värde.

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

Skapa rolltilldelningar

Hämta objekt-ID:t för den hanterade identiteten az identity show med kommandot med --query flaggan inställd på "principalId".

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

Hämta resurs-ID:t för Service Bus-namnområdet med az servicebus namespace show kommandot med --query flaggan inställd på "id".

SB_ID=$(az servicebus namespace show \
    --name $SB_NAME \
    --resource-group $RG_NAME \
    --query "id" \
    --output tsv)

Tilldela rollen Azure Service Bus-dataägare till den hanterade identiteten az role assignment create med hjälp av kommandot .

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

Aktivera arbetsbelastningsidentitet på KEDA-operatorn

När du har skapat federerade autentiseringsuppgifter för keda-operator ServiceAccount måste du starta om keda-operator poddarna manuellt för att säkerställa att miljövariablerna för arbetsbelastningsidentitet matas in i podden.
```
kubectl rollout restart deploy keda-operator -n kube-system
```

Bekräfta omstarten av keda-operatorpoddar

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

När du har bekräftat att keda-operatorpoddarna har slutfört rullande träff Ctrl+c för att bryta föregående bevakningskommando bekräftar du att miljövariablerna för arbetsbelastningsidentitet har matats in.
```
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
```

Du bör se utdata som liknar följande under Miljö.

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

Distribuera en KEDA TriggerAuthentication-resurs som innehåller den användartilldelade hanterade identitetens klient-ID.
```
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
```
Kommentar

Med TriggerAuthentication på plats kan KEDA autentisera via arbetsbelastningsidentitet. Poddarna keda-operator använder för att autentisera identityId mot Azure-resurser vid utvärdering av skalningsutlösare.

Publicera meddelanden till Azure Service Bus

Nu är allt konfigurerat för skalning med KEDA och Microsoft Entra Workload Identity. Vi testar detta genom att distribuera producent- och konsumentarbetsbelastningar.

Skapa ett nytt ServiceAccount för arbetsbelastningarna.

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

Distribuera ett jobb för att publicera 100 meddelanden.

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

Använda meddelanden från Azure Service Bus

Nu när vi har publicerat meddelanden till Azure Service Bus-kön distribuerar vi ett ScaledJob för att använda meddelandena. Det här ScaledJob använder KEDA TriggerAuthentication-resursen för att autentisera mot Azure Service Bus-kön med hjälp av arbetsbelastningsidentiteten och skala ut var tionde meddelande.

Distribuera en ScaledJob-resurs för att använda meddelandena. Skalningsutlösaren konfigureras för att skala ut var tionde meddelande. KEDA-skalningsaren skapar 10 jobb för att använda de 100 meddelandena.

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

Kommentar

ScaledJob skapar en Kubernetes-jobbresurs när en skalningshändelse inträffar och därför måste en jobbmall skickas när resursen skapas. När nya jobb skapas distribueras poddar med arbetsbelastningsidentitetsbitar för att använda meddelanden.

Kontrollera att KEDA-skalningen fungerade som avsett.
```
kubectl describe scaledjob myconsumer-scaledjob
```

Du bör se händelser som liknar följande.

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

Rensa resurser

När du har kontrollerat att distributionen har slutförts kan du rensa resurserna för att undvika kostnader för Azure.

Ta bort Azure-resursgruppen och alla resurser i den med kommandot [az group delete][az-group-delete].
```
az group delete --name $RG_NAME --yes --no-wait
```

Nästa steg

Den här artikeln visar hur du på ett säkert sätt skalar dina program med hjälp av KEDA-tillägget och arbetsbelastningsidentiteten i AKS.

Information om KEDA-felsökning finns i Felsöka tillägget Kubernetes Händelsedriven autoskalning (KEDA).

Mer information om KEDA finns i de överordnade KEDA-dokumenten.

Dela via