Konfigurowanie powiązań tożsamości w usłudze Azure Kubernetes Service (AKS) (wersja zapoznawcza)

Skonfiguruj powiązania tożsamości w klastrach usługi Azure Kubernetes Service (AKS), aby zamapować tożsamość zarządzaną przypisaną przez użytkownika (UAMI) w wielu klastrach przy użyciu pojedynczego poświadczenia tożsamości federacyjnej (FIC). Ta konfiguracja ułatwia skalowanie uwierzytelniania Microsoft Entra dla zasobów bez osiągnięcia limitów FIC.

Wymagania wstępne

Instalowanie lub aktualizowanie aks-preview rozszerzenia

  • Zainstaluj lub zaktualizuj rozszerzenie CLI platformy Azure do najnowszej wersji, używając polecenia az extension add lub az extension update.

    # Install the aks-preview extension
az extension add --name aks-preview

# Update to the latest version if already installed
az extension update --name aks-preview

Włącz flagę funkcji IdentityBindingPreview

  1. Zarejestruj flagę IdentityBindingPreview funkcjonalności w subskrypcji platformy Azure za pomocą polecenia az feature register.

    az feature register --namespace Microsoft.ContainerService --name IdentityBindingPreview

    Rejestracja funkcji może potrwać do 15 minut.

  2. Poczekaj na zakończenie rejestrowania funkcji przy użyciu polecenia az feature show.

    az feature show --namespace Microsoft.ContainerService --name IdentityBindingPreview

  3. Gdy funkcja będzie wyświetlana jako Registered, odśwież rejestrację dostawcy przy użyciu az provider register polecenia .

    az provider register --namespace Microsoft.ContainerService

Ograniczenia

Tworzenie zasobów testowych

  1. Utwórz grupę zasobów platformy Azure przy użyciu az group create polecenia .

    export RESOURCE_GROUP="ib-test"
export LOCATION="westus2"

az group create --name $RESOURCE_GROUP --location $LOCATION

  2. Utwórz klaster AKS z włączoną tożsamością składnika obciążenia i wystawcą OIDC, używając polecenia az aks create z flagami --enable-workload-identity i --enable-oidc-issuer.

    export CLUSTER_NAME="ib-test-cluster"

az aks create --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --location $LOCATION --no-ssh-key --enable-workload-identity --enable-oidc-issuer

  3. Utwórz tożsamość zarządzaną przypisaną przez użytkownika (UAMI) przy użyciu polecenia az identity create.

    export MI_NAME="ib-test-mi"
az identity create --resource-group $RESOURCE_GROUP --name $MI_NAME

Weryfikowanie wersji webhooka tożsamości obciążeniowej

  • Powiązanie tożsamości wymaga wersji zapoznawczej webhook tożsamości obciążenia roboczego. Sprawdź zainstalowaną wersję webhooka przy użyciu następującego kubectl get pods polecenia:

    kubectl -n kube-system get pods -l azure-workload-identity.io/system=true -o yaml | grep v1.6.0

    Wynik powinien pokazywać v1.6.0-alpha.1 w tagu obrazu, co potwierdza, że zainstalowano poprawną wersję.

Pobierz identyfikatory UAMI

  • Pobierz identyfikatory zasobów, głównego, klienta i dzierżawy UAMI i ustaw je jako zmienne środowiskowe przy użyciu następujących az identity show poleceń:

    export MI_RESOURCE_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $MI_NAME --query id --output tsv)
export MI_PRINCIPAL_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $MI_NAME --query principalId --output tsv)
export MI_CLIENT_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $MI_NAME --query clientId --output tsv)
export MI_TENANT_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $MI_NAME --query tenantId --output tsv)

Tworzenie powiązania tożsamości

  • Zmapuj UAMI na klaster AKS za pomocą powiązania tożsamości przy użyciu polecenia az aks identity-binding create.

    az aks identity-binding create --resource-group $RESOURCE_GROUP --cluster-name $CLUSTER_NAME --name "${MI_NAME}-ib" --managed-identity-resource-id $MI_RESOURCE_ID

    Uwaga / Notatka

    Podczas tworzenia powiązania tożsamości usługa AKS automatycznie tworzy poświadczenia tożsamości federacyjnej (FIC) o nazwie aks-identity-binding w obszarze UAMI. Poświadczeniem zarządza Azure Kubernetes Service (AKS). Nie modyfikuj ani nie usuwaj go, gdy wiązania tożsamości są używane. FIC utworzony dla powiązań tożsamości jest współużytkowany w ramach wszystkich powiązań tożsamości odnoszących się do tego samego UAMI.

