Använda rollbaserad Kubernetes-åtkomstkontroll med Microsoft Entra-ID i Azure Kubernetes Service

Azure Kubernetes Service (AKS) kan konfigureras för att använda Microsoft Entra-ID för användarautentisering. I den här konfigurationen loggar du in på ett AKS-kluster med en Microsoft Entra-autentiseringstoken. När du har autentiserats kan du använda den inbyggda rollbaserade Åtkomstkontrollen för Kubernetes (Kubernetes RBAC) för att hantera åtkomst till namnområden och klusterresurser baserat på en användares identitets- eller gruppmedlemskap.

Den här artikeln visar hur du gör följande:

• Kontrollera åtkomsten med Kubernetes RBAC i ett AKS-kluster baserat på Microsoft Entra-gruppmedlemskap.
• Skapa exempelgrupper och användare i Microsoft Entra-ID.
• Skapa roller och rollbindningar i ett AKS-kluster för att ge lämpliga behörigheter för att skapa och visa resurser.

Innan du börjar

• Du har ett befintligt AKS-kluster med Microsoft Entra-integrering aktiverat. Om du behöver ett AKS-kluster med den här konfigurationen kan du läsa Integrera Microsoft Entra-ID med AKS.
• Kubernetes RBAC aktiveras som standard när AKS-klustret skapas. Om du vill uppgradera ett befintligt kluster med Microsoft Entra-integrering och Kubernetes RBAC aktiverar du Microsoft Entra-integrering i ditt befintliga AKS-kluster.
• Kontrollera att Azure CLI version 2.0.61 eller senare är installerad och konfigurerad. Kör az --version för att hitta versionen. Information om hur du installerar eller uppgraderar finns i Installera Azure CLI.
• Om du använder Terraform installerar du Terraform version 2.99.0 eller senare.

Använd Azure-portalen eller Azure CLI för att verifiera att Microsoft Entra-integrering med Kubernetes RBAC är aktiverat.

Azure Portal

Så här verifierar du med hjälp av Azure-portalen:

1. Logga in på Azure-portalen och gå till din AKS-klusterresurs.
2. I tjänstmenyn går du till Inställningar och väljer Säkerhetskonfiguration.
3. Under avsnittet Autentisering och auktorisering kontrollerar du att alternativet Microsoft Entra-autentisering med Kubernetes RBAC är valt.

Azure CLI

Du kan verifiera med hjälp av Azure CLI-kommandot az aks show . Ersätt värdet myResourceGroup med resursgruppens namn som är värd för aks-klusterresursen och ersätt myAKSCluster med det faktiska namnet på ditt AKS-kluster.

az aks show --resource-group myResourceGroup --name myAKSCluster

Om aktiverat visar att värdet för enableAzureRbac är false.

Skapa demogrupper i Microsoft Entra-ID

I den här artikeln skapar du två användarroller för att visa hur Kubernetes RBAC och Microsoft Entra ID styr åtkomsten till klusterresurser. Följande två exempelroller används:

• Programutvecklare
  • En användare med namnet aksdev som ingår i appdev-gruppen .
• Platstillförlitlighetstekniker
  • En användare med namnet akssre som ingår i opssre-gruppen .

I produktionsmiljöer kan du använda befintliga användare och grupper i en Microsoft Entra-klientorganisation.

1. Hämta först resurs-ID:t för ditt AKS-kluster med hjälp av az aks show kommandot . Tilldela sedan resurs-ID:t till en variabel med namnet AKS_ID så att den kan refereras till i andra kommandon.

   AKS_ID=$(az aks show \
       --resource-group myResourceGroup \
       --name myAKSCluster \
       --query id -o tsv)
   

2. Skapa den första exempelgruppen i Microsoft Entra-ID för programutvecklare med hjälp av az ad group create kommandot . I följande exempel skapas en grupp med namnet appdev:

   APPDEV_ID=$(az ad group create --display-name appdev --mail-nickname appdev --query id -o tsv)
   

