Partilhar via

Usar o RBAC do Azure em clusters Kubernetes habilitados para Azure Arc

  • Artigo

Os tipos de objeto Kubernetes ClusterRoleBinding e RoleBinding ajudam a definir a autorização no Kubernetes nativamente. Usando esse recurso, você pode usar a ID do Microsoft Entra e as atribuições de função no Azure para controlar as verificações de autorização no cluster. As atribuições de função do Azure permitem controlar granularmente quais usuários podem ler, gravar e excluir objetos do Kubernetes, como implantação, pod e serviço.

Para obter uma visão geral conceitual desse recurso, consulte Azure RBAC no Kubernetes habilitado para Azure Arc.

Pré-requisitos

  • Instale ou atualize a CLI do Azure para a versão mais recente.

  • Instale a versão mais recente da extensão CLI do connectedk8s Azure:

    az extension add --name connectedk8s

    Se a connectedk8s extensão já estiver instalada, você poderá atualizá-la para a versão mais recente usando o seguinte comando:

    az extension update --name connectedk8s

  • Ligue um cluster do Kubernetes compatível com o Azure Arc:

Nota

O Azure RBAC não está disponível para ofertas do Red Hat OpenShift ou do Kubernetes gerenciado em que o acesso do usuário ao servidor de API é restrito (por exemplo, Amazon Elastic Kubernetes Service (EKS), Google Kubernetes Engine (GKE)).

Atualmente, o RBAC do Azure não oferece suporte a clusters Kubernetes que operam na arquitetura ARM64. Use o RBAC do Kubernetes para gerenciar o controle de acesso para clusters Kubernetes baseados em ARM64.

Para clusters do Serviço Kubernetes do Azure (AKS), esse recurso está disponível nativamente e não exige que o cluster AKS esteja conectado ao Azure Arc.

Para clusters do Serviço Kubernetes do Azure (AKS) habilitados pelo Azure Arc no Azure Stack HCI 23H2, a habilitação do RBAC do Azure atualmente só é suportada durante a criação do cluster do Kubernetes. Para criar um cluster AKS habilitado pelo Azure Arc com o Azure RBAC habilitado, siga o guia de autorização Usar o RBAC do Azure para Kubernetes. Observe que o RBAC do Azure não tem suporte para o Azure Stack HCI, versão 22H2.

Ativar o RBAC do Azure no cluster

  1. Obtenha a identidade MSI do cluster executando o seguinte comando:

    az connectedk8s show -g <resource-group> -n <connected-cluster-name>

  2. Obtenha a ID (identity.principalId) da saída e execute o seguinte comando para atribuir a função Leitor de CheckAccess de Identidade Gerenciado de Cluster Conectado ao MSI do cluster:

    az role assignment create --role "Connected Cluster Managed Identity CheckAccess Reader" --assignee "<Cluster MSI ID>" --scope <cluster ARM ID>

  3. Habilite o RBAC (controle de acesso baseado em função) do Azure em seu cluster Kubernetes habilitado para Azure Arc executando o seguinte comando:

    az connectedk8s enable-features -n <clusterName> -g <resourceGroupName> --features azure-rbac

    Nota

    Antes de executar o comando anterior, verifique se o kubeconfig arquivo na máquina está apontando para o cluster no qual você habilitará o recurso RBAC do Azure.

    Use --skip-azure-rbac-list com o comando anterior para uma lista separada por vírgulas de nomes de usuário, emails e conexões OpenID que passam por verificações de autorização usando objetos e nativos do Kubernetes em ClusterRoleBinding RoleBinding vez do RBAC do Azure.

Cluster genérico onde nenhum reconciliador está sendo executado na apiserver especificação

  1. SSH em cada nó mestre do cluster e execute as seguintes etapas:

    Se o seu kube-apiserver é um pod estático:

    1. O azure-arc-guard-manifests segredo no kube-system namespace contém dois arquivos: guard-authn-webhook.yaml e guard-authz-webhook.yaml. Copie esses arquivos para o /etc/guard diretório do nó.

      sudo mkdir -p /etc/guard
