Qual a finalidade e como utilizar ConfigMap

Tiago Temporin

2 anos atrás

Depois de muito tempo sem postar nada sobre Kubernetes, nesse post, vamos falar um pouco sobre o recurso ConfigMap.

ConfigMap é o principal recurso para armazenar dados de configuração. De fácil configuração, um ConfigMap é basicamente uma estrutura chave/valor, onde o valor, pode ser inclusive, um arquivo inteiro, como por exemplo, o arquivo de configuração para o nginx.

Quando olhamos para o ConfigMap de forma isolada, ele não parece trazer muito benefícios para um cluster Kubernetes. No entanto, quando o utilizamos junto a um recurso do tipo deploy, os benefícios ficam mais do que evidentes.

Mas antes de entrar nessa parte, vamos primeiro criar um ConfigMap.

ConfigMap

O início de um manifesto do tipo ConfigMap, é praticamente igual a todos os outros do Kubernetes. Em outras palavras, nessa parte, declaramos a apiVersion, kind e metadata.

apiVersion: v1
kind: ConfigMap
metadata:
  name: api
  namespace: aprenda-golang

Agora, a parte que realmente nos interessa. Diferente daquela enorme quantidade de atributos e configurações que temos em um manifesto de deploy, em um ConfigMap, configuramos somente o atributodata.

É nesse atributo que vamos adicionar todas as configurações que precisamos, no formato chave/valor.

apiVersion: v1
kind: ConfigMap
metadata:
  name: general
  namespace: aprenda-golang
data:
  ENVIRONMENT: prod
  DATABASE_HOST: db.aprendagolang.com.br
  DATABASE_PORT: 3306

Repare que criei todas as chaves com letras maiúsculas. Isso por que, a intenção com esse primeiro exemplo, é configurar as variáveis de ambiente de uma aplicação.

Utilizando o ConfigMap

Antes de exemplificar como utilizar o ConfigMap, vamos imaginar que eu tenho 3 deployments:

No primeiro, preciso utilizar somente o valor da chave ENVIRONMENT;
Já no segundo, preciso utilizar o valor da chave ENVIRONMENT como argumento para execução do programa;
No último, preciso utilizar todas as chaves.

Mapeando chave

Para resolver esse primeiro caso, vamos configurar uma variável de ambiente dentro de spec.containers apontando valor para o ConfigMap general.

spec:
  containers:
    - name: app
      image: registry.aprendagolang.com.br/app:latest
      ports:
        - containerPort: 8888
      env:
        - name: ENVIRONMENT
          valueFrom:
            configMapKeyRef:
              name: general
              key: ENVIRONMENT

Chave como argumento

No segundo caso, a configuração é praticamente a mesma do primeiro. No entanto, como precisamos utilizar a variável como um argumento da aplicação, adicionamos ela entre “$()” no atributo args.

spec:
  containers:
    - name: app
      image: registry.aprendagolang.com.br/app:latest
      args:
        - "-env"
        - "$(ENVIRONMENT)"
      ports:
        - containerPort: 8888
      env:
        - name: ENVIRONMENT
          valueFrom:
            configMapKeyRef:
              name: general
              key: ENVIRONMENT

Todas as chaves

Quando o objetivo é utilizar todas as chaves de um ConfigMap, não há necessidade de mapear cada uma das chaves individualmente.

Tudo que precisa ser feito é “dizer” ao deployment que as variáveis de ambiente virão de um ConfigMap.

spec:
  containers:
    - name: app
      image: registry.aprendagolang.com.br/app:latest
      ports:
        - containerPort: 8888
      envFrom:
      - configMapRef:
          name: general

ConfigMap como arquivo de configuração

Como dito no início do post, também podemos utilizar o ConfigMap para disponibilizar um arquivo de configuração inteiro.

Para exemplificar, criei um novo ConfigMap com as configurações para um nginx.

apiVersion: v1
kind: ConfigMap
metadata:
  name: nginx
  namespace: aprenda-golang
data:
  nginx.conf: |
    user nginx;
    worker_processes  3;
    error_log  /var/log/nginx/error.log;
    events {
      worker_connections  10240;
    }
    http {
      log_format  main
              'remote_addr:$remote_addr\\t'
              'time_local:$time_local\\t'
              'method:$request_method\\t'
              'uri:$request_uri\\t'
              'host:$host\\t'
              'status:$status\\t'
              'bytes_sent:$body_bytes_sent\\t'
              'referer:$http_referer\\t'
              'useragent:$http_user_agent\\t'
              'forwardedfor:$http_x_forwarded_for\\t'
              'request_time:$request_time';
      access_log	/var/log/nginx/access.log main;
      server {
          listen       80;
          server_name  _;
          location / {
              root   html;
              index  index.html index.htm;
          }
      }

Note que, no exemplo acima, o nome da chave é praticamente o nome do arquivo de configuração nginx. Embora isso seja uma pratica comum, não existe uma obrigatoriedade, já que o nome do arquivo será definido no manifesto de deploy.

Agora, no manifesto de deploy, precisamos fazer as seguintes configurações.

spec:
  containers:
    - name: api
      image: registry.aprendagolang.com.br/nginx:latest
      ports:
        - containerPort: 80
      volumeMounts:
      - mounthPath: /etc/nginx
        name: nginx-config
        readOnly: true
  volumes:
  - name: nginx-config
    configMap:
      name: nginx
      items:
      - key: nginx.conf
        path: nginx.conf

Conclusão

ConfigMaps são feitos para armazenar dados de configurações. No entanto, note que em nenhum exemplo temos dados sensíveis, como por exemplo senhas, sendo adicionados à ele.

No próximo post, ainda falando sobre configurações, falarei sobre o recurso que devemos utilizar para armazenar dados sensíveis.

Para ser notificado assim que o post sair, se inscreva na nossa newsletter. Além ficar atualizado, você ainda ganha 20% de desconto em qualquer treinamento, incluindo o curso de Containers & Kubernetes.

Até a próxima!