Konfigurowanie tożsamości obciążenia w klastrze AKS Edge Essentials (wersja zapoznawcza)

Artykuł
11/16/2024

Azure Kubernetes Service (AKS) Edge Essentials to lokalna implementacja platformy Kubernetes usługi Azure Kubernetes Service (AKS), która automatyzuje uruchamianie konteneryzowanych aplikacji na dużą skalę. W tym artykule opisano sposób wykonywania następujących zadań:

Utwórz konto usługi Kubernetes i powiąż je z tożsamością zarządzaną platformy Azure.
Utwórz poświadczenie federacyjne w tożsamości zarządzanej, aby ufać wystawcy OIDC.
Wdróż aplikację.
Przykład: udzielanie zasobnikowi w klastrze dostępu do wpisów tajnych w magazynie kluczy platformy Azure.

Aby zapoznać się z koncepcyjnym omówieniem federacji tożsamości obciążenia, zobacz Federacja tożsamości obciążeń w usłudze Kubernetes z obsługą usługi Azure Arc (wersja zapoznawcza).

Ważne

Te funkcje w wersji zapoznawczej są dostępne na zasadzie samoobsługi. Wersje zapoznawcze są udostępniane w wersji "as is" i "jako dostępne" i są wykluczone z umów dotyczących poziomu usług i ograniczonej gwarancji. Wersje zapoznawcze usługi Azure Kubernetes Service Edge Essentials są częściowo objęte pomocą techniczną w oparciu o najlepsze nakłady pracy.

Uwaga

W tej publicznej wersji zapoznawczej usługa AKS Edge Essentials umożliwia włączenie tożsamości obciążenia podczas początkowego wdrażania skryptu Szybki start operacji usługi Azure IoT. Ta funkcja nie jest dostępna w innych scenariuszach usługi AKS Edge Essentials.

Wymagania wstępne

Przed rozpoczęciem korzystania z federacji tożsamości obciążenia dla klastra AKS Edge Essentials należy wdrożyć skrypt Szybki start operacji usługi Azure IoT zgodnie z opisem w temacie Tworzenie i konfigurowanie klastra AKS Edge Essentials, który może uruchamiać operacje usługi Azure IoT. Skrypt automatycznie włącza funkcję federacji tożsamości obciążenia w klastrze AKS Edge Essentials.

Po wdrożeniu klastra AKS Edge Essentials możesz użyć następującego polecenia, aby sprawdzić stan rozszerzenia tożsamości obciążenia:

az connectedk8s show -n $aks_cluster_name -g $resource_group_name