kubectl get secrets azure-arc-guard-manifests -n kube-system -o json | jq -r '.data."guard-authn-webhook.yaml"' | base64 -d > /etc/guard/guard-authn-webhook.yaml
kubectl get secrets azure-arc-guard-manifests -n kube-system -o json | jq -r '.data."guard-authz-webhook.yaml"' | base64 -d > /etc/guard/guard-authz-webhook.yaml

    2. Abra o manifesto apiserver no modo de edição:

      sudo vi /etc/kubernetes/manifests/kube-apiserver.yaml

    3. Adicione a seguinte especificação em volumes:

      - hostPath
    path: /etc/guard
    type: Directory
name: azure-rbac

    4. Adicione a seguinte especificação em volumeMounts:

      - mountPath: /etc/guard
    name: azure-rbac
    readOnly: true

    Se o seu kube-apiserver não é um pod estático:

    1. Abra o manifesto apiserver no modo de edição:

      sudo vi /etc/kubernetes/manifests/kube-apiserver.yaml

    2. Adicione a seguinte especificação em volumes:

      - name: azure-rbac
    secret:
    secretName: azure-arc-guard-manifests

    3. Adicione a seguinte especificação em volumeMounts:

      - mountPath: /etc/guard
    name: azure-rbac
    readOnly: true

  2. Adicione os seguintes apiserver argumentos:

    - --authentication-token-webhook-config-file=/etc/guard/guard-authn-webhook.yaml
- --authentication-token-webhook-cache-ttl=5m0s
- --authorization-webhook-cache-authorized-ttl=5m0s
- --authorization-webhook-config-file=/etc/guard/guard-authz-webhook.yaml
- --authorization-webhook-version=v1
- --authorization-mode=Node,RBAC,Webhook

    Se o cluster do Kubernetes for a versão 1.19.0 ou posterior, você também precisará definir o seguinte apiserver argumento:

    - --authentication-token-webhook-version=v1

  3. Salve e feche o editor para atualizar o apiserver pod.

Cluster criado usando a API de Cluster

  1. Copie o segredo de proteção que contém arquivos de configuração de webhook de autenticação e autorização do cluster de carga de trabalho para sua máquina:

    kubectl get secret azure-arc-guard-manifests -n kube-system -o yaml > azure-arc-guard-manifests.yaml

  2. Altere o namespace campo no arquivo azure-arc-guard-manifests.yaml para o namespace dentro do cluster de gerenciamento onde você está aplicando os recursos personalizados para a criação de clusters de carga de trabalho.

  3. Aplique este manifesto:

    kubectl apply -f azure-arc-guard-manifests.yaml

  4. Edite o KubeadmControlPlane objeto executando kubectl edit kcp <clustername>-control-plane:

    1. Adicione o seguinte trecho em files:

      - contentFrom:
    secret:
      key: guard-authn-webhook.yaml
      name: azure-arc-guard-manifests
  owner: root:root
  path: /etc/kubernetes/guard-authn-webhook.yaml
  permissions: "0644"
- contentFrom:
    secret:
      key: guard-authz-webhook.yaml
      name: azure-arc-guard-manifests
  owner: root:root
  path: /etc/kubernetes/guard-authz-webhook.yaml
  permissions: "0644"

    2. Adicione o seguinte trecho em apiServer>extraVolumes:

      - hostPath: /etc/kubernetes/guard-authn-webhook.yaml
    mountPath: /etc/guard/guard-authn-webhook.yaml
    name: guard-authn
    readOnly: true
- hostPath: /etc/kubernetes/guard-authz-webhook.yaml
    mountPath: /etc/guard/guard-authz-webhook.yaml
    name: guard-authz
    readOnly: true

    3. Adicione o seguinte trecho em apiServer>extraArgs:

      authentication-token-webhook-cache-ttl: 5m0s
