Pular para o conteúdo principal

Capítulo 5.2 - Segredos

Objetivos de Aprendizagem​

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

  • Entender o que é um Secret e por que utilizá-lo
  • Criar Secrets de diferentes maneiras
  • Utilizar Secrets em seus Pods de forma segura
  • Compreender as limitações de segurança dos Secrets
  • Aplicar boas práticas para o gerenciamento de segredos

Introdução​

Os Secrets são semelhantes aos ConfigMaps, mas são projetados para armazenar dados sensíveis como senhas, tokens de API, chaves privadas e certificados.

Importante: Os Secrets do Kubernetes não são criptografados por padrão. Eles são apenas codificados em base64.

O que é um Secret?​

Um Secret é um objeto do Kubernetes que armazena dados sensíveis. Por padrão, os Secrets são codificados em base64 (não criptografados).

Tipos de Secrets​

O Kubernetes suporta vários tipos de Secrets:

  • Opaque: Dados arbitrários (padrão)
  • kubernetes.io/dockerconfigjson: Credenciais para registries Docker
  • kubernetes.io/tls: Certificados TLS
  • kubernetes.io/service-account-token: Tokens de Service Account

Por que Utilizar Secrets?​

Problemas Sem Secrets​

Problemas:

  • Senhas hardcoded no código
  • Risco de exposição no Git
  • Dificuldade de rotação
  • Sem gerenciamento centralizado

Vantagens Com Secrets​

Vantagens:

  • Separados do código da aplicação
  • Gerenciamento centralizado
  • Rotação facilitada
  • Integração com ferramentas externas (Vault, etc.)

Criação de Secrets​

Método 1: A partir de Literais​

kubectl create secret generic db-secret \
  --from-literal=username=admin \
  --from-literal=password=secretpassword123

Método 2: A partir de um Arquivo​

Crie um arquivo password.txt:

mysecretpassword
kubectl create secret generic db-secret \
  --from-file=password=password.txt

Método 3: A partir de um Arquivo YAML​

apiVersion: v1
kind: Secret
metadata:
  name: db-secret
type: Opaque
data:
  username: YWRtaW4=  # base64 de "admin"
  password: cGFzc3dvcmQxMjM=  # base64 de "password123"

Importante: Os valores em data devem ser codificados em base64.

Para codificar:

echo -n "admin" | base64
# Resultado: YWRtaW4=

Tipos de Secrets Especializados​

Secret Docker Registry​

Para acessar um registry Docker privado:

kubectl create secret docker-registry regcred \
  --docker-server=docker.io \
  --docker-username=myuser \
  --docker-password=mypassword \
  --docker-email=myuser@example.com

Uso em um Pod:

spec:
  containers:
  - name: app
    image: private-registry.io/myapp:1.0
  imagePullSecrets:
  - name: regcred

Secret TLS​

Para certificados SSL/TLS:

kubectl create secret tls tls-secret \
  --cert=tls.crt \
  --key=tls.key

Uso em Pods​

Método 1: Variáveis de Ambiente (Uma Chave)​

apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
  - name: app
    image: my-app:1.0
    env:
    - name: DB_USERNAME
      valueFrom:
        secretKeyRef:
          name: db-secret
          key: username
    - name: DB_PASSWORD
      valueFrom:
        secretKeyRef:
          name: db-secret
          key: password

Método 2: Todas as Chaves (envFrom)​

apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
  - name: app
    image: my-app:1.0
    envFrom:
    - secretRef:
        name: db-secret

Método 3: Como Volume (Arquivos)​

apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
  - name: app
    image: my-app:1.0
    volumeMounts:
    - name: secrets
      mountPath: /etc/secrets
      readOnly: true
  volumes:
  - name: secrets
    secret:
      secretName: db-secret
      defaultMode: 0400  # Permissões: somente leitura

Resultado: Cada chave se torna um arquivo em /etc/secrets/ com o valor decodificado.

