Controle 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 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 Kubernetes 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 descreve como controlar o acesso usando o Kubernetes RBAC em um cluster Kubernetes com base na associação do grupo Microsoft Entra no AKS Arc. Criar um grupo de demonstração e usuários no Microsoft Entra ID. 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 Kubernetes RBAC usando o Microsoft Entra ID, você precisa dos seguintes pré-requisitos:

Um cluster Kubernetes criado no AKS Arc. Se você precisar configurar seu 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 seu cluster Kubernetes. Para obter informações sobre como habilitar o Azure Arc, consulte Conectar um serviço Kubernetes do Azure no cluster local do Azure ao Kubernetes habilitado para Azure Arc.
Você precisa acessar as 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 sua versão do cliente kubectl é 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 entre plataformas 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 Kubernetes de qualquer lugar com um modo proxy usando az connectedk8s proxy o comando, você precisa da Microsoft.Kubernetes/connectedClusters/listClusterUserCredential/action, que está incluída na permissão de função Usuário do Cluster Kubernetes habilitado para Arco do Azure. Enquanto isso, você precisa verificar se os agentes e a máquina que executa o processo de integração atendem aos requisitos de rede nos requisitos de rede do Kubernetes habilitado para Azure Arc.

Primeiros passos opcionais

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

Para demonstrar o trabalho com o Microsoft Entra ID e o Kubernetes RBAC, você pode criar um grupo do Microsoft Entra para desenvolvedores de aplicativos que pode ser usado para mostrar como o RBAC do Kubernetes e o 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 no Microsoft Entra ID

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

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

Adicionar utilizadores ao seu grupo

Com o grupo de exemplo criado no Microsoft Entra ID para desenvolvedores de aplicativos, adicione um usuário ao appdev grupo. Você usa essa conta de usuário para entrar no cluster AKS e testar a integração 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 ligação de função RBAC do Kubernetes personalizada no recurso de cluster AKS para o grupo Microsoft Entra

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

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, Roles define as permissões a serem concedidas e RoleBindings aplica 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, consulte Usando a autorização RBAC do Kubernetes.

Crie uma função para o namespace dev . Essa função concede permissões totais ao namespace. Em ambientes de produção, convém 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 kubectl apply comando e especifique o nome do arquivo do seu manifesto YAML:
```
kubectl apply -f role-dev-namespace.yaml
```
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 objectId -o tsv
```
O az ad group show comando retorna o valor usado como :groupObjectId
```
38E5FA30-XXXX-4895-9A00-050712E3673A
```
Crie um arquivo chamado rolebinding-dev-namespace.yaml e copie/cole o seguinte manifesto YAML. Você estabelece a associação de função que permite que o grupo appdev use a função para acesso ao role-dev-namespace namespace. Na última linha, substitua groupObjectId pelo ID do az ad group show objeto de grupo produzido pelo 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
```
Gorjeta

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

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

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

Use funções RBAC do Kubernetes integradas para seu recurso de cluster 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 dentro de namespaces específicos usando RoleBindings (admin, edit, view)

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

Funções voltadas para o usuário

ClusterRole padrão	ClusterRoleBinding padrão	Description
cluster-admin	sistema:grupo de mestres	Permite o acesso de superusuário, para executar qualquer ação em qualquer recurso. Quando usada em um ClusterRoleBinding, essa função dá controle total sobre todos os recursos no cluster e em todos os namespaces. Quando usado em um RoleBinding, ele dá controle total sobre todos os recursos no namespace da associação de função, incluindo o namespace em si.
administração	Nenhuma	Permite acesso de administrador, destinado a ser concedido dentro de 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 namespace em si. 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.
Editar…	Nenhuma	Permite acesso de leitura/gravação à maioria dos objetos em um namespace. Esta função não permite visualizar ou modificar funções ou associações de funções. 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.
ver	Nenhuma	Permite acesso somente leitura para ver a maioria dos objetos em um namespace. Ele não permite a visualização de funções ou associações de funções. Essa função não permite a exibição de segredos, uma vez que 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 do Kubernetes integrada com o ID do Microsoft Entra

Para usar uma função RBAC interna do Kubernetes com o Microsoft Entra ID, 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 visualiza pods no namespace atribuído ao usuário. Em seguida, tente agendar e exibir pods fora do namespace atribuído.

Entre no Azure usando a $AKSDEV_ID conta de 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 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 é agendado com êxito, você deve ver a seguinte saída:
```
pod/nginx-dev created
```
Agora, use o kubectl get pods comando para exibir pods no dev namespace:
```
kubectl get pods --namespace dev
```
Quando o NGINX é executado com êxito, você deve 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 ao 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óximos passos

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

Partilhar via