Integrowanie usługi KEDA z klastrem usługi Azure Kubernetes Service

Artykuł
10/18/2023

KEDA to oparty na platformie Kubernetes narzędzie do automatycznego skalowania opartego na zdarzeniach. Usługa KEDA umożliwia skalowanie dowolnego kontenera na platformie Kubernetes na podstawie obciążenia do przetworzenia, wykonując zapytania dotyczące metryk z systemów, takich jak Prometheus. Integrowanie usługi KEDA z klastrem usługi Azure Kubernetes Service (AKS) w celu skalowania obciążeń na podstawie metryk rozwiązania Prometheus z obszaru roboczego usługi Azure Monitor.

Aby zintegrować aplikację KEDA z usługą Azure Kubernetes Service, musisz wdrożyć i skonfigurować tożsamość obciążenia lub tożsamość zasobnika w klastrze. Tożsamość umożliwia usłudze KEDA uwierzytelnianie za pomocą platformy Azure i pobieranie metryk skalowania z obszaru roboczego Monitor.

W tym artykule przedstawiono procedurę integrowania usługi KEDA z klastrem usługi AKS przy użyciu tożsamości obciążenia.

Uwaga

Zalecamy używanie Tożsamość obciążeń Microsoft Entra. Ta metoda uwierzytelniania zastępuje tożsamość zarządzaną zasobnika (wersja zapoznawcza), która integruje się z natywnymi funkcjami platformy Kubernetes w celu federacji z dowolnymi zewnętrznymi dostawcami tożsamości w imieniu aplikacji.

Tożsamość zarządzana typu open source firmy Microsoft Entra (wersja zapoznawcza) w usłudze Azure Kubernetes Service została uznana za przestarzałą od 10.24.2022 r., a projekt zostanie zarchiwizowany we wrześniu 2023 r. Aby uzyskać więcej informacji, zobacz powiadomienie o wycofaniu. Dodatek zarządzany przez usługę AKS rozpoczyna wycofywanie we wrześniu 2023 r.

Obsługa rozwiązania Prometheus zarządzanego przez platformę Azure rozpoczyna się od wersji KEDA w wersji 2.10. Jeśli masz zainstalowaną starszą wersję usługi KEDA, musisz przeprowadzić uaktualnienie, aby pracować z usługą Azure Managed Prometheus.

Wymagania wstępne

Klaster usługi Azure Kubernetes Service (AKS)
Prometheus wysyła metryki do obszaru roboczego usługi Azure Monitor. Aby uzyskać więcej informacji, zobacz Usługa zarządzana usługi Azure Monitor dla rozwiązania Prometheus.

Konfigurowanie tożsamości obciążenia

Zacznij od skonfigurowania niektórych zmiennych środowiskowych. Zmień wartości, aby odpowiadały klastrowi usługi 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 musi użyć konta usługi, które zostało użyte do utworzenia poświadczeń federacyjnych. Może to być dowolna nazwa zdefiniowana przez użytkownika.
- AKS_CLUSTER_NAME— nazwa klastra AKS, w którym chcesz wdrożyć usługę KEDA.
- SERVICE_ACCOUNT_NAMESPACE Zarówno KEDA, jak i konto usługi muszą znajdować się w tej samej przestrzeni nazw.
- USER_ASSIGNED_IDENTITY_NAME to nazwa tożsamości firmy Microsoft Entra utworzonej dla usługi KEDA.
- FEDERATED_IDENTITY_CREDENTIAL_NAME to nazwa poświadczenia utworzonego dla usługi KEDA do uwierzytelniania za pomocą platformy Azure.
Jeśli klaster usługi AKS nie został utworzony z włączoną tożsamością obciążenia lub wystawcą oidc, musisz go włączyć. Jeśli nie masz pewności, możesz uruchomić następujące polecenie, aby sprawdzić, czy jest on włączony.
```
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
```
Aby włączyć tożsamość obciążenia i oidc-issuer, uruchom następujące polecenie.
```
az aks update -g $RESOURCE_GROUP -n $AKS_CLUSTER_NAME --enable-workload-identity --enable-oidc-issuer
```

Zapisz adres URL wystawcy OIDC w zmiennej środowiskowej, która będzie używana później.

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

Utwórz tożsamość przypisaną przez użytkownika dla usługi KEDA. Ta tożsamość jest używana przez usługę KEDA do uwierzytelniania w usłudze Azure Monitor.

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

Dane wyjściowe będą mieć postać podobną do następującej:

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

