Integrar o KEDA ao cluster de Serviço de Kubernetes do Azure

2025-05-01

O KEDA é um dimensionador automático baseado em eventos baseado em Kubernetes. O KEDA permite que você conduza o dimensionamento de contêineres no Kubernetes com base na carga a ser processada, consultando métricas de sistemas como o Prometheus. Integre o KEDA ao AKS (Serviço de Kubernetes do Azure) ou ao cluster do Kubernetes habilitado pelo Azure Arc para dimensionar suas cargas de trabalho a partir das métricas do Prometheus no workspace do Azure Monitor.

Para integrar o KEDA ao seu Serviço de Kubernetes do Azure, você precisa implantar e configurar uma identidade de carga de trabalho ou uma identidade de pod em seu cluster. A identidade permite que o KEDA se autentique com o Azure e recupere métricas para dimensionamento por meio do workspace do Monitor.

Este artigo explica as etapas para integrar o KEDA ao cluster kubernetes habilitado para AKS ou Azure Arc usando uma identidade de carga de trabalho.

Observação

É recomendável usar a ID de carga de trabalho do Microsoft Entra. Esse método de autenticação substitui a identidade gerenciada por pod (versão prévia), que se integra aos recursos nativos do Kubernetes para federar com os provedores de identidade externos em nome do aplicativo.

A identidade gerenciada por pod do Microsoft Entra de código aberto (versão prévia) no Serviço de Kubernetes do Azure foi preterida em 24/10/2022, e o projeto será arquivado em setembro de 2023. Para obter mais informações, confira o aviso de preterimento. O complemento Gerenciado do AKS começa a ser preterido em setembro de 2023.

O suporte ao Prometheus Gerenciado do Azure começa na KEDA v2.10. Se você tiver uma versão mais antiga do KEDA instalada, deverá atualizar para trabalhar com o Prometheus Gerenciado do Azure.

Pré-requisitos

Serviço de Kubernetes do Azure (AKS) ou cluster kubernetes habilitado para Azure Arc
Prometheus enviando métricas para um workspace do Azure Monitor. Para obter mais informações, consulte o serviço gerenciado do Azure Monitor para Prometheus.

Configurar uma identidade de carga de trabalho

Comece configurando algumas variáveis de ambiente. Altere os valores para atender ao cluster.
```
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 – O KEDA deve adotar a conta de serviço que foi usada para criar credenciais federadas. Isso pode ser qualquer nome definido pelo usuário.
- AKS_CLUSTER_NAME – o nome do cluster do AKS em que você deseja implantar o KEDA.
- SERVICE_ACCOUNT_NAMESPACE Tanto o KEDA quanto a conta de serviço devem estar no mesmo namespace.
- USER_ASSIGNED_IDENTITY_NAME é o nome da identidade do Microsoft Entra criada para o KEDA.
- FEDERATED_IDENTITY_CREDENTIAL_NAME é o nome da credencial criada para o KEDA usar para se autenticar no Azure.

Se o cluster do AKS não foi criado com workload-identity ou oidc-issuer habilitado, você precisará habilitar. Se você não tiver certeza, poderá executar o comando a seguir para verificar se ele está habilitado.

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

Para habilitar a identidade da carga de trabalho e o oidc-issuer, execute o comando a seguir.

az aks update -g $RESOURCE_GROUP -n $AKS_CLUSTER_NAME --enable-workload-identity --enable-oidc-issuer

Armazene a URL do emissor do OIDC em uma variável de ambiente que será usada posteriormente.

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

Crie uma identidade atribuída pelo usuário para o KEDA. Essa identidade é usada pelo KEDA para autenticar com o Azure Monitor.

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

A saída será semelhante ao seguinte:

{
  "clientId": "00001111-aaaa-2222-bbbb-3333cccc4444",
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/rg-keda-integration/providers/Microsoft.    ManagedIdentity/userAssignedIdentities/keda-int-identity",
  "location": "eastus",
  "name": "keda-int-identity",
  "principalId": "aaaaaaaa-bbbb-cccc-1111-222222222222",
  "resourceGroup": "rg-keda-integration",
  "systemData": null,
  "tags": {},
  "tenantId": "aaaabbbb-0000-cccc-1111-dddd2222eeee",
  "type": "Microsoft.ManagedIdentity/userAssignedIdentities"
}

Armazene a clientId e a tenantId em variáveis de ambiente que serão usadas posteriormente.

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)"

Atribua a função Leitor de Dados de Monitoramento à identidade do workspace do Azure Monitor. Essa função permite que a identidade leia as métricas do workspace. Substitua o grupo de recursos do Workspace do Azure Monitor e o nome do Workspace do Azure Monitor pelo grupo de recursos e pelo nome do workspace do Azure Monitor configurado para coletar métricas do cluster do AKS.
```
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>
```

Crie o namespace KEDA e depois crie a conta de serviço do Kubernetes. Essa conta de serviço é usada pelo KEDA para se autenticar no 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

Verifique sua conta de serviço executando

kubectl describe serviceaccount $SERVICE_ACCOUNT_NAME -n keda

Estabeleça uma credencial federada entre a conta de serviço e a identidade atribuída pelo usuário. A credencial federada permite que a conta de serviço use a identidade atribuída pelo usuário para se autenticar no 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
```
Observação

