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

Artigo
11/05/2024

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 cluster de Serviço de Kubernetes do Azure (AKS) para dimensionar suas cargas de trabalho com base nas métricas do Prometheus por meio do 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 o orienta, passo a passo, para integrar o KEDA ao cluster do AKS 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

Cluster do AKS (Serviço de Kubernetes do Azure)
Prometheus enviando métricas para um workspace do Azure Monitor. Para obter mais informações, confira Serviço gerenciado do Azure Monitor para Prometheus.

Configurar uma identidade de carga de trabalho

Comece configurando algumas variáveis de ambiente. Mude para os valores adequados ao seu cluster do AKS.
```
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 de Leitor de dados de monitoramento à identidade de seu workspace do Azure Monitor. Essa função permite que a identidade leia as métricas do workspace. Substitua Grupo de recursos do workspace do Azure Monitor e Nome do workspace do Azure Monitor pelo grupo de recursos e pelo nome do workspace do Azure Monitor que está configurado para coletar as 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, confira Implantando 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, confira Dimensionadores. 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 mais informações, confira como Consultar métricas do Prometheus usando a API e o 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.

Compartilhar via