Saltar al contenido principal

Lab 9.1 - Creación de Roles y RoleBindings

Objetivos del Lab​

Al finalizar este laboratorio, usted será capaz de:

  • Comprender el concepto de RBAC en Kubernetes.
  • Crear un Role con permisos específicos.
  • Crear un RoleBinding para vincular un usuario a un Role.
  • Probar los permisos con kubectl auth can-i.
  • Comprender la diferencia entre Role y ClusterRole.

Duración Estimada​

45-60 minutos

Prerrequisitos​

  • kubectl instalado y configurado.
  • Cluster de Kubernetes local funcional.
  • Conocimientos sobre RBAC (Capítulo 9.1).

Parte 1: Comprender RBAC​

RBAC (Role-Based Access Control) permite controlar quién puede hacer qué en Kubernetes.

Conceptos:​

  • Role: Define permisos dentro de un namespace.
  • ClusterRole: Define permisos a nivel de clúster.
  • RoleBinding: Vincula un usuario/grupo/ServiceAccount a un Role (dentro de un namespace).
  • ClusterRoleBinding: Vincula un usuario/grupo/ServiceAccount a un ClusterRole (a nivel de clúster).

Parte 2: Creación de un Role​

Vamos a crear un Role que permite leer y crear Pods en un namespace.

Paso 2.1: Crear un Namespace de Prueba​

Cree un namespace para la prueba:

kubectl create namespace rbac-test

Paso 2.2: Crear un Role​

Cree 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"]

Explicación:

  • apiGroups: [""]: Grupo API core (recursos como Pods, Services, etc.).
  • resources: ["pods"]: Recurso sobre el cual se aplican los permisos.
  • verbs: Acciones permitidas (get, list, watch, create, update, patch, delete).

Aplique el 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: Creación de un RoleBinding​

Vamos a crear un RoleBinding que vincula un ServiceAccount al Role.

Paso 3.1: Crear un ServiceAccount​

Cree un ServiceAccount:

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

Paso 3.2: Crear el RoleBinding​

Cree 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

Explicación:

  • subjects: A quién se le otorgan los permisos (ServiceAccount, User, Group).
  • roleRef: Referencia al Role (o ClusterRole) a utilizar.

Aplique el 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: Prueba de Permisos​

Paso 4.1: Obtener el Token del ServiceAccount​

Para probar los permisos, debemos usar el token del ServiceAccount:

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

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

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

Paso 4.2: Probar con kubectl auth can-i​

Pruebe los permisos con su contexto actual (admin):

# Verificar si puede crear Pods
kubectl auth can-i create pods --namespace=rbac-test

# Verificar si puede eliminar Pods
kubectl auth can-i delete pods --namespace=rbac-test

# Verificar si puede listar Services (debería ser no)
kubectl auth can-i list services --namespace=rbac-test

Paso 4.3: Probar con el ServiceAccount​

Cree un Pod que utilice el 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 el Pod:

kubectl apply -f test-pod.yaml

Ejecute comandos en el Pod para probar los permisos:

# Probar la creación de un Pod (debería funcionar)
kubectl exec -n rbac-test test-pod -- kubectl create pod test-pod-2 --image=busybox --dry-run=client -o yaml

# Probar la lista de Pods (debería funcionar)
kubectl exec -n rbac-test test-pod -- kubectl get pods

# Probar la lista de Services (debería fallar)
kubectl exec -n rbac-test test-pod -- kubectl get services

Parte 5: Creación de un ClusterRole​

Un ClusterRole se aplica a nivel de todo el clúster.

Paso 5.1: Crear un ClusterRole​

Cree 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 el ClusterRole:

kubectl apply -f clusterrole-node-viewer.yaml

Parte 6: Limpieza​

Elimine los recursos creados:

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

Resumen del Lab​

En este laboratorio, usted creó Roles y RoleBindings para implementar RBAC. Aprendió a definir permisos con Roles, a vincular usuarios/ServiceAccounts con RoleBindings y a probar los permisos.

Próximos Pasos​

El próximo laboratorio le mostrará cómo utilizar los Service Accounts y sus permisos en los Pods.

Lab 9.2: Service Accounts y Permisos

Lab creado el: diciembre 2024