0Pricing
AWS Solutions Architect · Lección

Roles de IAM para cuentas de servicio (IRSA)

Asocie roles de IAM con permisos detallados a cuentas de servicio de Kubernetes mediante IRSA para que los pods accedan a servicios de AWS sin permisos a nivel de nodo

Roles de IAM para cuentas de servicio (IRSA) es una lección gratuita de AWS Solutions Architect en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AWS Solutions Architect, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AWS Solutions Architect incluye 4 lecciones en total.

El problema de IAM de los pods

Cuando un pod que se ejecuta en EKS necesita llamar a una API de AWS —por ejemplo, leer de S3 o escribir en DynamoDB— necesita credenciales de AWS. El enfoque ingenuo consiste en crear un usuario de IAM y codificar sus claves de acceso como variables de entorno. Esto es inseguro y vulnera el principio de privilegio mínimo, porque todos los pods del mismo nodo comparten las credenciales. IAM Roles for Service Accounts (IRSA) resuelve este problema vinculando roles de IAM detallados directamente a las cuentas de servicio de Kubernetes.

Cómo funciona IRSA: federación OIDC

IRSA funciona mediante la federación de OpenID Connect (OIDC). EKS crea un proveedor OIDC para su clúster. Cuando un pod hace referencia a una cuenta de servicio anotada con un ARN de rol de IAM, EKS inyecta en el pod un token proyectado de cuenta de servicio firmado. El SDK de AWS del pod intercambia este token por credenciales temporales de AWS mediante la API AssumeRoleWithWebIdentity de AWS STS; no se necesitan claves de larga duración.

# View the OIDC issuer URL for your cluster
aws eks describe-cluster \
  --name my-cluster \
  --query 'cluster.identity.oidc.issuer' \
  --output text

# Example output:
# https://oidc.eks.us-east-1.amazonaws.com/id/EXAMPLEIDSTRING

Paso 1: Asociar el proveedor OIDC

Antes de usar IRSA, debe asociar el emisor OIDC de EKS como proveedor de identidad de confianza en su cuenta de AWS. Esto crea un recurso de proveedor OIDC de IAM que AWS STS reconocerá. El comando eksctl se encarga de esto automáticamente. Una vez creado, puede verificarlo en la consola de IAM, en Proveedores de identidad.

# Associate the OIDC provider using eksctl (simplest method)
eksctl utils associate-iam-oidc-provider \
  --region us-east-1 \
  --cluster my-cluster \
  --approve

# Verify the provider was created
aws iam list-open-id-connect-providers \
  --query 'OpenIDConnectProviderList[].Arn'

Paso 2: Crear el rol de IAM

El rol de IAM para IRSA debe tener una política de confianza que permita al proveedor OIDC asumirlo, con un alcance limitado a un espacio de nombres y una cuenta de servicio específicos de Kubernetes. La condición utiliza la notificación sub del token OIDC, cuyo valor es system:serviceaccount:NAMESPACE:SERVICE_ACCOUNT_NAME. Esto garantiza que solo los pods que usan esa cuenta de servicio específica puedan asumir el rol, y no cualquier pod del clúster.

# Trust policy for the IRSA role (JSON)
# {
#   "Version": "2012-10-17",
#   "Statement": [{
#     "Effect": "Allow",
#     "Principal": {
#       "Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLEID"
#     },
#     "Action": "sts:AssumeRoleWithWebIdentity",
#     "Condition": {
#       "StringEquals": {
#         "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLEID:sub":
#           "system:serviceaccount:production:s3-reader"
#       }
#     }
#   }]
# }

Paso 3: Anotar la cuenta de servicio

Cree una ServiceAccount de Kubernetes en el espacio de nombres de destino y anótela con el ARN del rol de IAM. Cuando un pod haga referencia a esta cuenta de servicio, EKS inyectará automáticamente el token OIDC y dos variables de entorno (AWS_WEB_IDENTITY_TOKEN_FILE y AWS_ROLE_ARN). El SDK de AWS las detecta automáticamente y llama a STS para obtener credenciales temporales; no es necesario cambiar el código de la aplicación.

# Create and annotate the Kubernetes service account
kubectl create serviceaccount s3-reader -n production

kubectl annotate serviceaccount s3-reader \
  -n production \
  eks.amazonaws.com/role-arn=arn:aws:iam::111122223333:role/S3ReaderRole

# Verify the annotation
kubectl describe serviceaccount s3-reader -n production

Paso 4: Hacer referencia a la cuenta de servicio en los pods

En la especificación del pod o del despliegue, establezca serviceAccountName con el nombre de la cuenta de servicio anotada. Cuando EKS programe el pod, montará automáticamente el token OIDC en /var/run/secrets/eks.amazonaws.com/serviceaccount/token y establecerá las variables de entorno necesarias. Cualquier llamada a un SDK de AWS dentro del pod utilizará de forma transparente las credenciales del rol de IAM asignado, sin ninguna configuración explícita de credenciales.

# Pod spec using IRSA service account
apiVersion: v1
kind: Pod
metadata:
  name: s3-app
  namespace: production
spec:
  serviceAccountName: s3-reader
  containers:
  - name: app
    image: 111122223333.dkr.ecr.us-east-1.amazonaws.com/my-app:latest
    # AWS SDK auto-detects IRSA — no credential config needed
    # AWS_WEB_IDENTITY_TOKEN_FILE and AWS_ROLE_ARN are injected

IRSA frente al rol de IAM del nodo: diferencias principales