authentication-token-webhook-config-file: /etc/guard/guard-authn-webhook.yaml
authentication-token-webhook-version: v1
authorization-mode: Node,RBAC,Webhook
authorization-webhook-cache-authorized-ttl: 5m0s
authorization-webhook-config-file: /etc/guard/guard-authz-webhook.yaml
authorization-webhook-version: v1

    4. Salve e feche para atualizar o KubeadmControlPlane objeto. Aguarde até que essas alterações apareçam no cluster de carga de trabalho.

Criar atribuições de funções para os utilizadores acederem ao cluster

Os proprietários do recurso Kubernetes habilitado para Azure Arc podem usar funções internas ou funções personalizadas para conceder a outros usuários acesso ao cluster do Kubernetes.

Funções incorporadas

Função Description
Azure Arc Kubernetes Viewer Permite acesso somente leitura para ver a maioria dos objetos em um namespace. Essa função não permite a exibição de segredos, porque read a permissão em segredos permitiria o acesso a ServiceAccount credenciais no namespace. Essas credenciais, por sua vez, permitiriam o acesso à API por meio desse ServiceAccount valor (uma forma de escalonamento de privilégios).
Azure Arc Kubernetes Writer 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 valor no namespace, para que possa ser usada para obter os níveis de acesso à API de qualquer ServiceAccount valor no namespace.
Azure Arc Kubernetes Admin Permite acesso de administrador. Destina-se a ser concedido dentro de um namespace por meio RoleBindingdo . Se você usá-lo no RoleBinding, ele permitirá 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.
Azure Arc Kubernetes Cluster Admin Permite o acesso de superusuário para executar qualquer ação em qualquer recurso. Quando você o usa no ClusterRoleBinding, ele dá controle total sobre todos os recursos no cluster e em todos os namespaces. Quando você o usa no RoleBinding, ele dá controle total sobre todos os recursos no namespace da associação de função, incluindo o namespace em si.

Você pode criar atribuições de função com escopo para o cluster Kubernetes habilitado para Azure Arc no portal do Azure no painel Controle de Acesso (IAM) do recurso de cluster. Você também pode usar os seguintes comandos da CLI do Azure:

az role assignment create --role "Azure Arc Kubernetes Cluster Admin" --assignee <AZURE-AD-ENTITY-ID> --scope $ARM_ID

Nesses comandos, AZURE-AD-ENTITY-ID pode ser um nome de usuário (por exemplo, testuser@mytenant.onmicrosoft.com) ou até mesmo o appId valor de uma entidade de serviço.

Aqui está outro exemplo de criação de uma atribuição de função com escopo para um namespace específico dentro do cluster:

az role assignment create --role "Azure Arc Kubernetes Viewer" --assignee <AZURE-AD-ENTITY-ID> --scope $ARM_ID/namespaces/<namespace-name>

Nota

Você pode criar atribuições de função com escopo para o cluster usando o portal do Azure ou a CLI do Azure. No entanto, somente a CLI do Azure pode ser usada para criar atribuições de função com escopo para namespaces.

Funções personalizadas

Você pode optar por criar sua própria definição de função para uso em atribuições de função.

Percorra o exemplo a seguir de uma definição de função que permite que um usuário leia apenas implantações. Para obter mais informações, consulte a lista completa de ações de dados que você pode usar para construir uma definição de função.

Copie o seguinte objeto JSON em um arquivo chamado custom-role.json. Substitua o espaço reservado <subscription-id> pela ID de assinatura real. A função personalizada usa uma das ações de dados e permite exibir todas as implantações no escopo (cluster ou namespace) onde a atribuição de função é criada.