Uzyskiwanie adresu URL dostawcy identyfikacji OIDC dla UAMI

  • Uzyskaj adres URL wystawcy OIDC powiązany z UAMI, badając powiązanie tożsamości przy użyciu polecenia az aks identity-binding show.

    az aks identity-binding show --resource-group $RESOURCE_GROUP --cluster-name $CLUSTER_NAME --name "${MI_NAME}-ib"

    Skondensowane przykładowe dane wyjściowe:

    {
  "oidcIssuer": {
    "oidcIssuerUrl": "https://ib.oic.prod-aks.azure.com/<MI-tenant-id>/<MI-client-id>"
  }
}

Nawiązywanie połączenia z klastrem usługi AKS

  1. Pobierz poświadczenia klastra AKS przy użyciu polecenia az aks get-credentials i zapisz je w osobnym pliku kubeconfig.

    az aks get-credentials --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME -a -f "${CLUSTER_NAME}.kubeconfig"

  2. Ustaw zmienną KUBECONFIG środowiskową, aby wskazywała nowy plik kubeconfig:

    export KUBECONFIG="$(pwd)/${CLUSTER_NAME}.kubeconfig"

Autoryzowanie przestrzeni nazw i kont usług

  • Skonfiguruj kontrolę dostępu opartą na rolach (RBAC), aby przyznać określonym podmiotom uprawnienia do korzystania z tożsamości zarządzanej za pośrednictwem powiązania tożsamości, stosując następujący manifest przy użyciu następującego kubectl apply polecenia.

    Uwaga / Notatka

    Poniższy przykład jawnie odwołuje się do demo konta usługi w demo przestrzeni nazw. Chociaż jawne odwoływanie się do określonego konta usługi jest jedną z opcji, można również odwołać się do kolekcji kont usług w obszarze subjects. Aby uzyskać więcej informacji, zobacz Odwoływanie się do tematów w dokumentacji platformy Kubernetes.

    kubectl apply -f - <<EOF