3. Skapa en Azure-rolltilldelning för appdev-gruppen med kommandot az role assignment create . Med den här tilldelningen kan alla medlemmar i gruppen använda kubectl för att interagera med ett AKS-kluster genom att ge dem rollen Azure Kubernetes Service Cluster User.

   az role assignment create \
     --assignee $APPDEV_ID \
     --role "Azure Kubernetes Service Cluster User Role" \
     --scope $AKS_ID
   

   Tips/Råd

   Om du får ett fel, till exempel Principal 35bfec9328bd4d8d9b54dea6dac57b82 doesn't exist in the directory a5443dcd-cd0e-494d-a387-3039b419f0d5., vänta några sekunder på att Microsoft Entra-gruppobjekt-ID:t ska spridas via katalogen och försök sedan med kommandot az role assignment create igen.

4. Skapa en andra exempelgrupp för SREs med namnet opssre.

   OPSSRE_ID=$(az ad group create --display-name opssre --mail-nickname opssre --query id -o tsv)
   

5. Skapa en Azure-rolltilldelning för att tilldela medlemmar i gruppen rollen Azure Kubernetes Service Cluster User.

   az role assignment create \
     --assignee $OPSSRE_ID \
     --role "Azure Kubernetes Service Cluster User Role" \
     --scope $AKS_ID
   

Skapa demoanvändare i Microsoft Entra-ID

Nu när vi har två exempelgrupper som skapats i Microsoft Entra-ID för våra programutvecklare och SRE skapar du två exempelanvändare. Om du vill testa Kubernetes RBAC-integreringen i slutet av artikeln loggar du in på AKS-klustret med dessa konton.

Ange användarens huvudnamn och lösenord för programutvecklare

Ange användarens huvudnamn (UPN) och lösenordet för programutvecklare. UPN måste innehålla det verifierade domännamnet för din klientorganisation, till exempel aksdev@contoso.com. Information om hur du kan ta reda på (eller ange) de verifierade domännamnen i klientorganisationen finns i Hantera anpassade domännamn i ditt Microsoft Entra-ID.

Följande kommando uppmanar dig att ange UPN och ställer in det på AAD_DEV_UPN så att det kan användas i ett senare kommando:

echo "Please enter the UPN for application developers: " && read AAD_DEV_UPN

Följande kommando uppmanar dig att ange lösenordet och ställer in det på AAD_DEV_PW för användning i ett senare kommando:

echo "Please enter the secure password for application developers: " && read AAD_DEV_PW

Skapa användarkontona

1. Skapa det första användarkontot i Microsoft Entra-ID med kommandot az ad user create . I följande exempel skapas en användare med visningsnamnet AKS Dev och UPN och ett säkert lösenord med hjälp av värdena i AAD_DEV_UPN och AAD_DEV_PW:

   AKSDEV_ID=$(az ad user create \
     --display-name "AKS Dev" \
     --user-principal-name $AAD_DEV_UPN \
     --password $AAD_DEV_PW \
     --query id -o tsv)
   

2. Lägg till användaren i appdev-gruppen som skapades i föregående avsnitt med kommandot az ad group member add .

   az ad group member add --group appdev --member-id $AKSDEV_ID
   

3. Konfigurera UPN och lösenordet för SRE. UPN måste innehålla det verifierade domännamnet för din klientorganisation, till exempel akssre@contoso.com. Följande kommando uppmanar dig att ange UPN och ställer in det på AAD_SRE_UPN för användning i ett senare kommando:

   echo "Please enter the UPN for SREs: " && read AAD_SRE_UPN
   

4. Följande kommando uppmanar dig att ange lösenordet och ställer in det på AAD_SRE_PW för användning i ett senare kommando:

   echo "Please enter the secure password for SREs: " && read AAD_SRE_PW
   

