Controle de Acesso Baseado em Funções no Kubernetes

Introdução

Num cluster Kubernetes, o Role-Based Access Control (RBAC) é usado para controlar o acesso a recursos e operações dentro do cluster. O RBAC permite que os administradores do cluster definam funções e permissões para usuários, grupos e service accounts para controlar o acesso a recursos e operações dentro do cluster. Neste laboratório, você aprenderá como usar o RBAC para controlar o acesso a recursos em um cluster Kubernetes.

Iniciar o Cluster Minikube

Antes de criar recursos, você precisa de um cluster Kubernetes em execução. Minikube é um ambiente Kubernetes leve que roda em sua máquina local.

1. Navegue para o seu diretório de trabalho:

   Abra o terminal e navegue até a pasta do projeto padrão:

   cd /home/labex/project

2. Iniciar Minikube:

   Inicie o Minikube para inicializar um cluster Kubernetes:

   minikube start

   • Este comando configura um cluster Kubernetes de nó único em sua máquina local.
   • O Minikube pode levar alguns minutos para iniciar, dependendo do desempenho do seu sistema.

3. Verificar se o Minikube está em execução:

   Verifique o status do cluster Minikube:

   minikube status

   • Procure por componentes como kubelet e apiserver listados como Running.
   • Se o cluster não estiver em execução, execute novamente minikube start.

Se você encontrar problemas ao iniciar o Minikube. Use minikube delete para redefinir o ambiente, se necessário.

Criar um Namespace

Crie um novo namespace chamado myapp usando o seguinte comando:

kubectl create namespace myapp

Criar uma Role (Função)

Crie um novo Role (Papel) chamado myapp-reader no namespace myapp que permite aos usuários ler pods e services no namespace usando o seguinte arquivo YAML chamado myapp-reader-role.yaml:

kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  namespace: myapp
  name: myapp-reader
rules:
  - apiGroups: [""]
    resources: ["pods", "services"]
    verbs: ["get", "watch", "list"]

Este Role (Papel) permite que os usuários leiam (get, watch e list) pods e services no namespace myapp.

Crie o Role (Papel) usando o seguinte comando:

kubectl apply -f myapp-reader-role.yaml

Criar um Role Binding (Associação de Função)

Crie um Role Binding (Vinculação de Papel) que vincule o Role (Papel) myapp-reader a um usuário ou grupo no namespace myapp. Por exemplo, para vincular o Role (Papel) myapp-reader ao usuário developer no namespace myapp, crie o seguinte arquivo YAML chamado myapp-reader-binding.yaml:

kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: myapp-reader-binding
  namespace: myapp
subjects:
  - kind: User
    name: developer
    apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: myapp-reader
  apiGroup: rbac.authorization.k8s.io

Este Role Binding (Vinculação de Papel) vincula o Role (Papel) myapp-reader ao usuário developer no namespace myapp.

Crie o Role Binding (Vinculação de Papel) usando o seguinte comando:

kubectl apply -f myapp-reader-binding.yaml

Testar Acesso

Teste o acesso ao namespace myapp tentando obter a lista de pods no namespace usando o seguinte comando:

kubectl get pods -n myapp --as developer

Você deve ver uma mensagem indicando que não há recursos no namespace myapp, porque você pode não ter pods em seu cluster. Quando você terminar o laboratório, use este comando e você deverá ver uma lista de pods no namespace myapp.

Teste o acesso ao namespace default tentando obter a lista de pods no namespace usando o seguinte comando:

kubectl get pods --as developer

Você deve ver uma mensagem de erro indicando que você não tem acesso ao namespace default.

Criar um ClusterRole

Crie um novo ClusterRole (Papel de Cluster) chamado myapp-admin que permite aos usuários criar, excluir e atualizar pods e serviços em todos os namespaces usando o seguinte arquivo YAML chamado myapp-admin-clusterrole.yaml:

kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: myapp-admin
rules:
  - apiGroups: [""]
    resources: ["pods", "services"]
    verbs: ["get", "list", "watch", "create", "update", "delete"]

Este ClusterRole (Papel de Cluster) permite que os usuários realizem todas as operações (get, list, watch, create, update e delete) em pods e serviços em todos os namespaces.

Crie o ClusterRole (Papel de Cluster) usando o seguinte comando:

kubectl apply -f myapp-admin-clusterrole.yaml

Criar um ClusterRole Binding

Crie um ClusterRole Binding (Vinculação de Papel de Cluster) que vincule o myapp-admin ClusterRole (Papel de Cluster) a um usuário ou grupo no cluster. Por exemplo, para vincular o myapp-admin ClusterRole (Papel de Cluster) ao usuário cluster-admin, crie o seguinte arquivo YAML chamado myapp-admin-binding.yaml:

kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: myapp-admin-binding
subjects:
  - kind: User
    name: cluster-admin
    apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: ClusterRole
  name: myapp-admin
  apiGroup: rbac.authorization.k8s.io

Este ClusterRole Binding (Vinculação de Papel de Cluster) vincula o myapp-admin ClusterRole (Papel de Cluster) ao usuário cluster-admin.

Crie o ClusterRole Binding (Vinculação de Papel de Cluster) usando o seguinte comando:

kubectl apply -f myapp-admin-binding.yaml

Testar Acesso

Teste o acesso para criar um pod no namespace myapp criando um pod usando o seguinte arquivo YAML chamado myapp-pod.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: myapp-pod
  namespace: myapp
spec:
  containers:
    - name: myapp-container
      image: nginx
      ports:
        - containerPort: 80

Crie o pod usando o seguinte comando:

kubectl apply -f myapp-pod.yaml --as cluster-admin

Você deve ver uma mensagem indicando que o pod foi criado.

Teste o acesso para criar um deployment (implantação) no namespace myapp criando um deployment usando o seguinte arquivo YAML myapp-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
  namespace: myapp
spec:
  replicas: 1
  selector:
    matchLabels:
      app: myapp-deployment
  template:
    metadata:
      labels:
        app: myapp-deployment
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          ports:
            - containerPort: 80

Crie o pod usando o seguinte comando:

kubectl apply -f myapp-deployment.yaml --as cluster-admin

Você deve ver uma mensagem de erro indicando que você não tem acesso para criar um deployment no namespace myapp.

Resumo

Neste laboratório, você aprendeu como usar o Role-Based Access Control (RBAC - Controle de Acesso Baseado em Funções) no Kubernetes para controlar o acesso a recursos e operações dentro do cluster. Você criou um namespace, um Role (Papel) e um Role Binding (Vinculação de Papel) para controlar o acesso a recursos em um namespace específico. Você também criou um ClusterRole (Papel de Cluster) e um ClusterRole Binding (Vinculação de Papel de Cluster) para controlar o acesso a recursos em todos os namespaces. Ao final deste laboratório, você deve ter uma boa compreensão de como usar o RBAC para controlar o acesso a recursos e operações em um cluster Kubernetes.