Usar o controle de acesso baseado em função do Kubernetes com a ID do Microsoft Entra no Serviço Kubernetes do Azure

O Serviço Kubernetes do Azure (AKS) pode ser configurado para usar o Microsoft Entra ID para autenticação do usuário. Nessa configuração, você entra em um cluster AKS usando um token de autenticação do Microsoft Entra. Depois de autenticado, você pode usar o controle de acesso baseado em função do Kubernetes interno (Kubernetes RBAC) para gerenciar o acesso a namespaces e recursos de cluster com base na identidade de um usuário ou na associação ao grupo.

Este artigo mostra-lhe como:

• Controle o acesso usando o Kubernetes RBAC em um cluster AKS com base na associação ao grupo Microsoft Entra.
• Crie grupos e usuários de exemplo no Microsoft Entra ID.
• Crie Roles e RoleBindings em um cluster AKS para conceder as permissões apropriadas para criar e exibir recursos.

Antes de começar

• Você tem um cluster AKS existente com a integração do Microsoft Entra habilitada. Se precisar de um cluster AKS com esta configuração, consulte Integrar o Microsoft Entra ID com o AKS.
• O RBAC do Kubernetes é ativado por padrão durante a criação do cluster AKS. Para atualizar seu cluster com a integração do Microsoft Entra e o Kubernetes RBAC, habilite a integração do Microsoft Entra em seu cluster AKS existente.
• Certifique-se de que a CLI do Azure versão 2.0.61 ou posterior está instalada e configurada. Executar az --version para localizar a versão. Se precisar de instalar ou atualizar, veja Install Azure CLI (Instalar o Azure CLI).
• Se estiver usando o Terraform, instale o Terraform versão 2.99.0 ou posterior.

Use o portal do Azure ou a CLI do Azure para verificar se a integração do Microsoft Entra com o RBAC do Kubernetes está habilitada.

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

Criar grupos de demonstração no Microsoft Entra ID

Neste artigo, criaremos duas funções de usuário para mostrar como o Kubernetes RBAC e o Microsoft Entra ID controlam o acesso aos recursos do cluster. As duas funções de exemplo a seguir são usadas:

• Desenvolvedor de aplicativos
  • Um usuário chamado aksdev que faz parte do grupo appdev .
• Engenheiro de confiabilidade do site
  • Um usuário chamado akssre que faz parte do grupo opssre .

Em ambientes de produção, você pode usar usuários e grupos existentes em um locatário do Microsoft Entra.

1. Primeiro, obtenha o ID do recurso do seu cluster AKS usando o az aks show comando. Em seguida, atribua o ID do recurso a uma variável chamada AKS_ID para que ela possa ser referenciada em outros comandos.

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

2. Crie o primeiro grupo de exemplo no Microsoft Entra ID para os desenvolvedores de aplicativos usando o az ad group create comando. O exemplo a seguir cria um grupo chamado appdev:

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

3. Crie uma atribuição de função do Azure para o grupo appdev usando o az role assignment create comando. Essa atribuição permite que qualquer membro do grupo use kubectl para interagir com um cluster AKS, concedendo-lhes a Função de Usuário do Cluster de Serviço Kubernetes do Azure.

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

4. Crie um segundo grupo de exemplo para SREs chamado opssre.

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

5. Crie uma atribuição de função do Azure para conceder aos membros do grupo a Função de Usuário do Cluster de Serviço Kubernetes do Azure.

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

Criar usuários de demonstração no Microsoft Entra ID

Agora que temos dois grupos de exemplo criados no Microsoft Entra ID para nossos desenvolvedores de aplicativos e SREs, criaremos dois usuários de exemplo. Para testar a integração do Kubernetes RBAC no final do artigo, você entrará no cluster AKS com essas contas.

Definir o nome principal do usuário e a senha para desenvolvedores de aplicativos

Defina o nome principal do usuário (UPN) e a senha para os desenvolvedores de aplicativos. O UPN deve incluir o nome de domínio verificado do seu locatário, por exemplo aksdev@contoso.com.