apiVersion: v1
kind: Namespace
metadata:
  name: demo
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: demo
  namespace: demo
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: use-mi-${MI_CLIENT_ID}
rules:
  - verbs: ["use-managed-identity"]
    apiGroups: ["cid.wi.aks.azure.com"]
    resources: ["${MI_CLIENT_ID}"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: use-mi-${MI_CLIENT_ID}
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: use-mi-${MI_CLIENT_ID}
subjects:
  - kind: ServiceAccount
    name: demo
    namespace: demo
EOF

Utwórz magazyn kluczy z ochroną przed usunięciem i autoryzacją RBAC w Azure

  • Utwórz magazyn kluczy z ochroną przed czyszczeniem i autoryzacją RBAC platformy Azure włączoną przy użyciu polecenia az keyvault create z flagami --enable-purge-protection i --enable-rbac-authorization. Możesz również użyć istniejącego magazynu kluczy, jeśli jest skonfigurowany do ochrony przed czyszczeniem i autoryzacji Azure RBAC.

    export KEY_VAULT_NAME="ib-test"

az keyvault create \
    --name $KEY_VAULT_NAME \
    --resource-group $RESOURCE_GROUP \
    --location $LOCATION \
    --enable-purge-protection \
    --enable-rbac-authorization

Pobierz identyfikator zasobu i adres URL magazynu kluczy

  1. Pobierz identyfikator zasobu magazynu kluczy przy użyciu polecenia az keyvault show i ustaw go jako zmienną środowiskową.

    export KEY_VAULT_RESOURCE_ID=$(az keyvault show --resource-group $RESOURCE_GROUP \
    --name $KEY_VAULT_NAME \
    --query id \
    --output tsv)

  2. Pobierz adres URL magazynu kluczy przy użyciu az keyvault show polecenia i ustaw go jako zmienną środowiskową:

    export KEYVAULT_URL="$(az keyvault show \
    --resource-group $RESOURCE_GROUP \
    --name $KEY_VAULT_NAME \
    --query properties.vaultUri \
    --output tsv)"

Konfigurowanie dostępu do magazynu kluczy i tworzenie tajemnicy

W poniższych krokach pokazano, jak uzyskać dostęp do tajemnic, kluczy lub certyfikatów w usłudze Azure Key Vault z poziomu podu. 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ń RBAC platformy Azure, aby przyznać podowi dostęp do Azure Key Vault. Aby uzyskać więcej informacji na temat modelu uprawnień RBAC platformy Azure dla usługi Azure Key Vault, zobacz Udzielanie uprawnień aplikacjom do uzyskiwania dostępu do usługi Azure Key Vault przy użyciu kontroli dostępu opartej na rolach platformy Azure.

  1. Pobierz identyfikator obiektu zalogowanego użytkownika przy użyciu az ad signed-in-user show polecenia i ustaw go jako zmienną środowiskową:

    export CALLER_OBJECT_ID=$(az ad signed-in-user show --query id --output tsv)

  2. Przypisz sobie rolę Oficera tajemnic w Key Vault platformy Azure używając polecenia az role assignment create.

    az role assignment create --assignee $CALLER_OBJECT_ID \
    --role "Key Vault Secrets Officer" \
    --scope $KEY_VAULT_RESOURCE_ID

  3. Utwórz wpis tajny w magazynie kluczy przy użyciu az keyvault secret set polecenia .

    export KEY_VAULT_SECRET_NAME="my-secret"

az keyvault secret set \
    --vault-name $KEY_VAULT_NAME \
    --name $KEY_VAULT_SECRET_NAME \
    --value "Hello\!"

  4. Przypisz rolę Użytkownika wpisów tajnych usługi Key Vault do interfejsu użytkownika az role assignment create przy użyciu polecenia .

    az role assignment create \
    --assignee-object-id $MI_PRINCIPAL_ID \
    --role "Key Vault Secrets User" \
    --scope $KEY_VAULT_RESOURCE_ID \
    --assignee-principal-type ServicePrincipal

Dodawanie adnotacji do konta usługi

  1. Dodaj adnotację do konta usługi przy użyciu polecenia kubectl annotate z identyfikatorem dzierżawy tożsamości zarządzanej.

    kubectl annotate sa demo -n demo azure.workload.identity/tenant-id=$MI_TENANT_ID

  2. Adnotuj konto usługi identyfikatorem klienta tożsamości zarządzanej, korzystając z polecenia kubectl annotate.

    kubectl annotate sa demo -n demo azure.workload.identity/client-id=$MI_CLIENT_ID

Wdrażanie przykładowej aplikacji

  • Wdróż przykładowy zasobnik, który za pomocą powiązania tożsamości uzyskuje token dostępu dla zarządzanej tożsamości, aby uzyskać dostęp do usługi Azure Key Vault, używając następującego polecenia kubectl apply.

    kubectl apply -f - <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: demo
  namespace: demo
  labels:
    azure.workload.identity/use: "true"
  annotations:
    azure.workload.identity/use-identity-binding: "true"
spec:
  serviceAccount: demo
  containers:
    - name: azure-sdk
      # source code: https://github.com/Azure/azure-workload-identity/blob/feature/custom-token-endpoint/examples/identitybinding-msal-go/main.go
      image: ghcr.io/bahe-msft/azure-workload-identity/identitybinding-msal-go:latest-linux-amd64
      env:
        - name: KEYVAULT_URL
          value: ${KEYVAULT_URL}
        - name: SECRET_NAME
          value: ${KEY_VAULT_SECRET_NAME}
  restartPolicy: Never
EOF

Weryfikowanie dostępu do magazynu kluczy z przykładowej aplikacji

  1. Opisz zasobnik i potwierdź, że zmienne środowiskowe oraz projekcje montażu woluminu tokenu są obecne przy użyciu polecenia kubectl describe pod.

    kubectl describe pod demo -n demo

    Oczekiwane dane wyjściowe powinny zawierać wartości , AZURE_CLIENT_ID, AZURE_TENANT_IDAZURE_FEDERATED_TOKEN_FILE, AZURE_AUTHORITY_HOST, AZURE_KUBERNETES_TOKEN_PROXY. AZURE_KUBERNETES_SNI_NAME, i AZURE_KUBERNETES_CA_FILE.

  2. Sprawdź, czy zasobnik może uzyskać token i dostęp do zasobu, używając polecenia kubectl logs.

    kubectl logs demo -n demo

    W przypadku powodzenia dane wyjściowe powinny być podobne do następującego przykładu:

    I1107 20:03:42.865180       1 main.go:77] "successfully got secret" secret="Hello!"

Skalowanie powiązań tożsamości w wielu klastrach

Powiązania tożsamości umożliwiają mapowanie wielu klastrów usługi AKS na tę samą zarządzaną tożsamość przypisaną użytkownikowi (UAMI), jednocześnie używając pojedynczego FIC. Aby skalować powiązania tożsamości w wielu klastrach, możesz powtórzyć kroki opisane w artykule Tworzenie powiązania tożsamości za pomocą weryfikacji dostępu do magazynu kluczy z przykładowej aplikacji dla każdego dodatkowego klastra, który ma zostać zamapowyny na ten sam interfejs użytkownika (utworzenie nowego powiązania tożsamości dla klastra).

Uprzątnij zasoby

Jeśli nie potrzebujesz już zasobów utworzonych w tym artykule, możesz je wyczyścić, aby uniknąć ponoszenia przyszłych kosztów.

  1. Usuń zasobnik przy użyciu kubectl delete pod polecenia .

    kubectl delete pod demo -n demo

  2. Usuń przestrzeń nazw przy użyciu kubectl delete ns polecenia .

    kubectl delete ns demo

  3. Usuń grupę zasobów i wszystkie powiązane zasoby przy użyciu az group delete polecenia .

    az group delete --name $RESOURCE_GROUP --yes --no-wait

Treści powiązane

  • Last updated on