Controlar o acesso usando o Microsoft Entra ID e o Kubernetes RBAC para Windows Server

Artigo
08/10/2024

Aplica-se a: AKS no Azure Stack HCI 22H2, AKS no Windows Server

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

Este artigo descreve como controlar o acesso usando o RBAC do Kubernetes em um cluster do Kubernetes com base na associação de grupo do Microsoft Entra no AKS Arc. Você cria um grupo de demonstração e usuários na ID do Microsoft Entra. Em seguida, você cria funções e associações de função no cluster para conceder as permissões apropriadas para criar e exibir recursos.

Pré-requisitos

Antes de configurar o RBAC do Kubernetes usando a ID do Microsoft Entra, você precisa dos seguintes pré-requisitos:

Um cluster do Kubernetes criado no AKS Arc. Se você precisar configurar o cluster, consulte as instruções para usar o Windows Admin Center ou o PowerShell para implantar o AKS.
Conexão do Azure Arc. Você deve ter uma conexão do Azure Arc com o cluster do Kubernetes. Para obter informações sobre como habilitar o Azure Arc, consulte Conectar um Serviço de Kubernetes do Azure no cluster do Azure Stack HCI ao Kubernetes habilitado para Azure Arc.
Você precisa de acesso às seguintes ferramentas de linha de comando:
- CLI do Azure e a extensão connectedk8s. A CLI do Azure é um conjunto de comandos usados para criar e gerenciar recursos do Azure. Para verificar se você tem a CLI do Azure, abra uma ferramenta de linha de comando e digite: az -v. Além disso, instale a extensão connectedk8s para abrir um canal para o cluster do Kubernetes. Para obter instruções de instalação, consulte Como instalar a CLI do Azure.
- Kubectl. Essa ferramenta de linha de comando do Kubernetes permite que você execute comandos direcionados aos clusters do Kubernetes. Para verificar se você instalou o kubectl, abra um prompt de comando e digite: kubectl version --client. Certifique-se de que a versão do cliente kubectl seja pelo menos a versão v1.24.0. Para obter instruções de instalação, consulte kubectl.
- PowerShell e o módulo AksHci PowerShell. O PowerShell é uma solução de automação de tarefas multiplataforma composta por um shell de linha de comando, uma linguagem de script e uma estrutura de gerenciamento de configuração. Se você instalou o AKS Arc, terá acesso ao módulo AksHci PowerShell.
- Para acessar o cluster do Kubernetes de qualquer lugar com um modo proxy usando az connectedk8s proxy o comando, você precisa do Microsoft.Kubernetes/connectedClusters/listClusterUserCredential/action, que está incluído na permissão de função Usuário de Cluster do Kubernetes habilitado para Azure Arc. Enquanto isso, você precisa verificar se os agentes e o computador que executa o processo de integração atendem aos requisitos de rede nos requisitos de rede do Kubernetes habilitados para Azure Arc.

Primeiros passos opcionais

Se você ainda não tiver um grupo do Microsoft Entra que contenha membros, talvez queira criar um grupo e adicionar alguns membros, para que possa seguir as instruções neste artigo.

Para demonstrar o trabalho com a ID do Microsoft Entra e o RBAC do Kubernetes, você pode criar um grupo do Microsoft Entra para desenvolvedores de aplicativos que pode ser usado para mostrar como o RBAC do Kubernetes e a ID do Microsoft Entra controlam o acesso aos recursos do cluster. Em ambientes de produção, você pode usar usuários e grupos existentes em um locatário do Microsoft Entra.

Criar um grupo de demonstração na ID do Microsoft Entra

Primeiro, crie o grupo na ID do Microsoft Entra em seu locatário para os desenvolvedores de aplicativos usando o az ad group create comando. O exemplo a seguir solicita que você entre no locatário do Azure e crie um grupo chamado appdev:

az login
az ad group create --display-name appdev --mail-nickname appdev