{
    "Name": "Arc Deployment Viewer",
    "Description": "Lets you view all deployments in cluster/namespace.",
    "Actions": [],
    "NotActions": [],
    "DataActions": [
        "Microsoft.Kubernetes/connectedClusters/apps/deployments/read"
    ],
    "NotDataActions": [],
    "assignableScopes": [
        "/subscriptions/<subscription-id>"
    ]
}

  1. Crie a definição de função executando o seguinte comando da pasta onde você salvou custom-role.json:

    az role definition create --role-definition @custom-role.json

  2. Crie uma atribuição de função usando esta definição de função personalizada:

    az role assignment create --role "Arc Deployment Viewer" --assignee <AZURE-AD-ENTITY-ID> --scope $ARM_ID/namespaces/<namespace-name>

Configurar kubectl com credenciais de usuário

Há duas maneiras de obter o arquivo kubeconfig necessário para acessar o cluster:

  • Use o recurso cluster Connect (az connectedk8s proxy) do cluster Kubernetes habilitado para Azure Arc.
  • O administrador do cluster compartilha o arquivo kubeconfig com todos os outros usuários.

Usar conexão de cluster

Execute o seguinte comando para iniciar o processo de proxy:

az connectedk8s proxy -n <clusterName> -g <resourceGroupName>

Depois que o processo de proxy estiver em execução, você poderá abrir outra guia no console para começar a enviar suas solicitações para o cluster.

Usar um arquivo kubeconfig compartilhado

Usar um kubeconfig compartilhado requer etapas ligeiramente diferentes, dependendo da sua versão do Kubernetes.

  1. Execute o seguinte comando para definir as credenciais para o usuário. Especificar serverApplicationId como 6256c85f-0aad-4d50-b960-e6e9b21efe35 e clientApplicationId como 3f4439ff-e698-4d6d-84fe-09c9d574f06b:

    kubectl config set-credentials <testuser>@<mytenant.onmicrosoft.com> \
--auth-provider=azure \
--auth-provider-arg=environment=AzurePublicCloud \
--auth-provider-arg=client-id=<clientApplicationId> \
--auth-provider-arg=tenant-id=<tenantId> \
--auth-provider-arg=apiserver-id=<serverApplicationId>

  2. Abra o arquivo kubeconfig que você criou anteriormente. Em contexts, verifique se o contexto associado ao cluster aponta para as credenciais de usuário que você criou na etapa anterior. Para definir o contexto atual para essas credenciais de usuário, execute o seguinte comando:

    kubectl config set-context --current=true --user=<testuser>@<mytenant.onmicrosoft.com>

  3. Adicione a configuração do modo de configuração em user>config:

    name: testuser@mytenant.onmicrosoft.com
user:
    auth-provider:
    config:
        apiserver-id: $SERVER_APP_ID
        client-id: $CLIENT_APP_ID
        environment: AzurePublicCloud
        tenant-id: $TENANT_ID
        config-mode: "1"
    name: azure

    Nota

    Exec plugin é uma estratégia de autenticação Kubernetes que permite kubectl executar um comando externo para receber credenciais de usuário para enviar para apiserver. A partir do Kubernetes versão 1.26, o plug-in de autorização padrão do Azure não está mais incluído no client-go e kubectl. Com versões posteriores, para usar o plug-in exec para receber credenciais de usuário, você deve usar o Azure Kubelogin, um client-go plug-in de credencial (exec) que implementa a autenticação do Azure.

  4. Instale o Azure Kubelogin:

    • Para Windows ou Mac, siga as instruções de instalação do Kubelogin do Azure.

    • Para Linux ou Ubuntu, baixe a versão mais recente do kubelogin e execute os seguintes comandos:

      curl -LO https://github.com/Azure/kubelogin/releases/download/"$KUBELOGIN_VERSION"/kubelogin-linux-amd64.zip 

unzip kubelogin-linux-amd64.zip 

sudo mv bin/linux_amd64/kubelogin /usr/local/bin/ 