5. Skapa ett andra användarkonto. I följande exempel skapas en användare med visningsnamnet AKS SRE och UPN och ett säkert lösenord med hjälp av värdena i AAD_SRE_UPN och AAD_SRE_PW:

   # Create a user for the SRE role
   AKSSRE_ID=$(az ad user create \
     --display-name "AKS SRE" \
     --user-principal-name $AAD_SRE_UPN \
     --password $AAD_SRE_PW \
     --query id -o tsv)
   
   # Add the user to the opssre Entra ID group
   az ad group member add --group opssre --member-id $AKSSRE_ID
   

Skapa AKS-klusterresurser för apputveckling

Vi har skapat våra Microsoft Entra-grupper, användare och Azure-rolltilldelningar. Nu konfigurerar du AKS-klustret för att ge dessa olika grupper åtkomst till specifika resurser.

1. Hämta autentiseringsuppgifterna för klusteradministratören az aks get-credentials med kommandot . I ett av de följande avsnitten får du de reguljära autentiseringsuppgifterna för användarklustret för att se Microsoft Entra-autentiseringsflödet i praktiken.

   az aks get-credentials --resource-group myResourceGroup --name myAKSCluster --admin
   

2. Skapa ett namnområde i AKS-klustret med kommandot kubectl create namespace . I följande exempel skapas ett namnområdesnamn dev:

   kubectl create namespace dev
   

   Anmärkning

   I Kubernetes definierar Roller de behörigheter som ska beviljas och Rollbindningar tillämpar dem på önskade användare eller grupper. Dessa tilldelningar kan tillämpas på ett givet namnområde eller i hela klustret. Mer information finns i Använda Kubernetes RBAC-auktorisering.

   Om användaren som du beviljar Kubernetes RBAC-bindningen för finns i samma Microsoft Entra-klientorganisation tilldelar du behörigheter baserat på userPrincipalName (UPN). Om användaren finns i en annan Microsoft Entra-klientorganisation frågar du efter och använder egenskapen objectId i stället.

3. Skapa en roll för dev-namnområdet , vilket ger fullständig behörighet till namnområdet. I produktionsmiljöer kan du ange mer detaljerade behörigheter för olika användare eller grupper. Skapa en fil med namnet role-dev-namespace.yaml och klistra in följande YAML-manifest:

   kind: Role
   apiVersion: rbac.authorization.k8s.io/v1
   metadata:
     name: dev-user-full-access
     namespace: dev
   rules:
   - apiGroups: ["", "extensions", "apps"]
     resources: ["*"]
     verbs: ["*"]
   - apiGroups: ["batch"]
     resources:
     - jobs
     - cronjobs
     verbs: ["*"]
   

4. Skapa rollen med kommandot kubectl apply och ange filnamnet för YAML-manifestet.

   kubectl apply -f role-dev-namespace.yaml
   

5. Hämta resurs-ID:t för appdev-gruppen med kommandot az ad group show . Den här gruppen anges som ämne för ett RoleBinding i nästa steg.

   az ad group show --group appdev --query id -o tsv
   

6. Skapa en RoleBinding för appdev-gruppen för att använda den tidigare skapade rollen för namnområdesåtkomst. Skapa en fil med namnet rolebinding-dev-namespace.yaml och klistra in följande YAML-manifest. På den sista raden ersätter du groupObjectId med gruppobjektets ID-utdata från föregående kommando.

   kind: RoleBinding
   apiVersion: rbac.authorization.k8s.io/v1
   metadata:
     name: dev-user-access
     namespace: dev
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: Role
     name: dev-user-full-access
   subjects:
   - kind: Group
     namespace: dev
     name: groupObjectId
   

   Tips/Råd

   Om du vill skapa Rollbindning för en enskild användare anger du typ: Användare och ersätt groupObjectId med användarens huvudnamn (UPN) i föregående exempel.

7. Skapa RoleBinding med kommandot kubectl apply och ange filnamnet för DITT YAML-manifest:

   kubectl apply -f rolebinding-dev-namespace.yaml
   

Skapa AKS-klusterresurserna för SRE

Upprepa nu föregående steg för att skapa ett namnområde, en roll och en rollbindning för SRE.

