Pular para o conteúdo principal

Lab 9.1 - Criação de Roles e RoleBindings

Objetivos do Lab​

Ao final deste lab, você será capaz de:

  • Compreender o conceito de RBAC no Kubernetes.
  • Criar um Role com permissões específicas.
  • Criar um RoleBinding para vincular um usuário a um Role.
  • Testar as permissões com kubectl auth can-i.
  • Entender a diferença entre Role e ClusterRole.

Duração Estimada​

45-60 minutos

Pré-requisitos​

  • kubectl instalado e configurado.
  • Cluster Kubernetes local funcional.
  • Conhecimentos sobre RBAC (Capítulo 9.1).

Parte 1: Compreendendo o RBAC​

RBAC (Role-Based Access Control) permite controlar quem pode fazer o quê no Kubernetes.

Conceitos:​

  • Role: Define permissões dentro de um namespace.
  • ClusterRole: Define permissões no nível do cluster.
  • RoleBinding: Vincula um usuário/grupo/ServiceAccount a um Role (em um namespace).
  • ClusterRoleBinding: Vincula um usuário/grupo/ServiceAccount a um ClusterRole (em todo o cluster).

Parte 2: Criação de um Role​

Vamos criar um Role que permite ler e criar Pods em um namespace.

Etapa 2.1: Criar um Namespace de Teste​

Crie um namespace para o teste:

kubectl create namespace rbac-test

Etapa 2.2: Criar um Role​

Crie role-pod-manager.yaml:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: rbac-test
  name: pod-manager
rules:
- apiGroups: [""] # Grupo API core (v1)
  resources: ["pods"]
  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
- apiGroups: [""]
  resources: ["pods/status"]
  verbs: ["get"]

Explicação:

  • apiGroups: [""]: Grupo API core (recursos como Pods, Services, etc.).
  • resources: ["pods"]: Recurso ao qual as permissões se aplicam.
  • verbs: Ações permitidas (get, list, watch, create, update, patch, delete).

Aplique o Role:

kubectl apply -f role-pod-manager.yaml

Verifique:

kubectl get role -n rbac-test
kubectl describe role pod-manager -n rbac-test

Parte 3: Criação de um RoleBinding​

Vamos criar um RoleBinding que vincula um ServiceAccount ao Role.

Etapa 3.1: Criar um ServiceAccount​

Crie um ServiceAccount:

kubectl create serviceaccount pod-manager-sa -n rbac-test

Etapa 3.2: Criar o RoleBinding​

Crie rolebinding-pod-manager.yaml:

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: pod-manager-binding
  namespace: rbac-test
subjects:
- kind: ServiceAccount
  name: pod-manager-sa
  namespace: rbac-test
roleRef:
  kind: Role
  name: pod-manager
  apiGroup: rbac.authorization.k8s.io

Explicação:

  • subjects: Para quem as permissões são concedidas (ServiceAccount, User, Group).
  • roleRef: Referência ao Role (ou ClusterRole) a ser utilizado.

Aplique o RoleBinding:

kubectl apply -f rolebinding-pod-manager.yaml

Verifique:

kubectl get rolebinding -n rbac-test
kubectl describe rolebinding pod-manager-binding -n rbac-test

Parte 4: Testando as Permissões​

Etapa 4.1: Obter o Token do ServiceAccount​

Para testar as permissões, precisamos usar o token do ServiceAccount:

# Obter o nome do Secret do ServiceAccount
SECRET_NAME=$(kubectl get serviceaccount pod-manager-sa -n rbac-test -o jsonpath='{.secrets[0].name}')

# Extrair o token
TOKEN=$(kubectl get secret $SECRET_NAME -n rbac-test -o jsonpath='{.data.token}' | base64 -d)

# Obter o certificado CA
CA_CERT=$(kubectl get secret $SECRET_NAME -n rbac-test -o jsonpath='{.data.ca\.crt}')

Etapa 4.2: Testar com kubectl auth can-i​

Teste as permissões com seu contexto atual (admin):

# Verificar se você pode criar Pods
kubectl auth can-i create pods --namespace=rbac-test

# Verificar se você pode deletar Pods
kubectl auth can-i delete pods --namespace=rbac-test

# Verificar se você pode listar Services (deve ser não)
kubectl auth can-i list services --namespace=rbac-test

Etapa 4.3: Testar com o ServiceAccount​

Crie um Pod que utiliza o ServiceAccount:

apiVersion: v1
kind: Pod
metadata:
  name: test-pod
  namespace: rbac-test
spec:
  serviceAccountName: pod-manager-sa
  containers:
  - name: test
    image: bitnami/kubectl:latest
    command: ["sleep", "3600"]

Aplique o Pod:

kubectl apply -f test-pod.yaml

Execute comandos no Pod para testar as permissões:

# Testar a criação de um Pod (deve funcionar)
kubectl exec -n rbac-test test-pod -- kubectl create pod test-pod-2 --image=busybox --dry-run=client -o yaml

# Testar a listagem de Pods (deve funcionar)
kubectl exec -n rbac-test test-pod -- kubectl get pods

# Testar a listagem de Services (deve falhar)
kubectl exec -n rbac-test test-pod -- kubectl get services

Parte 5: Criação de um ClusterRole​

Um ClusterRole se aplica ao nível de todo o cluster.

Etapa 5.1: Criar um ClusterRole​

Crie clusterrole-node-viewer.yaml:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: node-viewer
rules:
- apiGroups: [""]
  resources: ["nodes"]
  verbs: ["get", "list", "watch"]

Aplique o ClusterRole:

kubectl apply -f clusterrole-node-viewer.yaml

Parte 6: Limpeza​

Remova os recursos criados:

kubectl delete pod test-pod -n rbac-test
kubectl delete rolebinding pod-manager-binding -n rbac-test
kubectl delete role pod-manager -n rbac-test
kubectl delete serviceaccount pod-manager-sa -n rbac-test
kubectl delete clusterrole node-viewer
kubectl delete namespace rbac-test

Resumo do Lab​

Neste lab, você criou Roles e RoleBindings para implementar RBAC. Você aprendeu a definir permissões com Roles, a vincular usuários/ServiceAccounts com RoleBindings e a testar as permissões.

Próximos Passos​

O próximo lab mostrará como utilizar os Service Accounts e suas permissões nos Pods.

Lab 9.2: Service Accounts e Permissões

Lab criado em: Dezembro 2024