O comando a seguir solicita o UPN e o define como AAD_DEV_UPN para que possa ser usado em um comando posterior:

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

O comando a seguir solicita a senha e a define como AAD_DEV_PW para uso em um comando posterior:

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

Criar as contas de utilizador

1. Crie a primeira conta de usuário no Microsoft Entra ID usando o az ad user create comando. O exemplo a seguir cria um usuário com o nome de exibição AKS Dev e UPN e senha segura usando os valores em AAD_DEV_UPN e 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. Adicione o usuário ao grupo appdev criado na seção anterior usando o az ad group member add comando.

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

3. Defina o UPN e a senha para SREs. O UPN deve incluir o nome de domínio verificado do seu locatário, por exemplo akssre@contoso.com. O comando a seguir solicita o UPN e o define como AAD_SRE_UPN para uso em um comando posterior:

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

4. O comando a seguir solicita a senha e a define como AAD_SRE_PW para uso em um comando posterior:

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

5. Crie uma segunda conta de usuário. O exemplo a seguir cria um usuário com o nome de exibição AKS SRE e UPN e senha segura usando os valores em AAD_SRE_UPN e 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 Azure AD group
az ad group member add --group opssre --member-id $AKSSRE_ID

Criar recursos de cluster AKS para desenvolvedores de aplicativos

Temos nossos grupos do Microsoft Entra, usuários e atribuições de função do Azure criados. Agora, vamos configurar o cluster AKS para permitir que esses diferentes grupos acessem recursos específicos.

1. Obtenha as credenciais de administrador do cluster usando o az aks get-credentials comando. Em uma das seções a seguir, você obtém as credenciais de cluster de usuário regular para ver o fluxo de autenticação do Microsoft Entra em ação.

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

2. Crie um namespace no cluster AKS usando o kubectl create namespace comando. O exemplo a seguir cria um dev de nome de namespace:

kubectl create namespace dev

3. Crie uma Função para o namespace dev , que concede permissões totais ao namespace. Em ambientes de produção, você pode especificar permissões mais granulares para diferentes usuários ou grupos. Crie um arquivo chamado role-dev-namespace.yaml e cole o seguinte manifesto YAML:

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. Crie a função usando o kubectl apply comando e especifique o nome do arquivo do seu manifesto YAML.

kubectl apply -f role-dev-namespace.yaml

5. Obtenha o ID do recurso para o grupo appdev usando o az ad group show comando. Este grupo é definido como o assunto de um RoleBinding na próxima etapa.

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

6. Crie um RoleBinding para o grupo appdev para usar a Função criada anteriormente para acesso ao namespace. Crie um arquivo chamado rolebinding-dev-namespace.yaml e cole o seguinte manifesto YAML. Na última linha, substitua groupObjectId pela saída de ID do objeto de grupo do comando anterior.

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

7. Crie o RoleBinding usando o kubectl apply comando e especifique o nome do arquivo do seu manifesto YAML:

kubectl apply -f rolebinding-dev-namespace.yaml

Criar os recursos de cluster AKS para SREs

Agora, repetiremos as etapas anteriores para criar um namespace, Role e RoleBinding para os SREs.

1. Crie um namespace para sre usando o kubectl create namespace comando.

kubectl create namespace sre

2. Crie um arquivo chamado role-sre-namespace.yaml e cole o seguinte manifesto YAML:

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. Crie a função usando o kubectl apply comando e especifique o nome do arquivo do seu manifesto YAML.

kubectl apply -f role-sre-namespace.yaml

4. Obtenha o ID do recurso para o grupo opssre usando o comando az ad group show .

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

4. Crie um RoleBinding para o grupo opssre para usar a Função criada anteriormente para acesso ao namespace. Crie um arquivo chamado rolebinding-sre-namespace.yaml e cole o seguinte manifesto YAML. Na última linha, substitua groupObjectId pela saída de ID do objeto de grupo do comando anterior.

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

5. Crie o RoleBinding usando o kubectl apply comando e especifique o nome do arquivo do seu manifesto YAML.