1. Skapa ett namnområde för sre med kommandot kubectl create namespace .

   kubectl create namespace sre
   

2. Skapa en fil med namnet role-sre-namespace.yaml och klistra in följande YAML-manifest:

   kind: Role
   apiVersion: rbac.authorization.k8s.io/v1
   metadata:
     name: sre-user-full-access
     namespace: sre
   rules:
   - apiGroups: ["", "extensions", "apps"]
     resources: ["*"]
     verbs: ["*"]
   - apiGroups: ["batch"]
     resources:
     - jobs
     - cronjobs
     verbs: ["*"]
   

3. Skapa rollen med kommandot kubectl apply och ange filnamnet för YAML-manifestet.

   kubectl apply -f role-sre-namespace.yaml
   

4. Hämta resurs-ID:t för opssre-gruppen med kommandot az ad group show .

   az ad group show --group opssre --query id -o tsv
   

5. Skapa en RoleBinding för opssre-gruppen för att använda den tidigare skapade rollen för namnområdesåtkomst. Skapa en fil med namnet rolebinding-sre-namespace.yaml och klistra in följande YAML-manifest. På den sista raden ersätter du groupObjectId med gruppobjektets ID-utdata från föregående kommando.

   kind: RoleBinding
   apiVersion: rbac.authorization.k8s.io/v1
   metadata:
     name: sre-user-access
     namespace: sre
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: Role
     name: sre-user-full-access
   subjects:
   - kind: Group
     namespace: sre
     name: groupObjectId
   

6. Skapa RoleBinding med kommandot kubectl apply och ange filnamnet för DITT YAML-manifest.

   kubectl apply -f rolebinding-sre-namespace.yaml
   

Interagera med klusterresurser med hjälp av Microsoft Entra-identiteter

Testa nu att de förväntade behörigheterna fungerar när du skapar och hanterar resurser i ett AKS-kluster. I de här exemplen schemalägger och visar du poddar i användarens tilldelade namnområde och försöker schemalägga och visa poddar utanför det tilldelade namnområdet.

1. Återställ kontexten för kubeconfig med az aks get-credentials kommandot. I ett tidigare avsnitt anger du kontexten med autentiseringsuppgifterna för klusteradministratören. Administratörsanvändaren kringgår Microsoft Entra-inloggningsanvisningarna. Utan parametern tillämpas användarkontexten som kräver att alla begäranden autentiseras --admin med hjälp av Microsoft Entra-ID.

   az aks get-credentials --resource-group myResourceGroup --name myAKSCluster --overwrite-existing
   

2. Schemalägg en grundläggande NGINX-podd med kommandot kubectl run i dev-namnområdet .

   kubectl run nginx-dev --image=mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine --namespace dev
   

3. Ange autentiseringsuppgifterna för ditt eget appdev@contoso.com konto som skapades i början av artikeln som inloggningsprompt. När du har loggat in framgångsrikt cachelagras kontotoken för framtida kubectl kommandon. NGINX har schemalagts framgångsrikt, enligt följande exempel på resultatet:

   $ kubectl run nginx-dev --image=mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine --namespace dev
   
   To sign in, use a web browser to open the page https://microsoft.com/devicelogin and enter the code B24ZD6FP8 to authenticate.
   
   pod/nginx-dev created
   

4. kubectl get pods Använd kommandot för att visa poddar i dev-namnområdet.

   kubectl get pods --namespace dev
   

5. Kontrollera att statusen för NGINX-pod Running. Utdata ser ut som följande:

   $ kubectl get pods --namespace dev
   
   NAME        READY   STATUS    RESTARTS   AGE
   nginx-dev   1/1     Running   0          4m
   

Skapa och visa klusterresurser utanför det tilldelade namnområdet

Försök att visa poddar utanför dev-namnområdet . kubectl get pods Använd kommandot igen, den här gången för att se --all-namespaces.

kubectl get pods --all-namespaces