Segurança dos Secrets​

Limitações Importantes​

Importante:

  • Os Secrets são codificados em base64, não criptografados
  • Acessíveis para quem tem acesso ao etcd
  • Visíveis com kubectl get secret -o yaml
  • Logs podem expor os secrets

Boas Práticas de Segurança​

  1. Ativar Criptografia em Repouso

Crie um arquivo encryption-config.yaml:

apiVersion: apiserver.config.k8s.io/v1
kind: EncryptionConfiguration
resources:
- resources:
  - secrets
  providers:
  - aescbc:
      keys:
      - name: key1
        secret: <base64-encoded-secret>
  - identity: {}  # Permite a descriptografia
  1. Utilizar External Secrets Operator

Para integração com Vault, AWS Secrets Manager, etc.

  1. RBAC Restritivo

Limitar o acesso aos Secrets com RBAC:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: secret-reader
rules:
- apiGroups: [""]
  resources: ["secrets"]
  resourceNames: ["db-secret"]
  verbs: ["get"]
  1. Nunca Comitar os Secrets
  • Use .gitignore para arquivos de secrets
  • Utilize ferramentas de gerenciamento de secrets
  • Rotação regular

Exemplo Completo​

Etapa 1: Criar o Secret​

apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
data:
  database_url: cG9zdGdyZXNxbDovL3VzZXI6cGFzc0BkYjoxMjM0L215ZGI=
  api_key: c2VjcmV0X2FwaV9rZXlfMTIzNDU2
  jwt_secret: bXlfanN0X3NlY3JldF9rZXlfZm9yX3NpZ25pbmc=

Etapa 2: Usar em um Deployment​

apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: webapp
  template:
    metadata:
      labels:
        app: webapp
    spec:
      containers:
      - name: webapp
        image: my-app:1.0
        envFrom:
        - secretRef:
            name: app-secrets
        volumeMounts:
        - name: certs
          mountPath: /etc/ssl/certs
          readOnly: true
      volumes:
      - name: certs
        secret:
          secretName: tls-secret
          defaultMode: 0400

Comandos Úteis​

Ver um Secret (Codificado)​

kubectl get secret db-secret
kubectl describe secret db-secret
kubectl get secret db-secret -o yaml

Decodificar um Secret​

# Ver o valor decodificado
kubectl get secret db-secret -o jsonpath='{.data.password}' | base64 -d

Editar um Secret​

kubectl edit secret db-secret

Nota: Os valores devem estar em base64 no editor.

Remover um Secret​

kubectl delete secret db-secret

Rotação de Secrets​

Processo de Rotação​

Etapas:

  1. Criar um novo Secret com nome diferente
  2. Atualizar o Deployment para referenciar o novo Secret
  3. Aguardar os Pods reiniciarem
  4. Remover o Secret antigo

External Secrets Operator​

Para um gerenciamento avançado com ferramentas externas:

apiVersion: external-secrets.io/v1beta1
kind: ExternalSecret
metadata:
  name: db-secret
spec:
  secretStoreRef:
    name: vault-backend
    kind: SecretStore
  target:
    name: db-secret
  data:
  - secretKey: password
    remoteRef:
      key: production/database/password

Resumo​

Neste capítulo, você aprendeu:

Secret: Objeto Kubernetes para dados sensíveis (base64, não criptografado por padrão)
Tipos: Opaque, docker-registry, TLS, service-account-token
Criação: kubectl create, YAML com valores em base64
Uso: Variáveis de ambiente ou volumes
Segurança: Ativar criptografia em repouso, RBAC, External Secrets
Limitações: Apenas base64, visível no etcd, logs
Rotação: Criar novo secret, atualizar, remover o antigo

Próximos Passos​

Capítulo 5.3: Injeção em Pods
Capítulo 5.4: Boas Práticas
Lab 5.2: Gerenciamento de Secrets

Capítulo criado em: Dezembro 2024