Pular para o conteúdo principal

Capítulo 9.2 - Service Accounts

Objetivos de Aprendizagem​

Ao final deste capítulo, você será capaz de:

  • Entender o que é um Service Account
  • Criar e usar Service Accounts
  • Vincular Service Accounts a Pods
  • Compreender tokens e secrets
  • Gerenciar permissões com RBAC
  • Utilizar Service Accounts para acesso à API

Introdução​

Um Service Account fornece uma identidade para os Pods que executam no cluster. Ele permite que as aplicações interajam com a API do Kubernetes de forma segura.

O que é um Service Account?​

Um Service Account é uma identidade do Kubernetes usada pelos Pods para:

  • Autenticar-se na API do Kubernetes
  • Acessar recursos conforme permissões RBAC
  • Interagir com outros serviços no cluster

Por padrão: Cada namespace possui um Service Account default.

Criação de um Service Account​

Service Account Básico​

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

Service Account com Annotations​

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

Utilização em um Pod​

Especificar o Service Account​

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

Resultado: O Pod utiliza my-app-sa em vez do Service Account padrão.

Service Account Automático​

Se serviceAccountName não for especificado, o Pod utiliza o Service Account default do namespace.

Tokens e Secrets​

Token Automático​

O Kubernetes cria automaticamente um token (Secret) para cada Service Account:

# Ver os secrets criados automaticamente
kubectl get secrets | grep my-app-sa

# Detalhes do token
kubectl describe secret my-app-sa-token-xxxxx

Montagem do Token​

O token é automaticamente montado no Pod em /var/run/secrets/kubernetes.io/serviceaccount/:

# Dentro do 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

Permissões RBAC​

Vincular um Service Account a um 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

Exemplo Completo​

Etapa 1: Criar o Service Account

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

Etapa 2: Criar o Role

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

Etapa 3: Criar o 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

Etapa 4: Utilizar em um Pod

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

Resultado: O Pod pode ler os Pods no namespace default.

Acesso à API do Kubernetes​

Utilizar o Token na Aplicação​

import os
import requests

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

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

# Chamada à 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​

Os Service Accounts podem ter imagePullSecrets para acessar registries Docker privados:

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

Resultado: Todos os Pods que usam este Service Account podem puxar imagens do registry privado.

Service Account Padrão​

Desabilitar a Montagem Automática​

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

Resultado: O token não é montado nos Pods que usam este Service Account.

No Nível do 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

Boas Práticas​

1. Service Account por Aplicação​

Crie um Service Account dedicado para cada aplicação.

2. Princípio do Menor Privilégio​

Conceda apenas as permissões necessárias via RBAC.

3. Não Usar o Service Account Padrão​

Evite utilizar o Service Account default em produção.

4. Desabilitar o Token se Não Necessário​

Use automountServiceAccountToken: false se a aplicação não precisar acessar a API.

5. Rotação de Tokens​

Os tokens são renovados automaticamente pelo Kubernetes.

Comandos Úteis​

Gerenciamento​

# Criar um Service Account
kubectl create serviceaccount my-app-sa

# Ver os Service Accounts
kubectl get serviceaccounts
kubectl get sa

# Detalhes
kubectl describe serviceaccount my-app-sa

# Ver os secrets associados
kubectl get secrets | grep my-app-sa

Utilização​

# Criar um Pod com um Service Account
kubectl run my-pod --image=my-app:1.0 --serviceaccount=my-app-sa

# Ver o token em um Pod
kubectl exec my-pod -- cat /var/run/secrets/kubernetes.io/serviceaccount/token

Resumo​

Neste capítulo, você aprendeu:

Service Account: Identidade para Pods no Kubernetes
Criação: Recurso Kubernetes simples
Utilização: Via serviceAccountName nos Pods
Tokens: Criados automaticamente e montados em /var/run/secrets/kubernetes.io/serviceaccount/
RBAC: Vincular Service Accounts a Roles para permissões
Acesso à API: Usar o token para chamar a API do Kubernetes
Image Pull Secrets: Para acessar registries privados
Boas práticas: Service Account por aplicação, menor privilégio

Próximos Passos​

Capítulo 9.3: Network Policies
Capítulo 9.4: Pod Security Standards
Lab 9.2: Service Accounts e Permissões

Capítulo criado em: Dezembro 2024