Con un rol de IAM del nodo, todos los pods de un nodo heredan los mismos permisos; un pod comprometido puede acceder a todos los servicios de AWS a los que el nodo tenga permiso de acceso. Con IRSA, cada pod, mediante su cuenta de servicio, asume únicamente el rol que necesita. Esto aplica el principio de privilegio mínimo en el nivel del pod y limita el radio de impacto de cualquier incidente de seguridad. AWS recomienda usar IRSA en lugar de roles a nivel de nodo en todos los nuevos despliegues de EKS.

Uso de eksctl para crear roles de IRSA

eksctl puede crear la asociación OIDC, el rol de IAM, la política de confianza y la anotación de Kubernetes de la ServiceAccount mediante un solo comando, usando create iamserviceaccount. Esta es la forma más sencilla de configurar IRSA sin escribir manualmente el JSON de la política de confianza. Especifique el espacio de nombres, el nombre de la cuenta de servicio y el ARN de la política de IAM que desea asociar; eksctl se encargará del resto.

# Create everything needed for IRSA in one command
eksctl create iamserviceaccount \
  --name s3-reader \
  --namespace production \
  --cluster my-cluster \
  --attach-policy-arn arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess \
  --approve \
  --override-existing-serviceaccounts

IRSA para complementos de AWS

Muchos complementos y controladores de EKS necesitan IRSA para funcionar: Cluster Autoscaler necesita permiso para llamar a la API de escalado automático de EC2, el AWS Load Balancer Controller necesita permiso para crear y administrar recursos de ELB, external-dns necesita acceso de escritura a Route 53 y el EBS CSI driver necesita permiso para crear y asociar volúmenes de EBS. Use siempre IRSA para estos componentes del sistema; nunca conceda estos permisos en el nivel del rol de IAM del nodo.

# Create IRSA for the EBS CSI driver
eksctl create iamserviceaccount \
  --name ebs-csi-controller-sa \
  --namespace kube-system \
  --cluster my-cluster \
  --attach-policy-arn arn:aws:iam::aws:policy/service-role/AmazonEBSCSIDriverPolicy \
  --approve \
  --role-name AmazonEKS_EBS_CSI_DriverRole

Actualización y rotación de credenciales y tokens

Los tokens de IRSA tienen una duración corta y el controlador de proyección de tokens de Kubernetes los rota automáticamente antes de que caduquen. La audiencia predeterminada del token es sts.amazonaws.com y su caducidad es de 24 horas, pero el controlador los actualiza cuando han transcurrido el 80 % de su duración. Las credenciales de AWS STS obtenidas mediante IRSA también son temporales, normalmente de 1 hora. Esta rotación automática elimina la carga de rotar credenciales asociada a las claves de acceso de IAM de larga duración.

# Inspect the projected service account token inside a pod
kubectl exec -n production s3-app -- \
  cat /var/run/secrets/eks.amazonaws.com/serviceaccount/token

# Decode the JWT header and payload to see expiry and audience
# jwt.io or: base64 -d <<< "PAYLOAD_SECTION"

Auditar el uso de IRSA con CloudTrail

Cada vez que un pod asume un rol de IAM mediante IRSA, AWS CloudTrail registra un evento AssumeRoleWithWebIdentity. El evento incluye el ARN del rol asumido, el asunto del token OIDC (system:serviceaccount:NAMESPACE:SERVICE_ACCOUNT) y la IP de origen. Esto proporciona un registro de auditoría completo de qué pods accedieron a qué servicios de AWS y cuándo, algo fundamental para el cumplimiento y la investigación de incidentes en entornos regulados.

# Search CloudTrail for IRSA calls
aws cloudtrail lookup-events \
  --lookup-attributes AttributeKey=EventName,AttributeValue=AssumeRoleWithWebIdentity \
  --start-time '2024-01-01T00:00:00Z' \
  --query 'Events[].{Time:EventTime,Role:CloudTrailEvent}' \
  --output table

Comprobación rápida

Compruebe su comprensión de los conceptos de AWS Solutions Architect (SAA-C03) tratados en esta lección.

Resumen de la lección

En esta lección ha aprendido que IRSA utiliza la federación OIDC para intercambiar tokens de cuentas de servicio de Kubernetes por credenciales temporales de AWS; las políticas de confianza de los roles de IAM limitan el acceso a un espacio de nombres y una cuenta de servicio específicos; y IRSA proporciona un privilegio mínimo por pod, muy superior al de los roles de IAM a nivel de nodo. A continuación, exploraremos las métricas, los espacios de nombres y las dimensiones de CloudWatch para observar sus recursos de AWS.

Preguntas frecuentes

¿La lección «Roles de IAM para cuentas de servicio (IRSA)» es gratis?

Sí — el texto completo de «Roles de IAM para cuentas de servicio (IRSA)» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AWS Solutions Architect, actualiza a CoddyKit PRO. El curso de AWS Solutions Architect incluye 4 lecciones en total.

¿Qué aprenderé en «Roles de IAM para cuentas de servicio (IRSA)»?

Asocie roles de IAM con permisos detallados a cuentas de servicio de Kubernetes mediante IRSA para que los pods accedan a servicios de AWS sin permisos a nivel de nodo Practicas AWS Solutions Architect con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar AWS Solutions Architect?

No se requiere experiencia previa. AWS Solutions Architect en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Roles de IAM para cuentas de servicio (IRSA)»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de AWS Solutions Architect?

Sí. Cada lección de AWS Solutions Architect incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Plano de control y nodos de trabajo de EKS
  2. Perfiles de Fargate para pods sin servidor
  3. Redes de EKS: VPC CNI y balanceo de carga
  4. Roles de IAM para cuentas de servicio (IRSA)
← Volver a AWS Solutions Architect