# agentState = "Succeeded" 
"agentPublicKeyCertificate": "", 
  "agentVersion": "1.21.10", 
  "arcAgentProfile": { 
    "agentAutoUpgrade": "Enabled", 
    "agentErrors": [], 
    "agentState": "Succeeded", 
    "desiredAgentVersion": "", 
    "systemComponents": null 

# oidcIssuerProfile "enabled": true and "issuerUrl" present 
"oidcIssuerProfile": { 
    "enabled": true, 
    "issuerUrl": "https://oidcdiscovery-{location}-endpoint-1111111111111111.000.azurefd.net/00000000-0000-0000-0000-000000000000/11111111-1111-1111-1111-111111111111/", 

# workloadIdentity "enabled": true 
"securityProfile": { 
    "workloadIdentity": { 
      "enabled": true

W witrynie Azure Portal możesz wyświetlić wiextension rozszerzenie w sekcji Właściwości klastra Kubernetes.

Eksportowanie zmiennych środowiskowych

Aby uprościć kroki konfigurowania wymaganych tożsamości, poniższe kroki definiują zmienne środowiskowe, do których odwołuje się w przykładach w tym artykule. Pamiętaj, aby zastąpić wartości wyświetlane własnymi wartościami:

$AZSubscriptionID = "00000000-0000-0000-0000-000000000000" 
$Location = "westeurope" 
$resource_group_name = "myResourceGroup" 

$aks_cluster_name = "myAKSCluster" 

$SERVICE_ACCOUNT_NAMESPACE = "default" 
$SERVICE_ACCOUNT_NAME = "workload-identity-sa" 

$FedIdCredentialName = "myFedIdentity" 
$MSIName = "myIdentity" 

# Include these variables to access key vault secrets from a pod in the cluster. 
$KVName = "KV-workload-id" 
$KVSecretName= "KV-secret"

Zapisywanie adresu URL wystawcy OIDC w zmiennej środowiskowej

Aby uzyskać adres URL wystawcy OIDC i zapisać go w zmiennej środowiskowej, uruchom następujące polecenie:

$SERVICE_ACCOUNT_ISSUER =$(az connectedk8s show --n $aks_cluster_name --resource-group $resource_group_name --query "oidcIssuerProfile.issuerUrl" --output tsv)

Krok 1. Tworzenie konta usługi Kubernetes i powiązanie go z tożsamością zarządzaną platformy Azure

Najpierw wywołaj polecenie az identity create , aby utworzyć tożsamość zarządzaną:

az identity create --name $MSIName --resource-group $resource_group_name --location $Location --subscription $AZSubscriptionID

Następnie utwórz zmienne dla identyfikatora klienta tożsamości zarządzanej:

$MSIId=$(az identity show --resource-group $resource_group_name --name $MSIName --query 'clientId' --output tsv)  
$MSIPrincipalId=$(az identity show --resource-group $resource_group_name --name $MSIName --query 'principalId' --output tsv)

Tworzenie konta usługi Kubernetes

Utwórz konto usługi Kubernetes i dodaj do niego adnotację przy użyciu identyfikatora klienta tożsamości zarządzanej utworzonej w poprzednim kroku. Skopiuj i wklej następujące polecenia interfejsu wiersza polecenia platformy Azure:

$yaml = @" 
apiVersion: v1 
kind: ServiceAccount 
metadata: 
  annotations: 
    azure.workload.identity/client-id: $MSIId 
  name: $SERVICE_ACCOUNT_NAME 
  namespace: $SERVICE_ACCOUNT_NAMESPACE 
"@ 

# Replace variables within the YAML content 
$yaml = $yaml -replace '\$MSIId', $MSIId ` 
              -replace '\$SERVICE_ACCOUNT_NAME', $SERVICE_ACCOUNT_NAME ` 
              -replace '\$SERVICE_ACCOUNT_NAMESPACE', $SERVICE_ACCOUNT_NAMESPACE 

# Apply the YAML content to Kubernetes 
$yaml | kubectl apply -f -

Następujące dane wyjściowe przedstawiają pomyślnie utworzoną tożsamość obciążenia:

serviceaccount/workload-identity-sa created

Krok 2. Tworzenie poświadczeń federacyjnych w tożsamości zarządzanej w celu zaufania wystawcy OIDC

Aby utworzyć poświadczenia tożsamości federacyjnej między tożsamością zarządzaną, wystawcą konta usługi i tematem, wywołaj polecenie az identity federated-credential create . Aby uzyskać więcej informacji na temat poświadczeń tożsamości federacyjnej w usłudze Microsoft Entra, zobacz Overview of federated identity credentials in Microsoft Entra ID (Omówienie poświadczeń tożsamości federacyjnej w usłudze Microsoft Entra ID).

# Create a federated credential 
az identity federated-credential create --name $FedIdCredentialName --identity-name $MSIName --resource-group $resource_group_name --issuer $SERVICE_ACCOUNT_ISSUER --subject "system:serviceaccount:${SERVICE_ACCOUNT_NAMESPACE}:${SERVICE_ACCOUNT_NAME}" 

# Show the federated credential 
az identity federated-credential show --name $FedIdCredentialName --resource-group $resource_group_name --identity-name $MSIName

Uwaga

Po dodaniu poświadczeń tożsamości federacyjnej propagacja trwa kilka sekund. Żądania tokenu wysyłane natychmiast potem mogą zakończyć się niepowodzeniem do czasu odświeżenia pamięci podręcznej. Aby zapobiec temu problemowi, rozważ dodanie krótkiego opóźnienia po utworzeniu poświadczeń tożsamości federacyjnej.

Krok 3. Wdrażanie aplikacji

Podczas wdrażania zasobników aplikacji manifest powinien odwoływać się do konta usługi utworzonego w kroku Tworzenie konta usługi Kubernetes Service. Poniższy manifest pokazuje, jak odwoływać się do konta, w szczególności metadata\namespace właściwości i spec\serviceAccountName . Upewnij się, że określono obraz dla image parametru i nazwę kontenera dla containerNameelementu :

$image = "<image>"  # Replace <image> with the actual image name 
$containerName = "<containerName>"  # Replace <containerName> with the actual container name 

$yaml = @" 
apiVersion: v1 
kind: Pod 
metadata: 
  name: sample-quick-start 
  namespace: $SERVICE_ACCOUNT_NAMESPACE 
  labels: 
    azure.workload.identity/use: "true" # Required. Only pods with this label can use workload identity. 
spec: 
  serviceAccountName: $SERVICE_ACCOUNT_NAME 
  containers: 
    - image: $image 
      name: $containerName 
"@ 

# Replace variables within the YAML content 
$yaml = $yaml -replace '\$SERVICE_ACCOUNT_NAMESPACE', $SERVICE_ACCOUNT_NAMESPACE ` 
                -replace '\$SERVICE_ACCOUNT_NAME', $SERVICE_ACCOUNT_NAME 

# Apply the YAML configuration 
$yaml | kubectl apply -f -

Ważne

Upewnij się, że zasobniki aplikacji korzystające z tożsamości obciążenia zawierają etykietę azure.workload.identity/use: "true" w specyfikacji zasobnika. W przeciwnym razie zasobniki kończą się niepowodzeniem po ponownym uruchomieniu.

Przykład: udzielanie uprawnień dostępu do usługi Azure Key Vault

Instrukcje w tym kroku opisują sposób uzyskiwania dostępu do wpisów tajnych, kluczy lub certyfikatów w magazynie kluczy platformy Azure z zasobnika. Przykłady w tej sekcji umożliwiają skonfigurowanie dostępu do wpisów tajnych w magazynie kluczy dla tożsamości obciążenia, ale możesz wykonać podobne kroki, aby skonfigurować dostęp do kluczy lub certyfikatów.

W poniższym przykładzie pokazano, jak używać modelu uprawnień kontroli dostępu na podstawie ról (RBAC) platformy Azure w celu udzielenia zasobnikowi dostępu do magazynu kluczy. Aby uzyskać więcej informacji na temat modelu uprawnień RBAC platformy Azure dla usługi Azure Key Vault, zobacz Udzielanie aplikacji uprawnień dostępu do magazynu kluczy platformy Azure przy użyciu kontroli dostępu opartej na rolach platformy Azure.

Utwórz magazyn kluczy z włączoną ochroną przeczyszczania i autoryzacją RBAC. Możesz również użyć istniejącego magazynu kluczy, jeśli jest skonfigurowany do ochrony przed przeczyszczeniem i autoryzacji RBAC:

az keyvault create --name $KVName --resource-group $resource_group_name --location $Location --enable-purge-protection --enable-rbac-authorization

# retrieve the key vault ID for role assignment
$KVId=$(az keyvault show --resource-group $resource_group_name --name $KVName --query id --output tsv)

Przypisz rolę RBAC Key Vault Secrets Officer do siebie, aby utworzyć wpis tajny w nowym magazynie kluczy. Propagowanie nowych przypisań ról przez serwer autoryzacji może potrwać do pięciu minut.
```
az role assignment create --assignee-object-id $MSIPrincipalId --role "Key Vault Secrets Officer" --scope $KVId --assignee-principal-type ServicePrincipal
```

Utwórz wpis tajny w magazynie kluczy:

az keyvault secret set --vault-name $KVName --name $KVSecretName --value "Hello!"

Przypisz rolę Użytkownika wpisów tajnych usługi Key Vault do utworzonej wcześniej tożsamości zarządzanej przypisanej przez użytkownika. Ten krok zapewnia uprawnienie tożsamości zarządzanej do odczytywania wpisów tajnych z magazynu kluczy:
```
az role assignment create --assignee-object-id $MSIPrincipalId --role "Key Vault Secrets User" --scope $KVId --assignee-principal-type ServicePrincipal
```

Utwórz zmienną środowiskową dla adresu URL magazynu kluczy:

$KVUrl=$(az keyvault show --resource-group $resource_group_name --name $KVName --query properties.vaultUri --output tsv)

Wdróż zasobnik, który odwołuje się do konta usługi i adresu URL magazynu kluczy:

$yaml = @" 
apiVersion: v1 
kind: Pod
metadata:
  name: sample-quick-start
  namespace: $SERVICE_ACCOUNT_NAMESPACE
  labels:
    azure.workload.identity/use: "true"
spec:
  serviceAccountName: $SERVICE_ACCOUNT_NAME 
  containers:
    - image: ghcr.io/azure/azure-workload-identity/msal-go 
      name: oidc 
      env: 
      - name: KEYVAULT_URL 
        value: $KVUrl 
      - name: SECRET_NAME 
        value: $KVSecretName 
  nodeSelector:
    kubernetes.io/os: linux
"@

# Replace variables within the YAML content 
$yaml = $yaml -replace '\$SERVICE_ACCOUNT_NAMESPACE', $SERVICE_ACCOUNT_NAMESPACE ` 
                -replace '\$SERVICE_ACCOUNT_NAME', $SERVICE_ACCOUNT_NAME ` 
                -replace '\$KVUrl', $KVUrl ` 
                -replace '\$KVSecretName', $KVSecretName 

# Apply the YAML configuration
$yaml | kubectl --kubeconfig $aks_cluster_name apply -f -

Następne kroki

W tym artykule skonfigurowano ją tak, aby korzystała z tożsamości obciążenia w ramach przygotowań dla obciążeń aplikacji do uwierzytelniania przy użyciu tego poświadczenia. Teraz możesz przystąpić do wdrażania aplikacji i konfigurować ją tak, aby korzystała z tożsamości obciążenia z najnowszą wersją biblioteki klienta usługi Azure Identity.

Udostępnij za pośrednictwem