clientId Zapisz zmienne środowiskowe i tenantId w zmiennych środowiskowych, aby użyć ich później.

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

Przypisz rolę Czytelnik danych monitorowania do tożsamości dla obszaru roboczego usługi Azure Monitor. Ta rola umożliwia tożsamości odczytywanie metryk z obszaru roboczego. Zastąp grupę zasobów Obszaru roboczego usługi Azure Monitor i nazwę obszaru roboczego usługi Azure Monitor nazwą obszaru roboczego usługi Azure Monitor, który jest skonfigurowany do zbierania metryk z klastra usługi 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>
```

Utwórz przestrzeń nazw KEDA, a następnie utwórz konto usługi Kubernetes. To konto usługi jest używane przez usługę KEDA do uwierzytelniania za pomocą platformy 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

Sprawdź konto usługi, uruchamiając polecenie

kubectl describe serviceaccount $SERVICE_ACCOUNT_NAME -n keda

Ustanów poświadczenia federacyjne między kontem usługi a tożsamością przypisaną przez użytkownika. Poświadczenie federacyjne umożliwia kontu usługi używanie tożsamości przypisanej przez użytkownika do uwierzytelniania za pomocą platformy 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
```
Uwaga

Propagacja poświadczeń tożsamości federacyjnej po ich dodaniu trwa kilka sekund. Jeśli żądanie tokenu jest wykonywane natychmiast po dodaniu poświadczeń tożsamości federacyjnej, może to prowadzić do niepowodzenia przez kilka minut, ponieważ pamięć podręczna jest wypełniana w katalogu starymi danymi. Aby uniknąć tego problemu, możesz dodać niewielkie opóźnienie po dodaniu poświadczeń tożsamości federacyjnej.

Wdrażanie usługi KEDA

KEDA można wdrożyć przy użyciu manifestów YAML, wykresów helm lub centrum operatorów. W tym artykule są używane wykresy programu Helm. Aby uzyskać więcej informacji na temat wdrażania usługi KEDA, zobacz Wdrażanie usługi KEDA

Dodaj repozytorium helm:

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

Wdróż usługę KEDA przy użyciu następującego polecenia:

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

Sprawdź wdrożenie, uruchamiając następujące polecenie.

kubectl get pods -n keda

Dane wyjściowe będą mieć postać podobną do następującej:

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

Skalatory

Skalatory definiują sposób i czas skalowania wdrożenia przez usługę KEDA. Usługa KEDA obsługuje różne skalatory. Aby uzyskać więcej informacji na temat skalowania, zobacz Skalowanie. Usługa Azure Managed Prometheus wykorzystuje już istniejący program Prometheus scaler do pobierania metryk rozwiązania Prometheus z obszaru roboczego usługi Azure Monitor. Poniższy plik yaml jest przykładem użycia usługi 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 to punkt końcowy zapytania obszaru roboczego usługi Azure Monitor. Aby uzyskać więcej informacji, zobacz Query Prometheus metrics using the API and PromQL (Tworzenie zapytań metryk prometheus przy użyciu interfejsu API i rozwiązania PromQL)
metricName to nazwa metryki, na którą chcesz przeprowadzić skalowanie.
query to zapytanie używane do pobierania metryki.
threshold to wartość, przy której wdrożenie jest skalowane.
podIdentity.provider Ustaw wartość zgodnie z typem używanej tożsamości.

Rozwiązywanie problemów

Poniższa sekcja zawiera porady dotyczące rozwiązywania typowych problemów.

Poświadczenia federacyjne

Propagacja poświadczeń federacyjnych może potrwać do 10 minut. Jeśli masz problemy z uwierzytelnianiem za pomocą usługi KEDA na platformie Azure, spróbuj wykonać następujące czynności.

Poniższy fragment dziennika przedstawia błąd z poświadczeniami federacyjnymi.

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

Sprawdź wartości używane do utworzenia konta usługi i poświadczeń utworzonych za pomocą az identity federated-credential create polecenia i upewnij się, że subject wartość jest zgodna z wartością system:serviceaccount .

Uprawnienia obszaru roboczego usługi Azure Monitor

Jeśli masz problemy z uwierzytelnianiem za pomocą usługi KEDA na platformie Azure, sprawdź uprawnienia dla obszaru roboczego usługi Azure Monitor. Poniższy fragment dziennika pokazuje, że tożsamość nie ma uprawnień do odczytu dla obszaru roboczego usługi 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\"}"}

Upewnij się, że tożsamość ma Monitoring Data Reader rolę w obszarze roboczym usługi Azure Monitor.