sudo chmod +x /usr/local/bin/kubelogin

  5. O Kubelogin pode ser usado para autenticar com clusters habilitados para Azure Arc solicitando um token de prova de posse (PoP). Converta o kubeconfig usando kubelogin para usar o modo de login apropriado. Por exemplo, para login de código de dispositivo com um usuário do Microsoft Entra, os comandos seriam os seguintes:

    export KUBECONFIG=/path/to/kubeconfig

kubelogin convert-kubeconfig --pop-enabled --pop-claims 'u=<ARM ID of cluster>"

Enviar solicitações para o cluster

  1. Execute qualquer kubectl comando. Por exemplo:

    • kubectl get nodes
    • kubectl get pods

  2. Depois que for solicitada a autenticação baseada em navegador, copie o URL de login do dispositivo (https://microsoft.com/devicelogin) e abra-o no navegador da Web.

  3. Introduza o código impresso na consola. Copie e cole o código no seu terminal no prompt de entrada de autenticação do dispositivo.

  4. Introduza o nome de utilizador (testuser@mytenant.onmicrosoft.com) e a palavra-passe associada.

  5. Se vir uma mensagem de erro como esta, significa que não está autorizado a aceder ao recurso solicitado:

    Error from server (Forbidden): nodes is forbidden: User "testuser@mytenant.onmicrosoft.com" cannot list resource "nodes" in API group "" at the cluster scope: User doesn't have access to the resource in Azure. Update role assignment to allow access.

    Um administrador precisa criar uma nova atribuição de função que autorize esse usuário a ter acesso ao recurso.

Usar o Acesso Condicional com o ID do Microsoft Entra

Ao integrar a ID do Microsoft Entra com seu cluster Kubernetes habilitado para Azure Arc, você também pode usar o Acesso Condicional para controlar o acesso ao cluster.

Nota

O Acesso Condicional do Microsoft Entra é um recurso P2 do Microsoft Entra ID.

Para criar um exemplo de política de Acesso Condicional para usar com o cluster:

  1. Na parte superior do portal do Azure, procure e selecione Microsoft Entra ID.

  2. No menu do Microsoft Entra ID no lado esquerdo, selecione Aplicativos corporativos.

  3. No menu para aplicações empresariais no lado esquerdo, selecione Acesso Condicional.

  4. No menu Acesso Condicional, no lado esquerdo, selecione Políticas>Nova política.

    Captura de ecrã a mostrar como adicionar uma política de acesso condicional no portal do Azure.

  5. Insira um nome para a política, como arc-k8s-policy.

  6. Selecionar Utilizadores e grupos. Em Incluir, escolha Selecionar usuários e grupos. Em seguida, escolha os usuários e grupos onde deseja aplicar a política. Para este exemplo, escolha o mesmo grupo do Microsoft Entra que tem acesso administrativo ao cluster.

    Captura de ecrã que mostra a seleção de utilizadores ou grupos para aplicar a política de Acesso Condicional.

  7. Selecione Aplicações na cloud ou ações. Em Incluir, escolha Selecionar aplicativos. Em seguida, procure e selecione o aplicativo de servidor que você criou anteriormente.

    Captura de tela mostrando como selecionar um aplicativo de servidor no portal do Azure.

  8. Em Controles de acesso, selecione Conceder. Selecione Conceder acesso Exigir que>o dispositivo seja marcado como compatível.

    Captura de ecrã a mostrar como permitir apenas dispositivos compatíveis no portal do Azure.

  9. Em Ativar política, selecione Ao>criar.

    Captura de ecrã a mostrar como ativar uma política de acesso condicional no portal do Azure.

Acesse o cluster novamente. Por exemplo, execute o kubectl get nodes comando para exibir nós no cluster:

kubectl get nodes

Siga as instruções para iniciar sessão novamente. Uma mensagem de erro indica que você está conectado com êxito, mas o administrador exige que o dispositivo que está solicitando acesso seja gerenciado pela ID do Microsoft Entra para acessar o recurso. Siga estes passos:

  1. No portal do Azure, vá para Microsoft Entra ID.

  2. Selecione Aplicações empresariais. Em seguida, em Atividade, selecione Entrar.

  3. Uma entrada na parte superior mostra Falha para Status e Sucesso para Acesso Condicional. Selecione a entrada e, em seguida, selecione Acesso condicional em Detalhes. Observe que sua política de Acesso Condicional está listada.

    Captura de ecrã a mostrar uma entrada de início de sessão com falha no portal do Azure.

Configurar o acesso ao cluster just-in-time com o Microsoft Entra ID

Outra opção para o controle de acesso ao cluster é usar o Privileged Identity Management (PIM) para solicitações just-in-time.

Nota

O Microsoft Entra PIM é um recurso do Microsoft Entra ID P2. Para obter mais informações sobre as SKUs do Microsoft Entra ID, consulte o guia de preços.

Para configurar solicitações de acesso just-in-time para seu cluster, conclua as seguintes etapas:

  1. Na parte superior do portal do Azure, procure e selecione Microsoft Entra ID.

  2. Anote o ID do inquilino. Para o restante dessas instruções, nos referiremos a essa ID como <tenant-id>.

    Captura de ecrã a mostrar os detalhes do Microsoft Entra ID no portal do Azure.

  3. No menu do Microsoft Entra ID no lado esquerdo, em Gerenciar, selecione Novo grupo de grupos>.

  4. Certifique-se de que Segurança está selecionada para Tipo de grupo. Insira um nome de grupo, como myJITGroup. Em Microsoft Entra funções podem ser atribuídas a este grupo (Pré-visualização), selecione Sim. Por fim, selecione Criar.

    Captura de ecrã a mostrar detalhes do novo grupo no portal do Azure.

  5. Você será levado de volta à página Grupos . Selecione o grupo recém-criado e anote o ID do objeto. Para o resto destas instruções, referir-nos-emos a este ID como <object-id>.

    Captura de ecrã a mostrar o ID do objeto para o novo grupo no portal do Azure.

  6. De volta ao portal do Azure, no menu Atividade do lado esquerdo, selecione Acesso privilegiado (visualização). Em seguida, selecione Ativar acesso privilegiado.

    Captura de ecrã a mostrar seleções para ativar o acesso privilegiado no portal do Azure.

  7. Selecione Adicionar atribuições para começar a conceder acesso.

    Captura de ecrã a mostrar como adicionar atribuições ativas no portal do Azure.

  8. Selecione uma função de Membro e selecione os usuários e grupos aos quais você deseja conceder acesso ao cluster. Um administrador de grupo pode modificar essas atribuições a qualquer momento. Quando estiver pronto para seguir em frente, selecione Avançar.

    Captura de ecrã a mostrar como adicionar atribuições no portal do Azure.

  9. Escolha um tipo de atribuição de Ativo, escolha a duração desejada e forneça uma justificação. Quando estiver pronto para continuar, selecione Atribuir. Para obter mais informações sobre tipos de atribuição, consulte Atribuir elegibilidade para um grupo de acesso privilegiado (visualização) no Privileged Identity Management.

    Captura de ecrã a mostrar propriedades de atribuição no portal do Azure.

Depois de fazer as atribuições, verifique se o acesso just-in-time está funcionando acessando o cluster. Por exemplo, use o kubectl get nodes comando para exibir nós no cluster:

kubectl get nodes

Observe o requisito de autenticação e siga as etapas para autenticar. Se a autenticação for bem-sucedida, você verá uma saída semelhante a esta:

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

NAME      STATUS   ROLES    AGE      VERSION
node-1    Ready    agent    6m36s    v1.18.14
node-2    Ready    agent    6m42s    v1.18.14
node-3    Ready    agent    6m33s    v1.18.14

Próximos passos