0Pricing
AWS Solutions Architect · Aula

Funções do IAM para contas de serviço (IRSA)

Associe funções do IAM com permissões detalhadas a contas de serviço do Kubernetes usando IRSA, para que os pods acessem serviços da AWS sem permissões no nível do nó.

Funções do IAM para contas de serviço (IRSA) é uma aula grátis de AWS Solutions Architect no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AWS Solutions Architect, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AWS Solutions Architect inclui 4 aulas no total.

O Problema do IAM nos Pods

Quando um pod em execução no EKS precisa chamar uma API da AWS — por exemplo, ler dados do S3 ou gravar dados no DynamoDB — ele precisa de credenciais da AWS. A abordagem ingênua é criar um usuário do IAM e codificar suas chaves de acesso como variáveis de ambiente. Isso é inseguro e viola o princípio do privilégio mínimo, porque todos os pods no mesmo nó compartilham as credenciais. IAM Roles for Service Accounts (IRSA) resolve esse problema associando funções do IAM com permissões específicas diretamente a contas de serviço do Kubernetes.

Como o IRSA Funciona: Federação OIDC

O IRSA funciona por meio da federação OpenID Connect (OIDC). O EKS cria um provedor OIDC para o seu cluster. Quando um pod faz referência a uma conta de serviço anotada com um ARN de função do IAM, o EKS injeta no pod um token de conta de serviço projetado e assinado. O SDK da AWS no pod troca esse token por credenciais temporárias da AWS usando a API AssumeRoleWithWebIdentity do AWS STS — sem necessidade de chaves de longa duração.

# 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

Etapa 1: Associar o Provedor OIDC

Antes de usar o IRSA, você deve associar o emissor OIDC do EKS como um provedor de identidade confiável na sua conta da AWS. Isso cria um recurso de provedor OIDC do IAM que o AWS STS reconhecerá. O comando eksctl faz isso automaticamente. Depois de criado, você pode verificá-lo no console do IAM, em Provedores de identidade.

# 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'

Etapa 2: Criar a Função do IAM

A função do IAM para o IRSA deve ter uma política de confiança que permita ao provedor OIDC assumi-la, com escopo restrito a um namespace específico do Kubernetes e a uma conta de serviço. A condição usa a declaração sub no token OIDC, definida como system:serviceaccount:NAMESPACE:SERVICE_ACCOUNT_NAME. Isso garante que somente os pods que usam essa conta de serviço específica possam assumir a função — e não qualquer pod do cluster.

# 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"
#       }
#     }
#   }]
# }

Etapa 3: Anotar a Conta de Serviço

Crie uma ServiceAccount do Kubernetes no namespace de destino e anote-a com o ARN da função do IAM. Quando um pod fizer referência a essa conta de serviço, o EKS injetará automaticamente o token OIDC e duas variáveis de ambiente (AWS_WEB_IDENTITY_TOKEN_FILE e AWS_ROLE_ARN). O SDK da AWS as detecta automaticamente e chama o STS para obter credenciais temporárias — não são necessárias alterações no código da sua aplicação.

# 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

Etapa 4: Fazer Referência à Conta de Serviço nos Pods

Na especificação do seu pod ou implantação, defina serviceAccountName como a conta de serviço anotada. Quando o EKS agendar o pod, ele montará automaticamente o token OIDC em /var/run/secrets/eks.amazonaws.com/serviceaccount/token e definirá as variáveis de ambiente necessárias. Qualquer chamada ao SDK da AWS dentro do pod usará de forma transparente as credenciais da função do IAM associada, sem nenhuma configuração explícita de credenciais.

# 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 versus Função do IAM do Nó: Principais Diferenças

Com uma função do IAM do nó, todos os pods em um nó herdam as mesmas permissões — um pod comprometido pode acessar todos os serviços da AWS aos quais o nó tem permissão de acesso. Com o IRSA, cada pod, por meio da sua conta de serviço, assume somente a função de que precisa. Isso segue o princípio do privilégio mínimo no nível do pod e limita o impacto de qualquer incidente de segurança. A AWS recomenda o IRSA em vez de funções no nível do nó para todas as novas implantações do EKS.

