KEDA integreren met uw Azure Kubernetes Service-cluster

Artikel
10/15/2024

KEDA is een op Kubernetes gebaseerde gebeurtenisgestuurde automatische schaalaanpassing. Met KEDA kunt u het schalen van een container in Kubernetes drijven op basis van de belasting die moet worden verwerkt, door query's uit te voeren op metrische gegevens van systemen zoals Prometheus. Integreer KEDA met uw AKS-cluster (Azure Kubernetes Service) om uw workloads te schalen op basis van metrische gegevens van Prometheus vanuit uw Azure Monitor-werkruimte.

Als u KEDA wilt integreren in uw Azure Kubernetes Service, moet u een workloadidentiteit of pod-identiteit in uw cluster implementeren en configureren. Met de identiteit kan KEDA worden geverifieerd met Azure en metrische gegevens worden opgehaald voor schaalaanpassing vanuit uw Monitor-werkruimte.

In dit artikel worden de stappen beschreven voor het integreren van KEDA in uw AKS-cluster met behulp van een workloadidentiteit.

Notitie

We raden u aan Microsoft Entra Workload-ID te gebruiken. Deze verificatiemethode vervangt door pod beheerde identiteit (preview), die wordt geïntegreerd met de systeemeigen kubernetes-mogelijkheden om te federeren met externe id-providers namens de toepassing.

De open source door Microsoft Entra beheerde identiteit (preview) in Azure Kubernetes Service is vanaf 10-24-2022 afgeschaft en het project wordt in september 2023 gearchiveerd. Zie de afschaffingsmelding voor meer informatie. De door AKS beheerde invoegtoepassing wordt afgeschaft in september 2023.

Azure Managed Prometheus-ondersteuning begint vanaf KEDA v2.10. Als u een oudere versie van KEDA hebt geïnstalleerd, moet u een upgrade uitvoeren om te kunnen werken met Azure Managed Prometheus.

Vereisten

Azure Kubernetes Service-cluster (AKS)
Prometheus verzendt metrische gegevens naar een Azure Monitor-werkruimte. Zie de beheerde Azure Monitor-service voor Prometheus voor meer informatie.

Een workloadidentiteit instellen

Begin met het instellen van enkele omgevingsvariabelen. Wijzig de waarden in uw AKS-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 - KEDA moet het serviceaccount gebruiken dat is gebruikt om federatieve referenties te maken. Dit kan elke door de gebruiker gedefinieerde naam zijn.
- AKS_CLUSTER_NAME- De naam van het AKS-cluster waar u KEDA wilt implementeren.
- SERVICE_ACCOUNT_NAMESPACE Zowel KEDA als serviceaccount moeten zich in dezelfde naamruimte bevinden.
- USER_ASSIGNED_IDENTITY_NAME is de naam van de Microsoft Entra-identiteit die is gemaakt voor KEDA.
- FEDERATED_IDENTITY_CREDENTIAL_NAME is de naam van de referentie die is gemaakt voor KEDA voor verificatie bij Azure.

Als uw AKS-cluster niet is gemaakt met workloadidentiteit of oidc-issuer ingeschakeld, moet u dit inschakelen. Als u het niet zeker weet, kunt u de volgende opdracht uitvoeren om te controleren of deze is ingeschakeld.

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

Voer de volgende opdracht uit om workloadidentiteit en oidc-issuer in te schakelen.

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

Sla de URL van de OIDC-verlener op in een omgevingsvariabele die later moet worden gebruikt.

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

Maak een door de gebruiker toegewezen identiteit voor KEDA. Deze identiteit wordt door KEDA gebruikt voor verificatie met Azure Monitor.

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

De uitvoer lijkt op de volgende:

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

Sla de clientId en tenantId in omgevingsvariabelen op voor later gebruik.

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

