Gerenciamento de Secrets e Configurações no Kubernetes

Introdução

Em um ambiente Kubernetes, o gerenciamento de configurações e secrets é um aspecto crucial para o deploy e a manutenção das aplicações. Este artigo explora os diferentes métodos para gerenciar esses elementos de forma segura e eficiente.

ConfigMaps: Gerenciamento de Configurações

Os ConfigMaps são objetos do Kubernetes que permitem armazenar dados não confidenciais na forma de pares chave-valor. Eles são ideais para separar a configuração da aplicação do código, facilitando alterações sem precisar reconstruir a imagem.

Criação de um ConfigMap

Método 1: A partir de um arquivo

# Créer un fichier de configuration
cat > app-config.properties << EOF
APP_ENV=production
LOG_LEVEL=info
API_URL=https://api.example.com
EOF

# Créer un ConfigMap à partir du fichier
kubectl create configmap app-config --from-file=app-config.properties

Método 2: A partir de linhas de comando

kubectl create configmap app-config \
  --from-literal=APP_ENV=production \
  --from-literal=LOG_LEVEL=info \
  --from-literal=API_URL=https://api.example.com

Método 3: Definição em YAML

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  APP_ENV: production
  LOG_LEVEL: info
  API_URL: https://api.example.com

Uso dos ConfigMaps

1. Variáveis de ambiente

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        envFrom:
        - configMapRef:
            name: app-config

2. Variáveis de ambiente individuais

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        env:
        - name: APP_ENV
          valueFrom:
            configMapKeyRef:
              name: app-config
              key: APP_ENV
        - name: LOG_LEVEL
          valueFrom:
            configMapKeyRef:
              name: app-config
              key: LOG_LEVEL

3. Arquivos de configuração

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        volumeMounts:
        - name: config-volume
          mountPath: /app/config
      volumes:
      - name: config-volume
        configMap:
          name: app-config

Secrets: Gerenciamento de Dados Sensíveis

Os Secrets são semelhantes aos ConfigMaps, mas foram concebidos para armazenar dados sensíveis, como senhas, tokens de API e chaves privadas. O Kubernetes armazena os secrets em base64, mas isso não constitui uma criptografia real.

Criação de um Secret

Método 1: A partir de linhas de comando

kubectl create secret generic app-secrets \
  --from-literal=DB_USERNAME=admin \
  --from-literal=DB_PASSWORD=secretpassword

Método 2: A partir de um arquivo

# Créer un fichier de secrets
cat > app-secrets.txt << EOF
DB_USERNAME=admin
DB_PASSWORD=secretpassword
EOF

# Créer un Secret à partir du fichier
kubectl create secret generic app-secrets --from-file=app-secrets.txt

Método 3: Definição em YAML (com valores em base64)

apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
data:
  DB_USERNAME: YWRtaW4=  # base64 de "admin"
  DB_PASSWORD: c2VjcmV0cGFzc3dvcmQ=  # base64 de "secretpassword"

Uso dos Secrets

1. Variáveis de ambiente

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        envFrom:
        - secretRef:
            name: app-secrets

2. Variáveis de ambiente individuais

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        env:
        - name: DB_USERNAME
          valueFrom:
            secretKeyRef:
              name: app-secrets
              key: DB_USERNAME
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: app-secrets
              key: DB_PASSWORD

3. Arquivos de configuração

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        volumeMounts:
        - name: secret-volume
          mountPath: /app/secrets
          readOnly: true
      volumes:
      - name: secret-volume
        secret:
          secretName: app-secrets

Boas Práticas para o Gerenciamento de Secrets

1. Usar um Gerenciador de Secrets Externo

O Kubernetes armazena os secrets em base64, o que não constitui uma criptografia real. Para uma segurança reforçada, use um gerenciador de secrets externo, como:

• HashiCorp Vault: solução completa de gerenciamento de secrets
• AWS Secrets Manager: serviço gerenciado para os secrets da AWS
• Azure Key Vault: serviço de gerenciamento de secrets do Azure
• Google Secret Manager: serviço de gerenciamento de secrets do GCP

Integração com o Vault

apiVersion: secrets.hashicorp.com/v1beta1
kind: VaultAuth
metadata:
  name: vault-auth
spec:
  method: kubernetes
  mount: kubernetes
  kubernetes:
    role: application
    serviceAccount: vault-auth
    tokenReviewerJWT: ""
---
apiVersion: secrets.hashicorp.com/v1beta1
kind: VaultSecret
metadata:
  name: app-secrets
spec:
  vaultAuthRef: vault-auth
  path: secret/data/application
  type: Opaque

2. Usar Secrets para Registries de Contêineres

Para acessar registries de contêineres privados, use secrets do tipo docker-registry:

kubectl create secret docker-registry regcred \
  --docker-server=<your-registry-server> \
  --docker-username=<your-username> \
  --docker-password=<your-password> \
  --docker-email=<your-email>

Em seguida, referencie-o no seu deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  template:
    spec:
      imagePullSecrets:
      - name: regcred
      containers:
      - name: myapp
        image: private-registry.example.com/myapp:1.0

3. Usar Secrets para Certificados TLS

Para certificados TLS, use secrets do tipo tls:

kubectl create secret tls tls-secret \
  --cert=path/to/tls.cert \
  --key=path/to/tls.key