Användarens gruppmedlemskap har ingen Kubernetes-roll som tillåter den här åtgärden, vilket visas i följande exempelutdata:

Error from server (Forbidden): pods is forbidden: User "aksdev@contoso.com" cannot list resource "pods" in API group "" at the cluster scope

På samma sätt kan du försöka schemalägga en podd i ett annat namnområde, till exempel sre-namnområdet . Användarens gruppmedlemskap överensstämmer inte med en Kubernetes-roll och RoleBinding för att bevilja dessa behörigheter, som visas i följande exempelutdata.

$ kubectl run nginx-dev --image=mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine --namespace sre

Error from server (Forbidden): pods is forbidden: User "aksdev@contoso.com" cannot create resource "pods" in API group "" in the namespace "sre"

Testa SRE-åtkomsten till AKS-klusterresurserna

Om du vill bekräfta att vårt Microsoft Entra-gruppmedlemskap och Kubernetes RBAC fungerar korrekt mellan olika användare och grupper provar du de tidigare kommandona när du är inloggad som opssre-användare .

1. Återställ kubeconfig-kontextenaz aks get-credentials med kommandot som rensar den tidigare cachelagrade autentiseringstoken för aksdev-användaren .

   az aks get-credentials --resource-group myResourceGroup --name myAKSCluster --overwrite-existing
   

2. Försök att schemalägga och visa poddar i det tilldelade sre-namnområdet . När du uppmanas till det loggar du in med dina egna opssre@contoso.com autentiseringsuppgifter som skapades i början av artikeln.

   kubectl run nginx-sre --image=mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine --namespace sre
   kubectl get pods --namespace sre
   

   Som du ser i följande exempelutdata kan du skapa och visa poddarna:

   $ kubectl run nginx-sre --image=mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine --namespace sre
   

3. Om du vill logga in använder du en webbläsare för att öppna sidan https://microsoft.com/devicelogin och ange koden BM4RHP3FD för att autentisera.

   pod/nginx-sre created
   
   $ kubectl get pods --namespace sre
   
   NAME        READY   STATUS    RESTARTS   AGE
   nginx-sre   1/1     Running   0
   

4. Försök att visa eller schemalägga poddar utanför det tilldelade SRE-namnområdet.

   kubectl get pods --all-namespaces
   kubectl run nginx-sre --image=mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine --namespace dev
   

   Dessa kubectl kommandon misslyckas, vilket visas i följande exempelutdata. Användarens gruppmedlemskap och Kubernetes-roll och rollbindningar beviljar inte behörighet att skapa eller hantera resurser i andra namnområden.

   $ kubectl get pods --all-namespaces
   Error from server (Forbidden): pods is forbidden: User "akssre@contoso.com" cannot list pods at the cluster scope
   
   $ kubectl run nginx-sre --image=mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine --namespace dev
   Error from server (Forbidden): pods is forbidden: User "akssre@contoso.com" cannot create pods in the namespace "dev"
   

Rensa resurser

I den här artikeln har du skapat resurser i AKS-klustret och användare och grupper i Microsoft Entra-ID. Om du vill rensa alla resurser kör du följande kommandon:

# Get the admin kubeconfig context to delete the necessary cluster resources.

az aks get-credentials --resource-group myResourceGroup --name myAKSCluster --admin

# Delete the dev and sre namespaces. This also deletes the pods, Roles, and RoleBindings.

kubectl delete namespace dev
kubectl delete namespace sre

# Delete the Azure AD user accounts for aksdev and akssre.

az ad user delete --upn-or-object-id $AKSDEV_ID
az ad user delete --upn-or-object-id $AKSSRE_ID

# Delete the Azure AD groups for appdev and opssre. This also deletes the Azure role assignments.

az ad group delete --group appdev
az ad group delete --group opssre

Nästa steg

• Mer information om hur du skyddar Kubernetes-kluster finns i Åtkomst- och identitetsalternativ för AKS.
• Metodtips för identitets- och resurskontroll finns i Metodtips för autentisering och auktorisering i AKS.