Integrare KEDA con il cluster servizio Azure Kubernetes

Articolo
10/18/2023

KEDA è un'utilità di scalabilità automatica basata su eventi basata su Kubernetes. KEDA consente di gestire il ridimensionamento di qualsiasi contenitore in Kubernetes in base al carico da elaborare, eseguendo query sulle metriche da sistemi come Prometheus. Integrare KEDA con il cluster servizio Azure Kubernetes (AKS) per ridimensionare i carichi di lavoro in base alle metriche prometheus dell'area di lavoro di Monitoraggio di Azure.

Per integrare KEDA nella servizio Azure Kubernetes, è necessario distribuire e configurare un'identità del carico di lavoro o un'identità pod nel cluster. L'identità consente a KEDA di eseguire l'autenticazione con Azure e recuperare le metriche per il ridimensionamento dall'area di lavoro Monitoraggio.

Questo articolo illustra i passaggi per integrare KEDA nel cluster del servizio Azure Kubernetes usando un'identità del carico di lavoro.

Nota

È consigliabile usare ID dei carichi di lavoro di Microsoft Entra. Questo metodo di autenticazione sostituisce l'identità gestita da pod (anteprima), che si integra con le funzionalità native di Kubernetes per la federazione con qualsiasi provider di identità esterno per conto dell'applicazione.

L'identità gestita da pod Microsoft Entra (anteprima) open source in servizio Azure Kubernetes è stata deprecata a partire dal 24/10/2022 e il progetto verrà archiviato a settembre 2023. Per altre informazioni, vedere l'avviso di deprecazione. Il componente aggiuntivo gestito del servizio Azure Kubernetes inizia la deprecazione a settembre 2023.

Il supporto di Prometheus gestito di Azure inizia da KEDA v2.10. Se è installata una versione precedente di KEDA, è necessario eseguire l'aggiornamento per usare Azure Managed Prometheus.

Prerequisiti

Cluster del servizio Azure Kubernetes
Prometheus invia metriche a un'area di lavoro di Monitoraggio di Azure. Per altre informazioni, vedere Servizio gestito di Monitoraggio di Azure per Prometheus.

Configurare un'identità del carico di lavoro

Per iniziare, configurare alcune variabili di ambiente. Modificare i valori in base al cluster del servizio Azure Kubernetes.
```
export RESOURCE_GROUP="rg-keda-integration"
export LOCATION="eastus"
export SUBSCRIPTION="$(az account show --query id --output tsv)"
export USER_ASSIGNED_IDENTITY_NAME="keda-int-identity"
export FEDERATED_IDENTITY_CREDENTIAL_NAME="kedaFedIdentity" 
export SERVICE_ACCOUNT_NAMESPACE="keda"
export SERVICE_ACCOUNT_NAME="keda-operator"
export AKS_CLUSTER_NAME="aks-cluster-name"
```
- SERVICE_ACCOUNT_NAME - KEDA deve usare l'account del servizio usato per creare credenziali federate. Può trattarsi di qualsiasi nome definito dall'utente.
- AKS_CLUSTER_NAME- Nome del cluster del servizio Azure Kubernetes in cui si vuole distribuire KEDA.
- SERVICE_ACCOUNT_NAMESPACE Sia KEDA che l'account del servizio devono trovarsi nello stesso spazio dei nomi.
- USER_ASSIGNED_IDENTITY_NAME è il nome dell'identità Microsoft Entra creata per KEDA.
- FEDERATED_IDENTITY_CREDENTIAL_NAME è il nome delle credenziali create per KEDA da usare per l'autenticazione con Azure.
Se il cluster del servizio Azure Kubernetes non è stato creato con l'identità del carico di lavoro o oidc-issuer abilitato, sarà necessario abilitarlo. Se non si è certi, è possibile eseguire il comando seguente per verificare se è abilitato.
```
az aks show --resource-group $RESOURCE_GROUP --name $AKS_CLUSTER_NAME --query oidcIssuerProfile
az aks show --resource-group $RESOURCE_GROUP --name $AKS_CLUSTER_NAME --query securityProfile.workloadIdentity
```
Per abilitare l'identità del carico di lavoro e oidc-issuer, eseguire il comando seguente.
```
az aks update -g $RESOURCE_GROUP -n $AKS_CLUSTER_NAME --enable-workload-identity --enable-oidc-issuer
```

Archiviare l'URL dell'autorità di certificazione OIDC in una variabile di ambiente da usare in un secondo momento.

export AKS_OIDC_ISSUER="$(az aks show -n $AKS_CLUSTER_NAME -g $RESOURCE_GROUP --query "oidcIssuerProfile.issuerUrl" -otsv)"

Creare un'identità assegnata dall'utente per KEDA. Questa identità viene usata da KEDA per l'autenticazione con Monitoraggio di Azure.

 az identity create --name $USER_ASSIGNED_IDENTITY_NAME --resource-group $RESOURCE_GROUP --location $LOCATION --subscription $SUBSCRIPTION

L'output sarà simile al seguente:

{
  "clientId": "abcd1234-abcd-abcd-abcd-9876543210ab",
  "id": "/subscriptions/abcdef01-2345-6789-0abc-def012345678/resourcegroups/rg-keda-integration/providers/Microsoft.    ManagedIdentity/userAssignedIdentities/keda-int-identity",
  "location": "eastus",
  "name": "keda-int-identity",
  "principalId": "12345678-abcd-abcd-abcd-1234567890ab",
  "resourceGroup": "rg-keda-integration",
  "systemData": null,
  "tags": {},
  "tenantId": "1234abcd-9876-9876-9876-abcdef012345",
  "type": "Microsoft.ManagedIdentity/userAssignedIdentities"
}

Archiviare e clientIdtenantId nelle variabili di ambiente da usare in un secondo momento.

export USER_ASSIGNED_CLIENT_ID="$(az identity show --resource-group $RESOURCE_GROUP --name $USER_ASSIGNED_IDENTITY_NAME --query 'clientId' -otsv)"
export TENANT_ID="$(az identity show --resource-group $RESOURCE_GROUP --name $USER_ASSIGNED_IDENTITY_NAME --query 'tenantId' -otsv)"

Assegnare il ruolo Lettore dati di monitoraggio all'identità per l'area di lavoro di Monitoraggio di Azure. Questo ruolo consente all'identità di leggere le metriche dall'area di lavoro. Sostituire il gruppo di risorse area di lavoro di Monitoraggio di Azure e il nome dell'area di lavoro monitoraggio di Azure con il gruppo di risorse e il nome dell'area di lavoro di Monitoraggio di Azure configurato per raccogliere le metriche dal cluster del servizio Azure Kubernetes.
```
az role assignment create \
--assignee $USER_ASSIGNED_CLIENT_ID \
--role "Monitoring Data Reader" \
--scope /subscriptions/$SUBSCRIPTION/resourceGroups/<Azure Monitor Workspace resource group>/providers/microsoft.monitor/accounts/<Azure monitor workspace name>
```

Creare lo spazio dei nomi KEDA, quindi creare l'account del servizio Kubernetes. Questo account del servizio viene usato da KEDA per l'autenticazione con Azure.


az aks get-credentials -n $AKS_CLUSTER_NAME -g $RESOURCE_GROUP

kubectl create namespace keda

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: ServiceAccount
metadata:
  annotations:
    azure.workload.identity/client-id: $USER_ASSIGNED_CLIENT_ID
  name: $SERVICE_ACCOUNT_NAME
  namespace: $SERVICE_ACCOUNT_NAMESPACE
EOF

Controllare l'account del servizio eseguendo

kubectl describe serviceaccount $SERVICE_ACCOUNT_NAME -n keda

Stabilire una credenziale federata tra l'account del servizio e l'identità assegnata dall'utente. Le credenziali federate consentono all'account del servizio di usare l'identità assegnata dall'utente per l'autenticazione con Azure.
```
az identity federated-credential create --name $FEDERATED_IDENTITY_CREDENTIAL_NAME --identity-name $USER_ASSIGNED_IDENTITY_NAME --resource-group $RESOURCE_GROUP --issuer $AKS_OIDC_ISSUER --subject     system:serviceaccount:$SERVICE_ACCOUNT_NAMESPACE:$SERVICE_ACCOUNT_NAME --audience api://AzureADTokenExchange
```
Nota

La propagazione delle credenziali di identità federata dopo l'aggiunta iniziale richiede alcuni secondi. Se una richiesta di token viene effettuata immediatamente dopo l'aggiunta della credenziale dell'identità federata, potrebbe verificarsi un errore per un paio di minuti perché la cache viene popolata nella directory con i dati precedenti. Per evitare questo problema, è possibile aggiungere un lieve ritardo dopo l'aggiunta delle credenziali di identità federate.

Distribuire KEDA

KEDA può essere distribuito usando manifesti YAML, grafici Helm o Hub operatore. Questo articolo usa grafici Helm. Per altre informazioni sulla distribuzione di KEDA, vedere Distribuzione di KEDA

Aggiungere il repository Helm:

helm repo add kedacore https://kedacore.github.io/charts
helm repo update

Distribuire KEDA usando il comando seguente:

helm install keda kedacore/keda --namespace keda \
--set serviceAccount.create=false \
--set serviceAccount.name=keda-operator \
--set podIdentity.azureWorkload.enabled=true \
--set podIdentity.azureWorkload.clientId=$USER_ASSIGNED_CLIENT_ID \
--set podIdentity.azureWorkload.tenantId=$TENANT_ID

Controllare la distribuzione eseguendo il comando seguente.

kubectl get pods -n keda

L'output sarà simile al seguente:

NAME                                               READY   STATUS    RESTARTS       AGE
keda-admission-webhooks-ffcb8f688-kqlxp            1/1     Running   0              4m
keda-operator-5d9f7d975-mgv7r                      1/1     Running   1 (4m ago)     4m
keda-operator-metrics-apiserver-7dc6f59678-745nz   1/1     Running   0              4m

Scaler