Usando o eksctl para Criar Funções do IRSA

O eksctl pode criar a associação OIDC, a função do IAM, a política de confiança e a anotação da ServiceAccount do Kubernetes com um único comando, usando create iamserviceaccount. Essa é a maneira mais simples de configurar o IRSA sem escrever manualmente o JSON da política de confiança. Você especifica o namespace, o nome da conta de serviço e o ARN da política do IAM a ser associada, e o eksctl cuida do restante.

# 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 da AWS

Muitos complementos e controladores do EKS precisam do IRSA para funcionar: o Cluster Autoscaler precisa de permissão para chamar a API do EC2 Auto Scaling, o AWS Load Balancer Controller precisa de permissão para criar e gerenciar recursos do ELB, o external-dns precisa de acesso de gravação ao Route 53, e o EBS CSI driver precisa de permissão para criar e associar volumes EBS. Use sempre o IRSA para esses componentes do sistema — nunca conceda as permissões no nível da função do IAM do nó.

# 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

Atualização de Tokens e Rotação de Credenciais

Os tokens do IRSA têm curta duração e são rotacionados automaticamente pelo controlador de projeção de tokens do Kubernetes antes de expirarem. O público padrão do token é sts.amazonaws.com e a validade é de 24 horas, mas o controlador os atualiza quando atingem 80% da sua duração. As credenciais do AWS STS obtidas por meio do IRSA também são temporárias, normalmente válidas por 1 hora. Essa rotação automática elimina a sobrecarga de rotacionar credenciais de chaves de acesso do IAM de longa duração.

# 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"

Auditoria do Uso do IRSA com o CloudTrail

Sempre que um pod assume uma função do IAM por meio do IRSA, o AWS CloudTrail registra um evento AssumeRoleWithWebIdentity. O evento inclui o ARN da função assumida, o assunto do token OIDC (system:serviceaccount:NAMESPACE:SERVICE_ACCOUNT) e o IP de origem. Isso fornece um registro de auditoria completo sobre quais pods acessaram quais serviços da AWS e quando — algo essencial para conformidade e investigação de incidentes em ambientes regulamentados.

# 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

Verificação Rápida

Teste sua compreensão dos conceitos do AWS Solutions Architect (SAA-C03) apresentados nesta lição.

Resumo da Lição

Nesta lição, você aprendeu que: o IRSA usa a federação OIDC para trocar tokens de contas de serviço do Kubernetes por credenciais temporárias da AWS; as políticas de confiança das funções do IAM restringem o acesso a um namespace e uma conta de serviço específicos; e o IRSA fornece privilégio mínimo por pod, muito superior ao das funções do IAM no nível do nó. A seguir, exploraremos as métricas, os namespaces e as dimensões do CloudWatch para observar seus recursos da AWS.

Perguntas Frequentes

A aula “Funções do IAM para contas de serviço (IRSA)” é grátis?

Sim — o texto completo de “Funções do IAM para contas de serviço (IRSA)” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AWS Solutions Architect, atualize para CoddyKit PRO. O curso de AWS Solutions Architect inclui 4 aulas no total.

O que vou aprender em “Funções do IAM para contas de serviço (IRSA)”?

Associe funções do IAM com permissões detalhadas a contas de serviço do Kubernetes usando IRSA, para que os pods acessem serviços da AWS sem permissões no nível do nó. Você pratica AWS Solutions Architect com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AWS Solutions Architect?

Nenhuma experiência prévia é necessária. AWS Solutions Architect no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Funções do IAM para contas de serviço (IRSA)”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AWS Solutions Architect?

Sim. Cada aula de AWS Solutions Architect inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Plano de controle e nós de trabalho do EKS
  2. Perfis do Fargate para pods sem servidor
  3. Rede do EKS: VPC CNI e balanceamento de carga
  4. Funções do IAM para contas de serviço (IRSA)
← Voltar para AWS Solutions Architect