Ridimensionare in modo sicuro le applicazioni usando il componente aggiuntivo KEDA e l'identità del carico di lavoro nel servizio Azure Kubernetes

Articolo
08/02/2024

Questo articolo illustra come ridimensionare in modo sicuro le applicazioni con il componente aggiuntivo KEDA (Kubernetes Event-driven Autoscaling) e l'identità del carico di lavoro nel servizio Azure Kubernetes.

Importante

La tua versione di Kubernetes del cluster determina quale versione KEDA verrà installata nel tuo cluster AKS. Per vedere quale versione di KEDA si riferisce a ognuna delle versioni di AKA, vedi la colonna dei componenti aggiuntivi gestiti da AKS della tabella delle versioni del componente Kubernetes.

Per le versioni di Kubernetes GA, AKS offre il supporto completo della relativa versione secondaria KEDA nella tabella. Le versioni in anteprima di Kubernetes e la patch KEDA più recente sono parzialmente coperte dal supporto clienti con il massimo impegno. Di conseguenza, queste funzionalità non sono destinate all'uso in produzione. Per altre informazioni, vedere gli articoli di supporto seguenti:

Operazioni preliminari

È necessaria una sottoscrizione di Azure. Se non hai una sottoscrizione Azure, crea un account gratuito.
È necessario che l'interfaccia della riga di comando di Azure sia installata.
Assicurarsi che le regole del firewall siano configurate per consentire l'accesso al server API Kubernetes. Per ulteriori informazioni, vedi Regole di rete e FQDN (nome di dominio completo) in uscita per i cluster del servizio Azure Kubernetes.

Creare un gruppo di risorse

Creare un gruppo di risorse usando il comando az group create. Assicurarsi di sostituire i segnaposto con i propri valori.
```
LOCATION=<azure-region>
RG_NAME=<resource-group-name>

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

Creare un cluster del servizio Azure Kubernetes

Creare un cluster del servizio Azure Kubernetes con il componente aggiuntivo KEDA, l'identità del carico di lavoro e l'autorità emittente OIDC abilitata usando il comando az aks create con i flag --enable-workload-identity, --enable-keda e --enable-oidc-issuer. Assicurarsi di sostituire il valore segnaposto con il proprio valore.
```
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 
```
Verificare che la distribuzione abbia esito positivo e assicurarsi che il cluster abbia KEDA, identità del carico di lavoro e autorità di certificazione OIDC abilitata usando il comando az aks show con il flag --query impostato su "[workloadAutoScalerProfile, securityProfile, oidcIssuerProfile]".
```
az aks show \
    --name $AKS_NAME \
    --resource-group $RG_NAME \
    --query "[workloadAutoScalerProfile, securityProfile, oidcIssuerProfile]"
```

Connettersi al cluster usando il comando az aks get-credentials.

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

Creare un bus di servizio di Azure

Creare uno spazio dei nomi del bus di servizio di Azure usando il comando az servicebus namespace create. Assicurarsi di sostituire il valore segnaposto con il proprio valore.

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

Creare una coda del bus di servizio di Azure usando il comando az servicebus queue create. Assicurarsi di sostituire il valore segnaposto con il proprio valore.
```
SB_QUEUE_NAME=<service-bus-queue-name>

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

Creare un'identità gestita

Creare un'identità gestita usando il comando az identity create. Assicurarsi di sostituire il valore segnaposto con il proprio valore.

MI_NAME=<managed-identity-name>

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

Ottenere l'URL dell'autorità emittente OIDC usando il comando az aks show con il flag --query impostato su oidcIssuerProfile.issuerUrl.

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

Creare una credenziale federata tra l'identità gestita e lo spazio dei nomi e l'account del servizio usati dal carico di lavoro usando il comando az identity federated-credential create. Assicurarsi di sostituire il valore segnaposto con il proprio valore.

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

Creare una seconda credenziale federata tra l'identità gestita e lo spazio dei nomi e l'account del servizio usati dall'operatore KEDA usando il comando az identity federated-credential create. Assicurarsi di sostituire il valore segnaposto con il proprio valore.

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

Creare assegnazioni di ruolo