I scaler definiscono come e quando KEDA deve ridimensionare una distribuzione. KEDA supporta un'ampia gamma di scaler. Per altre informazioni sui scaler, vedere Scaler. Prometheus gestito di Azure usa un scaler Prometheus già esistente per recuperare le metriche di Prometheus dall'area di lavoro di Monitoraggio di Azure. Il file yaml seguente è un esempio di uso di Prometheus gestito di Azure.

apiVersion: keda.sh/v1alpha1
kind: TriggerAuthentication
metadata:
  name: azure-managed-prometheus-trigger-auth
spec:
  podIdentity:
      provider: azure-workload | azure # use "azure" for pod identity and "azure-workload" for workload identity
      identityId: <identity-id> # Optional. Default: Identity linked with the label set when installing KEDA.
---
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: azure-managed-prometheus-scaler
spec:
  scaleTargetRef:
    name: deployment-name-to-be-scaled
  minReplicaCount: 1
  maxReplicaCount: 20
  triggers:
  - type: prometheus
    metadata:
      serverAddress: https://test-azure-monitor-workspace-name-1234.eastus.prometheus.monitor.azure.com
      metricName: http_requests_total
      query: sum(rate(http_requests_total{deployment="my-deployment"}[2m])) # Note: query must return a vector/scalar single element response
      threshold: '100.50'
      activationThreshold: '5.5'
    authenticationRef:
      name: azure-managed-prometheus-trigger-auth

serverAddress è l'endpoint query dell'area di lavoro di Monitoraggio di Azure. Per altre informazioni, vedere Eseguire query sulle metriche di Prometheus usando l'API e PromQL
metricName è il nome della metrica su cui si vuole eseguire la scalabilità.
query è la query usata per recuperare la metrica.
threshold è il valore in base al quale la distribuzione viene ridimensionata.
Impostare in podIdentity.provider base al tipo di identità in uso.

Risoluzione dei problemi

Nella sezione seguente vengono forniti suggerimenti per la risoluzione dei problemi comuni.

Credenziali federate

La propagazione delle credenziali federate può richiedere fino a 10 minuti. Se si verificano problemi con l'autenticazione KEDA con Azure, provare la procedura seguente.

L'estratto del log seguente mostra un errore con le credenziali federate.

kubectl logs -n keda keda-operator-5d9f7d975-mgv7r

{
 \"error\": \"unauthorized_client\",\n  \"error_description\": \"AADSTS70021: No matching federated identity record found for presented assertion. 
Assertion Issuer: 'https://eastus.oic.prod-aks.azure.com/abcdef01-2345-6789-0abc-def012345678/12345678-abcd-abcd-abcd-1234567890ab/'.
Assertion Subject: 'system:serviceaccount:keda:keda-operator'. 
Assertion Audience: 'api://AzureADTokenExchange'. https://docs.microsoft.com/azure/active-directory/develop/workload-identity-federation
Trace ID: 12dd9ea0-3a65-408f-a41f-5d0403a25100\\r\\nCorrelation ID: 8a2dce68-17f1-4f11-bed2-4bcf9577f2af\\r\\nTimestamp: 2023-05-30 11:11:53Z\",
\"error_codes\": [\n    70021\n  ],\n  \"timestamp\": \"2023-05-30 11:11:53Z\",
\"trace_id\": \"12345678-3a65-408f-a41f-5d0403a25100\",
\"correlation_id\": \"12345678-17f1-4f11-bed2-4bcf9577f2af\",
\"error_uri\": \"https://login.microsoftonline.com/error?code=70021\"\n}
\n--------------------------------------------------------------------------------\n"}

Controllare i valori usati per creare ServiceAccount e le credenziali create con az identity federated-credential create e assicurarsi che il subject valore corrisponda al system:serviceaccount valore.

Autorizzazioni dell'area di lavoro di Monitoraggio di Azure

Se si verificano problemi con l'autenticazione KEDA con Azure, controllare le autorizzazioni per l'area di lavoro di Monitoraggio di Azure. L'estratto del log seguente mostra che l'identità non dispone delle autorizzazioni di lettura per l'area di lavoro monitoraggio di Azure.

kubectl logs -n keda keda-operator-5d9f7d975-mgv7r

2023-05-30T11:15:45Z    ERROR   scale_handler   error getting metric for scaler 
{"scaledObject.Namespace": "default", "scaledObject.Name": "azure-managed-prometheus-scaler", "scaler": "prometheusScaler", 
"error": "prometheus query api returned error. status: 403 response: {\"status\":\"error\",
\"errorType\":\"Forbidden\",\"error\":\"User \\u0027abc123ab-1234-1234-abcd-abcdef123456
\\u0027 does not have access to perform any of the following actions 
\\u0027microsoft.monitor/accounts/data/metrics/read, microsoft.monitor/accounts/data/metrics/read
\\u0027 on resource \\u0027/subscriptions/abcdef01-2345-6789-0abc-def012345678/resourcegroups/rg-azmon-ws-01/providers/microsoft.monitor/accounts/azmon-ws-01\\u0027. RequestId: 123456c427f348258f3e5aeeefef834a\"}"}

Verificare che l'identità abbia il Monitoring Data Reader ruolo nell'area di lavoro monitoraggio di Azure.

Condividi tramite