Pular para o conteúdo principal

Capítulo 5.1 - ConfigMaps

Objetivos de Aprendizagem​

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

  • Entender o que é um ConfigMap e por que utilizá-lo
  • Criar ConfigMaps de diferentes maneiras
  • Utilizar ConfigMaps em seus Pods
  • Separar a configuração do código da aplicação
  • Aplicar boas práticas para ConfigMaps

Introdução​

No desenvolvimento de aplicações, a configuração frequentemente muda conforme o ambiente (desenvolvimento, staging, produção). Hardcodear a configuração no código ou nas imagens Docker não é uma boa prática.

Os ConfigMaps permitem separar a configuração do código da aplicação.

O que é um ConfigMap?​

Um ConfigMap é um objeto do Kubernetes que armazena dados de configuração não sensíveis em pares chave-valor. Esses dados podem ser utilizados pelos Pods como variáveis de ambiente, argumentos de comando ou arquivos de configuração.

Por que Utilizar ConfigMaps?​

Problemas Sem ConfigMaps​

Problemas:

  • Configuração hardcoded no código
  • Necessidade de rebuild da imagem para mudar a config
  • Difícil gerenciar diferentes ambientes
  • Não há separação de responsabilidades

Vantagens Com ConfigMaps​

Vantagens:

  • Configuração separada do código
  • Não é necessário rebuild da imagem
  • Fácil gerenciar múltiplos ambientes
  • Reutilizável entre vários Pods

Criação de ConfigMaps​

Método 1: A partir de Literais​

kubectl create configmap app-config \
  --from-literal=database_url=postgresql://localhost:5432/mydb \
  --from-literal=log_level=info \
  --from-literal=max_connections=100

Método 2: A partir de um Arquivo​

Crie um arquivo config.properties:

database_url=postgresql://localhost:5432/mydb
log_level=info
max_connections=100
kubectl create configmap app-config --from-file=config.properties

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

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
  namespace: default
data:
  database_url: "postgresql://localhost:5432/mydb"
  log_level: "info"
  max_connections: "100"
  # Arquivo completo
  application.properties: |
    server.port=8080
    server.host=0.0.0.0
    spring.datasource.url=jdbc:postgresql://localhost:5432/mydb

Utilização nos 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: DATABASE_URL
      valueFrom:
        configMapKeyRef:
          name: app-config
          key: database_url
    - name: LOG_LEVEL
      valueFrom:
        configMapKeyRef:
          name: app-config
          key: log_level

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:
    - configMapRef:
        name: app-config

Resultado: Todas as chaves do ConfigMap se tornam variáveis de ambiente.

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: config
      mountPath: /etc/config
      readOnly: true
  volumes:
  - name: config
    configMap:
      name: app-config

Resultado: Cada chave se torna um arquivo em /etc/config/ com o valor como conteúdo.

Exemplo Completo​

Etapa 1: Criar o ConfigMap​

apiVersion: v1
kind: ConfigMap
metadata:
  name: webapp-config
data:
  # Variáveis simples
  APP_NAME: "My Web Application"
  APP_VERSION: "1.0.0"
  ENVIRONMENT: "production"
  
  # Arquivo de configuração
  nginx.conf: |
    server {
        listen 80;
        server_name example.com;
        root /usr/share/nginx/html;
        index index.html;
    }

Etapa 2: Utilizar 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: nginx:1.20
        env:
        - name: APP_NAME
          valueFrom:
            configMapKeyRef:
              name: webapp-config
              key: APP_NAME
        - name: ENVIRONMENT
          valueFrom:
            configMapKeyRef:
              name: webapp-config
              key: ENVIRONMENT
        volumeMounts:
        - name: nginx-config
          mountPath: /etc/nginx/conf.d
          readOnly: true
      volumes:
      - name: nginx-config
        configMap:
          name: webapp-config
          items:
          - key: nginx.conf
            path: default.conf

Casos de Uso​

1. Configuração de Aplicação​

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-settings
data:
  database_host: "db.example.com"
  database_port: "5432"
  cache_ttl: "3600"
  feature_flags: "feature1,feature2"

2. Arquivos de Configuração​

apiVersion: v1
kind: ConfigMap
metadata:
  name: nginx-config
data:
  nginx.conf: |
    events {
        worker_connections 1024;
    }
    http {
        include /etc/nginx/mime.types;
        default_type application/octet-stream;
    }

3. Scripts​

apiVersion: v1
kind: ConfigMap
metadata:
  name: init-scripts
data:
  init.sh: |
    #!/bin/bash
    echo "Inicializando aplicação..."
    /app/setup.sh
    exec /app/start.sh

Boas Práticas​

1. Organização por Ambiente​

Crie ConfigMaps separados para cada ambiente:

# Desenvolvimento
kubectl create configmap app-config-dev --from-file=config-dev.properties

# Produção
kubectl create configmap app-config-prod --from-file=config-prod.properties

2. Versionamento​

Use labels para versionar:

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
  labels:
    version: v1
    environment: production
data:
  # ...

3. Não Armazenar Dados Sensíveis​

Nunca coloque em um ConfigMap:

  • Senhas
  • Tokens de API
  • Chaves privadas
  • Certificados

Utilize Secrets para isso.

Comandos Úteis​

Ver um ConfigMap​

kubectl get configmap app-config
kubectl describe configmap app-config
kubectl get configmap app-config -o yaml

Editar um ConfigMap​

kubectl edit configmap app-config

Nota: Os Pods existentes não verão as mudanças imediatamente. É necessário reiniciá-los.

Remover um ConfigMap​

kubectl delete configmap app-config

Limitações​

Tamanho Máximo​

  • 1 MiB por entrada em um ConfigMap
  • Total limitado pelo etcd (geralmente ~1.5 MiB por objeto)

Atualização​

  • Variáveis de ambiente: Não mudam sem reiniciar o Pod
  • Volumes: Atualizados periodicamente (delay de alguns segundos)

Resumo​

Neste capítulo, você aprendeu:

ConfigMap: Objeto do Kubernetes para armazenar configuração não sensível
Criação: kubectl create, YAML, a partir de arquivos
Utilização: Variáveis de ambiente (env/envFrom) ou volumes
Vantagens: Separação config/código, flexibilidade, reutilização
Boas práticas: Organização por ambiente, versionamento, não armazenar segredos
Limitações: Tamanho máximo, atualização exige reinício para env vars

Próximos Passos​

Capítulo 5.2: Secrets - Gerenciamento de dados sensíveis
Lab 5.1: Criação e Utilização de ConfigMaps

Capítulo criado em: Dezembro 2024