Wdrażanie i konfigurowanie tożsamości obciążenia w usłudze AKS włączonej przez klaster usługi Azure Arc (wersja zapoznawcza)

Artykuł
11/23/2024

Dotyczy: Azure Local, wersja 23H2

Federacja tożsamości obciążenia umożliwia skonfigurowanie tożsamości zarządzanej przypisanej przez użytkownika lub rejestracji aplikacji w usłudze Microsoft Entra ID w celu zaufania tokenów od zewnętrznego dostawcy tożsamości (IdP), takiego jak Kubernetes, umożliwiając dostęp do zasobów chronionych przez firmę Microsoft Entra, takich jak Azure Key Vault lub Azure Blob Storage.

Usługa Azure Kubernetes Service (AKS) włączona przez usługę Azure Arc to zarządzana usługa Kubernetes, która umożliwia łatwe wdrażanie klastrów Kubernetes z obsługą tożsamości obciążenia. W tym artykule opisano sposób wykonywania następujących zadań:

Utwórz klaster usługi AKS Arc z włączoną tożsamością obciążenia (wersja zapoznawcza).
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.

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. Usługa Azure Kubernetes Service włączona przez wersje zapoznawcze usługi Azure Arc jest częściowo objęta pomocą techniczną w oparciu o najlepsze wysiłki.

Uwaga

W publicznej wersji zapoznawczej usługa AKS w usłudze Azure Stack HCI obsługuje włączanie tożsamości obciążenia podczas tworzenia klastra usługi AKS. Jednak włączenie tożsamości obciążenia po utworzeniu klastra lub jego wyłączeniu jest obecnie nieobsługiwane.

Wymagania wstępne

Przed wdrożeniem klastra Kubernetes z włączoną usługą Azure Arc należy spełnić następujące wymagania wstępne:

Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto platformy Azure.
Ten artykuł wymaga wersji 1.4.23 lub nowszej interfejsu wiersza polecenia platformy Azure. Jeśli używasz usługi Azure Cloud Shell, najnowsza wersja jest już zainstalowana.

Eksportowanie zmiennych środowiskowych

Aby uprościć kroki konfigurowania wymaganych tożsamości, następujące polecenia definiują zmienne środowiskowe, do których odwołuje się w przykładach w tym artykule. Zastąp następujące wartości 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" 

# To access key vault secrets from a pod in the cluster, include these variables:
$KVName = "KV-workload-id" 
$KVSecretName= "KV-secret"

Ustawianie aktywnej subskrypcji

Najpierw ustaw subskrypcję jako bieżącą aktywną subskrypcję. Uruchom polecenie az account set z identyfikatorem subskrypcji:

az login  
az account set -s $AZSubscriptionID

Tworzenie grupy zasobów

Grupa zasobów platformy Azure to grupa logiczna, w której zasoby platformy Azure są wdrażane i zarządzane. Podczas tworzenia grupy zasobów zostanie wyświetlony monit o określenie lokalizacji. Ta lokalizacja to lokalizacja magazynu metadanych grupy zasobów i lokalizacja, w której zasoby są uruchamiane na platformie Azure, jeśli nie określisz innego regionu podczas tworzenia zasobów.

Aby utworzyć grupę zasobów, uruchom polecenie az group create:

az group create --name $resource_group_name --location $Location

W poniższych przykładowych danych wyjściowych przedstawiono pomyślne utworzenie grupy zasobów:

{ 
  "id": "/subscriptions/<guid>/resourceGroups/myResourceGroup", 
  "location": "westeurope", 
  "managedBy": null, 
  "name": "$resource_group_name", 
  "properties": { 
    "provisioningState": "Succeeded" 
  }, 
  "tags": null 
}

Krok 1. Tworzenie klastra usługi AKS Arc z włączoną tożsamością obciążenia

Aby utworzyć klaster usługi AKS Arc, potrzebne są wartości $customlocation_ID i .$logicnet_Id