kubectl apply -f rolebinding-sre-namespace.yaml

Interagir com recursos de cluster usando identidades do Microsoft Entra

Agora, testaremos se as permissões esperadas funcionam quando você cria e gerencia recursos em um cluster AKS. Nesses exemplos, agendaremos e exibiremos pods no namespace atribuído pelo usuário e tentaremos agendar e exibir pods fora do namespace atribuído.

1. Redefina o contexto kubeconfig usando o az aks get-credentials comando. Em uma seção anterior, você define o contexto usando as credenciais de administrador do cluster. O usuário administrador ignora os prompts de entrada do Microsoft Entra. Sem o parâmetro, é aplicado o contexto de usuário que requer que todas as solicitações sejam autenticadas usando o --admin Microsoft Entra ID.

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

2. Agende um pod NGINX básico usando o kubectl run comando no namespace dev .

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

3. Insira as credenciais da sua própria appdev@contoso.com conta criada no início do artigo como o prompt de entrada. Depois que você entrar com êxito, o token da conta será armazenado em cache para comandos futuros kubectl . O NGINX é agendado com êxito, conforme mostrado na saída de exemplo a seguir:

$ 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. Use o kubectl get pods comando para exibir pods no namespace dev .

kubectl get pods --namespace dev

5. Verifique se o status do pod NGINX está em execução. A saída será semelhante à seguinte saída:

$ kubectl get pods --namespace dev

NAME        READY   STATUS    RESTARTS   AGE
nginx-dev   1/1     Running   0          4m

Criar e exibir recursos de cluster fora do namespace atribuído

Tente visualizar pods fora do namespace dev . Use o kubectl get pods comando novamente, desta vez para ver --all-namespaces.

kubectl get pods --all-namespaces

A associação ao grupo do usuário não tem uma Função Kubernetes que permita essa ação, conforme mostrado na saída de exemplo a seguir:

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

Da mesma forma, tente agendar um pod em um namespace diferente, como o namespace sre . A associação de grupo do usuário não se alinha com uma Função do Kubernetes e RoleBinding para conceder essas permissões, conforme mostrado na saída de exemplo a seguir:

$ 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"

Testar o acesso SRE aos recursos do cluster AKS

Para confirmar se nossa associação ao grupo Microsoft Entra e o RBAC do Kubernetes funcionam corretamente entre diferentes usuários e grupos, tente os comandos anteriores quando estiver conectado como o usuário opssre .

1. Redefina o contexto kubeconfig usando o az aks get-credentials comando que limpa o token de autenticação armazenado anteriormente em cache para o usuário aksdev .

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

2. Tente agendar e visualizar pods no namespace sre atribuído. Quando solicitado, entre com suas próprias opssre@contoso.com credenciais criadas no início do artigo.

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

Como mostrado na saída de exemplo a seguir, você pode criar e visualizar com êxito os pods:

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

3. To sign in, use a web browser to open the page https://microsoft.com/devicelogin and enter the code BM4RHP3FD to authenticate.

pod/nginx-sre created

$ kubectl get pods --namespace sre

NAME        READY   STATUS    RESTARTS   AGE
nginx-sre   1/1     Running   0

4. Tente exibir ou agendar pods fora do namespace SRE atribuído.

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

Esses kubectl comandos falham, conforme mostrado na saída de exemplo a seguir. A associação de grupo do usuário e a Função e RoleBindings do Kubernetes não concedem permissões para criar ou gerenciar recursos em outros namespaces.

$ 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"

Clean up resources (Limpar recursos)

Neste artigo, você criou recursos no cluster AKS e usuários e grupos no Microsoft Entra ID. Para limpar todos os recursos, execute os seguintes comandos:

# 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

Próximos passos

• Para obter mais informações sobre como proteger clusters Kubernetes, consulte Opções de acesso e identidade para AKS.

• Para obter as melhores práticas sobre controle de identidade e recursos, consulte Práticas recomendadas para autenticação e autorização no AKS.