Ottenere l'ID oggetto per l'identità gestita usando il comando az identity show con il flag --query impostato su "principalId".

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

Ottenere l'ID risorsa dello spazio dei nomi del bus di servizio usando il comando az servicebus namespace show con il flag --query impostato su "id".
```
SB_ID=$(az servicebus namespace show \
    --name $SB_NAME \
    --resource-group $RG_NAME \
    --query "id" \
    --output tsv)
```

Assegnare il ruolo Proprietario dati del bus di servizio di Azure all'identità gestita usando il comando 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

Abilitare l'identità del carico di lavoro nell'operatore KEDA

Dopo aver creato le credenziali federate per keda-operator ServiceAccount, sarà necessario riavviare manualmente i pod keda-operator per assicurarsi che le variabili di ambiente dell'identità del carico di lavoro vengano inserite nel pod.
```
kubectl rollout restart deploy keda-operator -n kube-system
```

Confermare il riavvio dei pod keda-operator

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

Dopo aver confermato che i pod keda-operator hanno terminato l'implementazione premere Ctrl+c per interrompere il comando di controllo precedente, quindi verificare che le variabili di ambiente dell'identità del carico di lavoro siano state inserite.
```
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
```

L'output dovrebbe essere simile al seguente in Ambiente.

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

Distribuire una risorsa TriggerAuthentication KEDA che include l'ID client dell'identità gestita assegnata dall'utente.
```
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
```
Nota

Quando TriggerAuthentication è disponibile, KEDA sarà in grado di eseguire l'autenticazione tramite l'identità del carico di lavoro. I pod keda-operator usano identityId per eseguire l'autenticazione con le risorse di Azure durante la valutazione dei trigger di ridimensionamento.

Pubblicare messaggi nel bus di servizio di Azure

A questo punto tutto è configurato per il ridimensionamento con KEDA e l'identità del carico di lavoro Microsoft Entra. Questa operazione verrà testata distribuendo carichi di lavoro producer e consumer.

Creare un nuovo ServiceAccount per i carichi di lavoro.

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

Distribuire un processo per pubblicare 100 messaggi.

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

Usare messaggi dal bus di servizio di Azure

Ora che sono stati pubblicati messaggi nella coda del bus di servizio di Azure, si distribuirà ScaledJob per usare i messaggi. Questo ScaledJob userà la risorsa TriggerAuthentication KEDA per eseguire l'autenticazione nella coda del bus di servizio di Azure usando l'identità del carico di lavoro e aumentando il numero di istanze ogni 10 messaggi.

Distribuire una risorsa ScaledJob per utilizzare i messaggi. Il trigger di scalabilità verrà configurato per aumentare il numero di istanze ogni 10 messaggi. L'utilità di scalabilità KEDA creerà 10 processi per utilizzare i 100 messaggi.

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

Nota

ScaledJob crea una risorsa processo Kubernetes ogni volta che si verifica un evento di ridimensionamento e pertanto è necessario passare un modello di processo durante la creazione della risorsa. Quando vengono creati nuovi processi, i pod verranno distribuiti con bit di identità del carico di lavoro per l'utilizzo dei messaggi.

Verificare che l'utilità di scalabilità KEDA funzioni come previsto.
```
kubectl describe scaledjob myconsumer-scaledjob
```

Verranno visualizzati eventi simili ai seguenti.

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

Pulire le risorse

Dopo aver verificato che la distribuzione sia avvenuta correttamente, è possibile pulire le risorse per evitare di incorrere nei costi di Azure.

Eliminare il gruppo di risorse di Azure e tutte le risorse in esso contenute usando il comando [az group delete][az-group-delete].
```
az group delete --name $RG_NAME --yes --no-wait
```

Passaggi successivi

Questo articolo ha illustrato come ridimensionare in modo sicuro le applicazioni usando il componente aggiuntivo KEDA e l'identità del carico di lavoro nel servizio Azure Kubernetes.

Per informazioni sulla risoluzione dei problemi di KEDA, vedi Risolvere i problemi relativi al componente aggiuntivo di scalabilità automatica basata su eventi Kubernetes (KEDA).

Per altre informazioni su KEDA, vedere la documentazione di KEDA upstream.

Condividi tramite