Saltar al contenido principal

Capítulo 9.2 - Service Accounts

Objetivos de Aprendizaje​

Al final de este capítulo, usted será capaz de:

  • Comprender qué es un Service Account
  • Crear y utilizar Service Accounts
  • Vincular Service Accounts a Pods
  • Comprender los tokens y secrets
  • Gestionar los permisos con RBAC
  • Utilizar Service Accounts para el acceso a la API

Introducción​

Una Service Account proporciona una identidad para los Pods que se ejecutan en el clúster. Permite que las aplicaciones interactúen con la API de Kubernetes de manera segura.

¿Qué es un Service Account?​

Un Service Account es una identidad de Kubernetes utilizada por los Pods para:

  • Autenticarse ante la API de Kubernetes
  • Acceder a los recursos según los permisos de RBAC
  • Interactuar con otros servicios en el clúster

Por defecto: Cada namespace tiene un Service Account default.

Creación de un Service Account​

Service Account Básico​

apiVersion: v1
kind: ServiceAccount
metadata:
  name: my-app-sa
  namespace: default

Service Account con Anotaciones​

apiVersion: v1
kind: ServiceAccount
metadata:
  name: my-app-sa
  namespace: default
  annotations:
    eks.amazonaws.com/role-arn: arn:aws:iam::123456789012:role/my-role

Uso en un Pod​

Especificar el Service Account​

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  serviceAccountName: my-app-sa
  containers:
  - name: app
    image: my-app:1.0

Resultado: El Pod utiliza my-app-sa en lugar del Service Account por defecto.

Service Account Automático​

Si no se especifica serviceAccountName, el Pod utiliza el Service Account default del namespace.

Tokens y Secrets​

Token Automático​

Kubernetes crea automáticamente un token (Secret) para cada Service Account:

# Ver los secrets creados automáticamente
kubectl get secrets | grep my-app-sa

# Detalles del token
kubectl describe secret my-app-sa-token-xxxxx

Montaje del Token​

El token se monta automáticamente en el Pod en /var/run/secrets/kubernetes.io/serviceaccount/:

# Dentro del Pod
cat /var/run/secrets/kubernetes.io/serviceaccount/token
cat /var/run/secrets/kubernetes.io/serviceaccount/namespace
cat /var/run/secrets/kubernetes.io/serviceaccount/ca.crt

Permisos RBAC​

Vincular un Service Account a un Role​

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: app-role-binding
  namespace: default
subjects:
- kind: ServiceAccount
  name: my-app-sa
  namespace: default
roleRef:
  kind: Role
  name: app-role
  apiGroup: rbac.authorization.k8s.io

Ejemplo Completo​

Paso 1: Crear el Service Account

apiVersion: v1
kind: ServiceAccount
metadata:
  name: pod-reader-sa
  namespace: default

Paso 2: Crear el Role

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

Paso 3: Crear el RoleBinding

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

Paso 4: Usar en un Pod

apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  serviceAccountName: pod-reader-sa
  containers:
  - name: app
    image: my-app:1.0

Resultado: El Pod puede leer los Pods en el namespace default.

Acceso a la API de Kubernetes​

Usar el Token en la Aplicación​

import os
import requests

# Leer el token
with open('/var/run/secrets/kubernetes.io/serviceaccount/token', 'r') as f:
    token = f.read().strip()

# Leer el namespace
with open('/var/run/secrets/kubernetes.io/serviceaccount/namespace', 'r') as f:
    namespace = f.read().strip()

# Llamada a la API
api_url = f"https://kubernetes.default.svc/api/v1/namespaces/{namespace}/pods"
headers = {
    'Authorization': f'Bearer {token}',
    'Content-Type': 'application/json'
}

response = requests.get(api_url, headers=headers, verify='/var/run/secrets/kubernetes.io/serviceaccount/ca.crt')
print(response.json())

Image Pull Secrets​

Los Service Accounts pueden tener imagePullSecrets para acceder a registros Docker privados:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: private-registry-sa
  namespace: default
imagePullSecrets:
- name: regcred

Resultado: Todos los Pods que utilicen este Service Account pueden extraer imágenes del registro privado.

Service Account por Defecto​

Desactivar el Montaje Automático​

apiVersion: v1
kind: ServiceAccount
metadata:
  name: no-token-sa
  namespace: default
automountServiceAccountToken: false

Resultado: El token no se monta en los Pods que utilizan este Service Account.

A Nivel de Pod​

apiVersion: v1
kind: Pod
metadata:
  name: no-token-pod
spec:
  serviceAccountName: my-app-sa
  automountServiceAccountToken: false
  containers:
  - name: app
    image: my-app:1.0

Buenas Prácticas​

1. Service Account por Aplicación​

Crear un Service Account dedicado para cada aplicación.

2. Principio de Menor Privilegio​

Otorgar solo los permisos necesarios mediante RBAC.

3. No usar el Service Account por Defecto​

Evitar utilizar el Service Account default en producción.

4. Desactivar el Token si No es Necesario​

Utilizar automountServiceAccountToken: false si la aplicación no necesita acceder a la API.

5. Rotación de Tokens​

Los tokens son renovados automáticamente por Kubernetes.

Comandos Útiles​

Gestión​

# Crear un Service Account
kubectl create serviceaccount my-app-sa

# Ver los Service Accounts
kubectl get serviceaccounts
kubectl get sa

# Detalles
kubectl describe serviceaccount my-app-sa

# Ver los secrets asociados
kubectl get secrets | grep my-app-sa

Uso​

# Crear un Pod con un Service Account
kubectl run my-pod --image=my-app:1.0 --serviceaccount=my-app-sa

# Ver el token en un Pod
kubectl exec my-pod -- cat /var/run/secrets/kubernetes.io/serviceaccount/token

Resumen​

En este capítulo, usted ha aprendido:

Service Account: Identidad para los Pods en Kubernetes
Creación: Recurso de Kubernetes sencillo
Uso: A través de serviceAccountName en los Pods
Tokens: Creados automáticamente y montados en /var/run/secrets/kubernetes.io/serviceaccount/
RBAC: Vincular Service Accounts a Roles para los permisos
Acceso API: Usar el token para llamar a la API de Kubernetes
Image Pull Secrets: Para acceder a registros privados
Buenas prácticas: Service Account por aplicación, menor privilegio

Próximos Pasos​

Capítulo 9.3: Network Policies
Capítulo 9.4: Pod Security Standards
Lab 9.2: Service Accounts y Permisos

Capítulo creado el: Diciembre 2024