Använda Kubernetes RBAC med Microsoft Entra ID i AKS

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 (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 som beviljar lämpliga behörigheter, till exempel för att skapa och visa resurser.

Förutsättningar

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. Information om hur du uppgraderar ett befintligt kluster med Microsoft Entra-integrering och Kubernetes RBAC finns i Aktivera 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
Azure CLI

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

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

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 du använder Microsoft Entra-autentisering med Kubernetes RBAC (och inte Azure RBAC) är enableAzureRbacutdatavärdet för false .

Skapa grupper i Microsoft Entra-ID

I det här avsnittet lär du dig hur du skapar två användarroller för att visa hur Kubernetes RBAC och Microsoft Entra ID styr åtkomstklusterresurser. Följande två exempelroller är:

Programutvecklare
- En användare med namnet aksdev som ingår i appdev-gruppen .
Platstillförlitlighetstekniker (SRE)
- 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.

Apputveckling
SRE

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)
```
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)
```
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
```
Viktigt!

Det rollnamn som du anger måste exakt matcha namnet på Azure-rolldefinitionen, inklusive versaler och avstånd.

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.

Skapa en exempelgrupp för SREs med namnet opssre.

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

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 användare i Microsoft Entra-ID

När du har skapat microsoft entra-ID-exempelgrupper för programutvecklare och SRE:er är nästa steg att skapa två motsvarande användarkonton. Dessa användare används för att logga in på AKS-klustret och verifiera Kubernetes RBAC-integreringen som beskrivs senare i den här artikeln.

Innan du börjar måste du ange användarens huvudnamn (UPN) och lösenordet för programutvecklarna. UPN måste innehålla det verifierade domännamnet för din klientorganisation. Till exempel en användare som är programutvecklare, 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 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, UPN och 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)
```
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
```

Konfigurera UPN och lösenordet för SRE. UPN måste innehålla det verifierade domännamnet för din klientorganisation. Till exempel en SRE-användare, 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
```
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
```

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

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.

Apputveckling
SRE

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
```
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å UPN. Om användaren finns i en annan Microsoft Entra-klientorganisation frågar du efter och använder egenskapen objectId i stället.
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: ["*"]
```
Skapa rollen med kommandot kubectl apply och ange filnamnet för YAML-manifestet.
```
kubectl apply -f role-dev-namespace.yaml
```
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
```
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
  # Replace the placeholder below with the group's objectId (GUID)
  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 UPN i föregående exempel.
Skapa RoleBinding med kommandot kubectl apply och ange filnamnet för DITT YAML-manifest:
```
kubectl apply -f rolebinding-dev-namespace.yaml
```

Skapa ett namnområde för SRE med kommandot kubectl create namespace :
```
kubectl create namespace sre
```

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: ["*"]

Skapa rollen med kommandot kubectl apply och ange filnamnet för YAML-manifestet:
```
kubectl apply -f role-sre-namespace.yaml
```
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
```

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
  # Replace the placeholder below with the group's objectId (GUID)
  name: groupObjectId

Skapa RoleBinding med kommandot kubectl apply och ange filnamnet för DITT YAML-manifest:
```
kubectl apply -f rolebinding-sre-namespace.yaml
```

Få åtkomst till AKS-klusterresurser med 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.

Å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
```

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

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

Ange autentiseringsuppgifterna för appdev-gruppkontot (ange dina egna autentiseringsuppgifter) i inloggningsprompten. När du har loggat in framgångsrikt cachelagras kontotoken för framtida kubectl kommandon. NGINX har schemalagts enligt följande exempelutdata:
```
$ 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
```
kubectl get pods Använd kommandot för att visa poddar i dev-namnområdet:
```
kubectl get pods --namespace dev
```

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

Testa SRE-åtkomst till AKS-klusterresurser

Bekräfta att vårt Microsoft Entra-gruppmedlemskap och Kubernetes RBAC fungerar korrekt mellan olika användare och grupper genom att prova de tidigare kommandona när de loggas in som akssre-användare .

Å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
```
Schemalägg och visa poddar i det tilldelade SRE-namnområdet . När du uppmanas till det loggar du in med autentiseringsuppgifterna för opssre-gruppkontot (ange dina egna autentiseringsuppgifter).
```
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
```
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
```

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"

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

För att visa pods utanför dev-namnrymden. Använd kubectl get pods kommandot genom att använda --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 schemalägger du 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 "akssre@contoso.com" cannot create resource "pods" in API group "" in the namespace "sre"

Rensa klusterresurser

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 Microsoft Entra ID 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 Microsoft Entra ID 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.

Feedback

Var den här sidan hjälpsam?

Last updated on 2025-12-17