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

Artigo
10/18/2023

O KEDA é um Autoscaler controlado por eventos baseado em Kubernetes. O KEDA permite que você conduza o dimensionamento de qualquer contêiner no Kubernetes com base na carga a ser processada, consultando métricas de sistemas como o Prometheus. Integre o KEDA com seu cluster do Serviço Kubernetes do Azure (AKS) para dimensionar suas cargas de trabalho com base nas métricas do Prometheus do seu espaço de trabalho do Azure Monitor.

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

Este artigo orienta você pelas etapas para integrar o KEDA ao seu cluster AKS usando uma identidade de carga de trabalho.

Nota

Recomendamos o uso do Microsoft Entra Workload ID. Esse método de autenticação substitui a identidade gerenciada por pod (visualização), que se integra aos recursos nativos do Kubernetes para federar com quaisquer provedores de identidade externos em nome do aplicativo.

A identidade gerenciada por pod do Microsoft Entra de código aberto (visualização) no Serviço Kubernetes do Azure foi preterida a partir de 24/10/2022, e o projeto será arquivado em setembro de 2023. Para obter mais informações, consulte o aviso de descontinuação. O complemento AKS Managed começa a ser descontinuado em setembro de 2023.

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

Pré-requisitos

Cluster do Azure Kubernetes Service (AKS)
Prometheus enviando métricas para um espaço de trabalho do Azure Monitor. Para obter mais informações, consulte 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 se adequarem ao seu cluster 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 - KEDA deve usar a conta de serviço que foi usada para criar credenciais federadas. Pode ser qualquer nome definido pelo usuário.
- AKS_CLUSTER_NAME- O nome do cluster AKS onde você deseja implantar o KEDA.
- SERVICE_ACCOUNT_NAMESPACE O KEDA e a conta de serviço devem estar no mesmo namespace.
- USER_ASSIGNED_IDENTITY_NAME é o nome da identidade Microsoft Entra criada para o KEDA.
- FEDERATED_IDENTITY_CREDENTIAL_NAME é o nome da credencial criada para o KEDA usar para autenticar com o Azure.
Se o cluster AKS não tiver sido criado com a identidade da carga de trabalho ou o emissor oidc habilitado, você precisará habilitá-lo. Se não tiver a certeza, pode executar o seguinte comando para verificar se está ativado.
```
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 seguinte comando.
```
az aks update -g $RESOURCE_GROUP -n $AKS_CLUSTER_NAME --enable-workload-identity --enable-oidc-issuer
```

Armazene a url do emissor OIDC em uma variável de ambiente para 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 ao 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

O resultado será semelhante ao seguinte:

{
  "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"
}

Armazene as variáveis de clientId ambiente e tenantId em para usar mais tarde.

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 seu espaço de trabalho do Azure Monitor. Essa função permite que a identidade leia métricas do seu espaço de trabalho. Substitua o grupo de recursos Espaço de Trabalho do Azure Monitor e o nome do Espaço de Trabalho do Azure Monitor pelo grupo de recursos e nome do espaço de trabalho do Azure Monitor, que está configurado para coletar métricas do cluster 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, em seguida, crie uma conta de serviço do Kubernetes. Esta conta de serviço é usada pela KEDA para autenticar com o 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 a 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 ao usuário. A credencial federada permite que a conta de serviço use a identidade atribuída ao usuário para autenticar com o 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

A propagação da credencial de identidade federada demora alguns segundos depois de ter sido 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, pois o cache é preenchido no diretório com dados antigos. Para evitar esse problema, você pode adicionar um pequeno atraso após adicionar a credencial de identidade federada.

Implantar o KEDA

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

Adicionar repositório de leme:

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 seguinte comando.

kubectl get pods -n keda

O resultado 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

Escaladores

Os escaladores definem como e quando o KEDA deve dimensionar uma implantação. KEDA suporta uma variedade de escaladores. Para obter mais informações sobre escaladores, consulte Escaladores. O Azure Managed Prometheus utiliza o escalonador Prometheus já existente para recuperar métricas do Prometheus do Azure Monitor Workspace. O seguinte arquivo yaml é um exemplo para usar o Azure Managed Prometheus.

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 seu espaço de trabalho do Azure Monitor. Para obter mais informações, consulte 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 de acordo com o podIdentity.provider tipo de identidade que você está usando.

Resolução de Problemas

A seção a seguir fornece dicas de solução de problemas para 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: 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"}

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

Permissões do espaço de trabalho do Azure Monitor

Se você estiver tendo problemas com a autenticação KEDA com o Azure, verifique as permissões para o espaço de trabalho do Azure Monitor. O trecho de log a seguir mostra que a identidade não tem permissões de leitura para o espaço de trabalho 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/abcdef01-2345-6789-0abc-def012345678/resourcegroups/rg-azmon-ws-01/providers/microsoft.monitor/accounts/azmon-ws-01\\u0027. RequestId: 123456c427f348258f3e5aeeefef834a\"}"}

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

Share via