Em seguida, use-o no seu Ingress:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: tls-ingress
spec:
  tls:
  - hosts:
    - example.com
    secretName: tls-secret
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: app-service
            port:
              number: 80

4. Rotação dos Secrets

Implemente uma estratégia de rotação regular dos secrets:

apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
  annotations:
    kubernetes.io/change-cause: "Rotation des secrets - 2024-05-10"
type: Opaque
data:
  DB_PASSWORD: <new-base64-encoded-password>

Gerenciamento Avançado de Configurações

1. ConfigMaps para Arquivos de Configuração

Para aplicações que exigem arquivos de configuração completos:

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  nginx.conf: |
    server {
      listen 80;
      server_name example.com;
      location / {
        proxy_pass http://backend;
      }
    }
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  template:
    spec:
      containers:
      - name: nginx
        image: nginx:1.19
        volumeMounts:
        - name: config-volume
          mountPath: /etc/nginx/conf.d
      volumes:
      - name: config-volume
        configMap:
          name: app-config

2. ConfigMaps para Scripts de Inicialização

Para scripts de inicialização ou de configuração:

apiVersion: v1
kind: ConfigMap
metadata:
  name: init-scripts
data:
  init.sh: |
    #!/bin/bash
    echo "Initializing application..."
    # Script d'initialisation
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  template:
    spec:
      initContainers:
      - name: init
        image: busybox
        command: ["/scripts/init.sh"]
        volumeMounts:
        - name: scripts-volume
          mountPath: /scripts
      containers:
      - name: myapp
        image: myapp:1.0
      volumes:
      - name: scripts-volume
        configMap:
          name: init-scripts
          defaultMode: 0755

3. Uso do Helm para o Gerenciamento de Configurações

O Helm é um gerenciador de pacotes para Kubernetes que simplifica o gerenciamento de configurações:

# values.yaml
config:
  APP_ENV: production
  LOG_LEVEL: info
secrets:
  DB_PASSWORD: secretpassword
---
# templates/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}-deployment
spec:
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:{{ .Values.image.tag }}
        env:
        - name: APP_ENV
          value: {{ .Values.config.APP_ENV }}
        - name: LOG_LEVEL
          value: {{ .Values.config.LOG_LEVEL }}
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: {{ .Release.Name }}-secrets
              key: DB_PASSWORD

Segurança dos Secrets

1. Criptografia em Repouso (Encryption at Rest)

Ative a criptografia em repouso para os secrets no etcd:

apiVersion: apiserver.config.k8s.io/v1
kind: EncryptionConfiguration
resources:
  - resources:
    - secrets
    providers:
    - aescbc:
        keys:
        - name: key1
          secret: <base64-encoded-key>
    - identity: {}

2. RBAC para os Secrets

Use o RBAC para limitar o acesso aos secrets:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: secret-reader
rules:
- apiGroups: [""]
  resources: ["secrets"]
  verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: secret-reader-binding
subjects:
- kind: ServiceAccount
  name: app-service-account
  namespace: default
roleRef:
  kind: Role
  name: secret-reader
  apiGroup: rbac.authorization.k8s.io

3. Auditoria dos Secrets

Ative a auditoria para acompanhar o acesso aos secrets:

apiVersion: audit.k8s.io/v1
kind: Policy
rules:
- level: Metadata
  users: ["system:serviceaccount"]
  verbs: ["get", "list", "watch"]
  resources:
  - group: ""
    resources: ["secrets"]

Exemplo Completo: Aplicação com ConfigMaps e Secrets

Veja um exemplo completo de uma aplicação que utiliza ConfigMaps e Secrets:

# ConfigMap pour la configuration de l'application
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  APP_ENV: production
  LOG_LEVEL: info
  API_URL: https://api.example.com
  nginx.conf: |
    server {
      listen 80;
      server_name example.com;
      location / {
        proxy_pass http://backend;
      }
    }
---
# Secret pour les données sensibles
apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
data:
  DB_USERNAME: YWRtaW4=  # base64 de "admin"
  DB_PASSWORD: c2VjcmV0cGFzc3dvcmQ=  # base64 de "secretpassword"
---
# Déploiement de l'application
apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        ports:
        - containerPort: 8080
        envFrom:
        - configMapRef:
            name: app-config
        - secretRef:
            name: app-secrets
        volumeMounts:
        - name: config-volume
          mountPath: /app/config
        - name: nginx-config-volume
          mountPath: /etc/nginx/conf.d
      volumes:
      - name: config-volume
        configMap:
          name: app-config
      - name: nginx-config-volume
        configMap:
          name: app-config
---
# Service pour exposer l'application
apiVersion: v1
kind: Service
metadata:
  name: app-service
spec:
  selector:
    app: myapp
  ports:
  - port: 80
    targetPort: 8080
  type: LoadBalancer

Conclusão

O gerenciamento eficiente de secrets e configurações é essencial para o deploy seguro de aplicações no Kubernetes. Ao usar ConfigMaps para dados não confidenciais e Secrets para dados sensíveis, você pode separar a configuração do código e facilitar as alterações sem reconstruir as imagens.

Para uma segurança reforçada, considere usar um gerenciador de secrets externo, como o HashiCorp Vault, que oferece criptografia real e recursos avançados de gerenciamento de secrets.

No próximo artigo, vamos explorar monitoramento e logging no Kubernetes, aspectos cruciais para manter a saúde e o desempenho das suas aplicações.