Wijs de rol Bewakingsgegevenslezer toe aan de identiteit voor uw Azure Monitor-werkruimte. Met deze rol kan de identiteit metrische gegevens lezen uit uw werkruimte. Vervang de resourcegroep en de Azure Monitor-werkruimtenaam door de resourcegroep en de naam van de Azure Monitor-werkruimte die is geconfigureerd voor het verzamelen van metrische gegevens van het AKS-cluster.
```
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>
```

Maak de KEDA-naamruimte en maak vervolgens een Kubernetes-serviceaccount. Dit serviceaccount wordt door KEDA gebruikt voor verificatie met 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

Controleer uw serviceaccount door uit te voeren

kubectl describe serviceaccount $SERVICE_ACCOUNT_NAME -n keda

Stel een federatieve referentie in tussen het serviceaccount en de door de gebruiker toegewezen identiteit. Met de federatieve referentie kan het serviceaccount de door de gebruiker toegewezen identiteit gebruiken om te verifiëren bij 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
```
Notitie

Het duurt een aantal seconden voordat de federatieve identiteitsreferentie wordt doorgegeven nadat deze in eerste instantie is toegevoegd. Als er direct na het toevoegen van de federatieve identiteitsreferentie een tokenaanvraag wordt gedaan, kan dit enkele minuten tot een fout leiden omdat de cache wordt gevuld in de map met oude gegevens. U kunt dit probleem voorkomen door een kleine vertraging toe te voegen nadat u de federatieve identiteitsreferentie hebt toegevoegd.

KEDA implementeren

KEDA kan worden geïmplementeerd met behulp van YAML-manifesten, Helm-grafieken of Operator Hub. In dit artikel worden Helm-grafieken gebruikt. Zie Keda implementeren voor meer informatie over het implementeren van KEDA

Helm-opslagplaats toevoegen:

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

Implementeer KEDA met behulp van de volgende opdracht:

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

Controleer uw implementatie door de volgende opdracht uit te voeren.

kubectl get pods -n keda

De uitvoer lijkt op de volgende:

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

Schaalaanpassingen

Schaalders bepalen hoe en wanneer KEDA een implementatie moet schalen. KEDA ondersteunt diverse schaalders. Zie Scalers voor meer informatie over scalers. Azure Managed Prometheus maakt gebruik van al bestaande Prometheus-scaler om metrische Prometheus-gegevens op te halen uit de Azure Monitor-werkruimte. Het volgende yaml-bestand is een voorbeeld van het gebruik van 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 is het query-eindpunt van uw Azure Monitor-werkruimte. Zie Metrische gegevens van Prometheus opvragen met behulp van de API en PromQL voor meer informatie
metricName is de naam van de metrische waarde waarop u wilt schalen.
query is de query die wordt gebruikt om de metrische waarde op te halen.
threshold is de waarde waarmee de implementatie wordt geschaald.
Stel het podIdentity.provider in op basis van het type identiteit dat u gebruikt.

Probleemoplossing

De volgende sectie bevat tips voor het oplossen van veelvoorkomende problemen.

Federatieve referenties

Het kan 10 minuten duren voordat federatieve referenties zijn doorgegeven. Als u problemen ondervindt met het verifiëren van KEDA met Azure, voert u de volgende stappen uit.

In het volgende logboekfragment ziet u een fout met de federatieve referenties.

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

Controleer de waarden die worden gebruikt voor het maken van het ServiceAccount en de referenties die zijn gemaakt met az identity federated-credential create en zorg ervoor dat de subject waarde overeenkomt met de system:serviceaccount waarde.

Machtigingen voor Azure Monitor-werkruimte

Als u problemen ondervindt met KEDA-verificatie met Azure, controleert u de machtigingen voor de Azure Monitor-werkruimte. In het volgende logboekfragment ziet u dat de identiteit geen leesmachtigingen heeft voor de Azure Monitor-werkruimte.

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

Zorg ervoor dat de identiteit de Monitoring Data Reader rol heeft in de Azure Monitor-werkruimte.

Delen via