Adicionar usuários ao seu grupo

Com o grupo de exemplo criado na ID do Microsoft Entra para desenvolvedores de aplicativos, adicione um usuário ao appdev grupo. Use essa conta de usuário para entrar no cluster do AKS e testar a integração do RBAC do Kubernetes.

Adicione um usuário ao grupo appdev criado na seção anterior usando o az ad group member add comando. Se você sair da sessão, reconecte-se ao Azure usando az logino .

$AKSDEV_ID = az ad user create --display-name <name> --password <strongpassword> --user-principal-name <name>@contoso.onmicrosoft.com
az ad group member add --group appdev --member-id $AKSDEV_ID

Criar uma associação de função RBAC do Kubernetes personalizada no recurso de cluster do AKS para o grupo do Microsoft Entra

Configure o cluster do AKS para permitir que o grupo do Microsoft Entra acesse o cluster. Se você quiser adicionar um grupo e usuários, consulte Criar grupos de demonstração na ID do Microsoft Entra.

Obtenha as credenciais de administrador do cluster usando o Get-AksHciCredential comando:
```
Get-AksHciCredential -name <name-of-your-cluster>
```
Crie um namespace no cluster do Kubernetes usando o kubectl create namespace comando. O exemplo a seguir cria um namespace chamado dev:
```
kubectl create namespace dev
```
No Kubernetes, as funções definem as permissões a serem concedidas e as RoleBindings aplicam as permissões aos usuários ou grupos desejados. Essas atribuições podem ser aplicadas a um determinado namespace ou em um cluster inteiro. Para obter mais informações, confira Usar a autorização do RBAC para Kubernetes.

Crie uma função para o namespace dev . Essa função concede permissões completas para o namespace. Em ambientes de produção, talvez você queira especificar permissões mais granulares para diferentes usuários ou grupos.

Crie um arquivo chamado role-dev-namespace.yaml e copie/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: ["*"]

Crie a função usando o comando e especifique o nome do arquivo do manifesto kubectl apply YAML:
```
kubectl apply -f role-dev-namespace.yaml
```
Obtenha a ID do recurso do grupo appdev usando o comando az ad group show. Esse grupo é definido como o assunto de um RoleBinding na próxima etapa:
```
az ad group show --group appdev --query objectId -o tsv
```
O az ad group show comando retorna o valor que você usa como :groupObjectId
```
38E5FA30-XXXX-4895-9A00-050712E3673A
```
Crie um arquivo chamado rolebinding-dev-namespace.yaml e copie/cole o manifesto YAML a seguir. Você estabelece a associação de função que permite que o grupo appdev use a role-dev-namespace função para acesso ao namespace. Na última linha, substitua groupObjectId pelo ID do objeto de grupo produzido pelo az ad group show comando:
```
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
```
Dica

Se você quiser criar o RoleBinding para um único usuário, especifique kind: User e substitua groupObjectId pelo nome UPN (nome UPN) no exemplo.

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

kubectl apply -f rolebinding-dev-namespace.yaml

rolebinding.rbac.authorization.k8s.io/dev-user-access created

Usar funções RBAC internas do Kubernetes para o recurso de cluster do AKS

O Kubernetes também fornece funções internas voltadas para o usuário. Essas funções internas incluem:

Funções de superusuário (administrador de cluster)
Funções destinadas a serem concedidas em todo o cluster usando ClusterRoleBindings
Funções destinadas a serem concedidas em namespaces específicos usando RoleBindings (admin, edit, view)

Para obter mais informações sobre funções RBAC do Kubernetes integradas, consulte Funções voltadas para o usuário do Kubernetes RBAC.

Funções voltadas para o usuário