$customlocation_ID: identyfikator usługi Azure Resource Manager lokalizacji niestandardowej. Lokalizacja niestandardowa jest konfigurowana podczas wdrażania klastra rozwiązania Azure Stack HCI. Administrator infrastruktury powinien podać identyfikator usługi Resource Manager lokalizacji niestandardowej. Identyfikator usługi Resource Manager można również uzyskać przy użyciu polecenia $customlocation_ID = $(az customlocation show --name "<your-custom-location-name>" --resource-group $resource_group_name --query "id" -o tsv), jeśli administrator infrastruktury udostępnia niestandardową nazwę lokalizacji i nazwę grupy zasobów.
$logicnet_Id: Identyfikator usługi Azure Resource Manager lokalnej sieci logicznej platformy Azure utworzony zgodnie z tymi krokami. Administrator infrastruktury powinien podać identyfikator usługi Resource Manager sieci logicznej. Identyfikator usługi Resource Manager można również uzyskać przy użyciu polecenia $logicnet_Id = $(az stack-hci-vm network lnet show --name "<your-lnet-name>" --resource-group $resource_group_name --query "id" -o tsv), jeśli administrator infrastruktury udostępnia nazwę sieci logicznej i nazwę grupy zasobów.

Uruchom polecenie az aksarc create za pomocą parametru --enable-oidc-issuer --enable-workload-identity . Podaj identyfikatory entra-admin-group-object-ids i upewnij się, że jesteś członkiem grupy administracyjnej Identyfikator entra firmy Microsoft na potrzeby dostępu do trybu serwera proxy:

az aksarc create  
-n $aks_cluster_name -g $resource_group_name  
--custom-location $customlocation_ID --vnet-ids $logicnet_Id  
--aad-admin-group-object-ids <entra-admin-group-object-ids> 
--generate-ssh-keys  
--enable-oidc-issuer --enable-workload-identity

Po kilku minutach polecenie zostanie wykonane i zwróci informacje o klastrze w formacie JSON.

Wdrożenie rozszerzenia tożsamości obciążenia po pomyślnym utworzeniu aprowizowanego klastra może zająć trochę czasu. Użyj 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/"}

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

Ważne

W ramach ulepszenia zabezpieczeń klastrów usługi AKS Arc włączenie tożsamości obciążenia wyzwala dwie zmiany. Najpierw klucz podpisywania konta usługi Kubernetes automatycznie obraca się co 45 dni i pozostaje ważny przez 90 dni. Po drugie, flaga --service-account-extend-token-expiration jest wyłączona, zmniejszając ważność tokenu z jednego roku do maksymalnie 24 godzin.

Zapisywanie adresu URL wystawcy OIDC w zmiennej środowiskowej

Po pomyślnym utworzeniu klastra usługi AKS można 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 2. Tworzenie konta usługi Kubernetes i powiązanie go z tożsamością zarządzaną platformy Azure

Najpierw utwórz tożsamość zarządzaną. Uruchom polecenie az identity create:

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:

az connectedk8s proxy -n $aks_cluster_name -g $resource_group_name

Otwórz nowe okno. Skopiuj i wklej następujące polecenia interfejsu wiersza polecenia:

$yaml = @" apiVersion: v1 kind: ServiceAccount metadata: annotations: azure.workload.identity/client-id: $MSIId name: $SERVICE_ACCOUNT_NAME namespace: $SERVICE_ACCOUNT_NAMESPACE "@ $yaml = $yaml -replace '\$MSIId', $MSIId ` -replace '\$SERVICE_ACCOUNT_NAME', $SERVICE_ACCOUNT_NAME ` -replace '\$SERVICE_ACCOUNT_NAMESPACE', $SERVICE_ACCOUNT_NAMESPACE $yaml | kubectl apply -f -

Następujące dane wyjściowe pokazują pomyślne utworzenie konta usługi:

serviceaccount/workload-identity-sa created

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

Najpierw utwórz poświadczenia tożsamości federacyjnej. Wywołaj polecenie az identity federated-credential create , aby utworzyć poświadczenia tożsamości federacyjnej między tożsamością zarządzaną, wystawcą konta usługi i tematem. 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 4. 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 wdrożono klaster Kubernetes i skonfigurowano go do używania tożsamości obciążenia w ramach przygotowań do uwierzytelniania obciążeń aplikacji 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

Wdrażanie i konfigurowanie tożsamości obciążenia w usłudze AKS włączonej przez klaster usługi Azure Arc (wersja zapoznawcza)

Wymagania wstępne

Eksportowanie zmiennych środowiskowych

Ustawianie aktywnej subskrypcji

Tworzenie grupy zasobów

Krok 1. Tworzenie klastra usługi AKS Arc z włączoną tożsamością obciążenia

Zapisywanie adresu URL wystawcy OIDC w zmiennej środowiskowej

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

Tworzenie konta usługi Kubernetes

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

Krok 4. Wdrażanie aplikacji

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

Następne kroki

Opinia

Dodatkowe zasoby