Leva alguns segundos para que a credencial de identidade federada seja propagada após ser inicialmente adicionada. Se uma solicitação de token for feita imediatamente após a adição da credencial de identidade federada, isso poderá levar a uma falha por alguns minutos enquanto o cache for preenchido no diretório com os dados antigos. Para evitar esse problema, você pode adicionar um pequeno atraso depois de adicionar a credencial de identidade federada.

Implantar o KEDA

O KEDA pode ser implantado usando manifestos YAML, gráficos Helm ou o Operator Hub. Este artigo usa gráficos Helm. Para obter mais informações sobre como implantar o KEDA, consulte Implantando o KEDA

Adicione o repositório Helm:

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

Implante o KEDA usando o seguinte comando:

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

Verifique sua implantação executando o comando a seguir.

kubectl get pods -n keda

A saída será semelhante ao seguinte:

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

Dimensionadores

Os dimensionadores definem como e quando o KEDA deve dimensionar uma implantação. O KEDA dá suporte a uma variedade de dimensionadores. Para obter mais informações sobre dimensionadores, consulte Scalers. O Prometheus gerenciado pelo Azure utiliza o dimensionador Prometheus que já existe para recuperar as métricas do Prometheus a partir do Workspace do Azure Monitor. O arquivo yaml a seguir é um exemplo para usar o Prometheus gerenciado pelo 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 é o ponto de extremidade de consulta do workspace do Azure Monitor. Para obter mais informações, consulte Consulta de métricas do Prometheus usando a API e PromQL
metricName é o nome da métrica na qual você deseja dimensionar.
query é a consulta usada para recuperar a métrica.
threshold é o valor no qual a implantação é dimensionada.
Defina o podIdentity.provider de acordo com o tipo de identidade que você está usando.

Solução de problemas

A seção a seguir fornece dicas de solução de problemas comuns.

Credenciais federadas

As credenciais federadas podem levar até 10 minutos para serem propagadas. Se você estiver tendo problemas com a autenticação KEDA com o Azure, tente as etapas a seguir.

O trecho de log a seguir mostra um erro com as credenciais federadas.

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: 0000aaaa-11bb-cccc-dd22-eeeeee333333\\r\\nCorrelation ID: 1111bbbb-22cc-dddd-ee33-ffffff444444\\r\\nTimestamp: 2023-05-30 11:11:53Z\",
\"error_codes\": [\n    70021\n  ],\n  \"timestamp\": \"2023-05-30 11:11:53Z\",
\"trace_id\": \"2222cccc-33dd-eeee-ff44-aaaaaa555555\",
\"correlation_id\": \"aaaa0000-bb11-2222-33cc-444444dddddd\",
\"error_uri\": \"https://login.microsoftonline.com/error?code=70021\"\n}
\n--------------------------------------------------------------------------------\n"}

Verifique os valores usados para criar a ServiceAccount e as credenciais criadas com az identity federated-credential create e verifique se o valor subject corresponde ao valor system:serviceaccount.

Permissões do workspace do Azure Monitor

Se você estiver enfrentando problemas com a autenticação do KEDA no Azure, verifique as permissões do workspace do Azure Monitor. O trecho de log a seguir mostra que a identidade não tem permissões de leitura no workspace do Azure Monitor.

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/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/rg-azmon-ws-01/providers/microsoft.monitor/accounts/azmon-ws-01\\u0027. RequestId: 123456c427f348258f3e5aeeefef834a\"}"}

Verifique se a identidade tem a função Monitoring Data Reader no workspace do Azure Monitor.