ClusterRole padrão	ClusterRoleBinding padrão	Descrição
administrador de cluster	Sistema:Grupo de Mestres	Permite o acesso de superusuários, para executar qualquer ação em qualquer recurso. Quando usada em um ClusterRoleBinding, essa função fornece controle total sobre todos os recursos no cluster e em todos os namespaces. Quando usado em um RoleBinding, ele fornece controle total sobre todos os recursos no namespace da associação de função, incluindo o próprio namespace.
admin	Nenhum	Permite o acesso de administrador, destinado a ser concedido em um namespace usando uma associação de função. Se usado em uma associação de função, permite acesso de leitura/gravação à maioria dos recursos em um namespace, incluindo a capacidade de criar funções e associações de função dentro do namespace. Essa função não permite acesso de gravação à cota de recursos ou ao próprio namespace. Essa função também não permite acesso de gravação a pontos de extremidade em clusters criados usando o Kubernetes v1.22+. Para obter mais informações, consulte Acesso de gravação para pontos de extremidade.
edit	Nenhum	Permite acesso de leitura/gravação à maioria dos objetos em um namespace. Essa função não permite exibir ou modificar funções ou associações de função. No entanto, essa função permite acessar segredos e executar pods como qualquer ServiceAccount no namespace, para que possa ser usada para obter os níveis de acesso à API de qualquer ServiceAccount no namespace. Essa função também não permite acesso de gravação a pontos de extremidade em clusters criados usando o Kubernetes v1.22+. Para obter mais informações, consulte Acesso de gravação para pontos de extremidade.
view	Nenhum	Permite acesso somente leitura para ver a maioria dos objetos em um namespace. Não permite exibir funções nem associações de função. Essa função não permite a exibição de segredos, pois a leitura do conteúdo dos segredos permite o acesso às credenciais ServiceAccount no namespace, o que permitiria o acesso à API como qualquer ServiceAccount no namespace (uma forma de escalonamento de privilégios).

Usar uma função RBAC interna do Kubernetes com a ID do Microsoft Entra

Para usar uma função RBAC interna do Kubernetes com a ID do Microsoft Entra, siga estas etapas:

Aplique a função RBAC interna view do Kubernetes ao seu grupo do Microsoft Entra:

kubectl create clusterrolebinding <name of your cluster role binding> --clusterrole=view --group=<Azure AD group object ID>

Aplique a função RBAC interna view do Kubernetes a cada um dos usuários do Microsoft Entra:

kubectl create clusterrolebinding <name of your cluster role binding> --clusterrole=view --user=<Azure AD user object ID>

Trabalhar com recursos de cluster usando IDs do Microsoft Entra

Agora, teste as permissões esperadas ao criar e gerenciar recursos em um cluster do Kubernetes. Nesses exemplos, você agenda e exibe pods no namespace atribuído do usuário. Em seguida, você tenta agendar e visualizar pods fora do namespace atribuído.

Entre no Azure usando a conta de $AKSDEV_ID usuário que você especificou como uma entrada para o az ad group member add comando. Execute o az connectedk8s proxy comando para abrir um canal para o cluster:
```
az connectedk8s proxy -n <cluster-name> -g <resource-group>
```
Depois que o canal de proxy for estabelecido, abra outra sessão e agende um pod NGINX 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
```
Quando o NGINX for agendado com êxito, você deverá ver a seguinte saída:
```
pod/nginx-dev created
```
Agora, use o kubectl get pods comando para visualizar pods no dev namespace:
```
kubectl get pods --namespace dev
```
Quando o NGINX estiver em execução com êxito, você deverá ver a seguinte saída:
```
NAME        READY   STATUS    RESTARTS   AGE
nginx-dev   1/1     Running   0          4m
```

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

Para tentar visualizar pods fora do namespace dev , use o kubectl get pods comando com o --all-namespaces sinalizador:

kubectl get pods --all-namespaces

A associação de grupo do usuário não tem uma função do Kubernetes que permita essa ação. Sem a permissão, o comando gera um erro:

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

Próximas etapas

Saiba mais sobre segurança no AKS Arc no Windows Server

Compartilhar via