A utilização de Docker tem se tornado uma prática comum entre desenvolvedores e equipes de operações devido à sua capacidade de proporcionar isolamento por volume e facilitar o gerenciamento de aplicações. Neste contexto, uma das maiores vantagens é a habilidade de executar várias versões do mesmo serviço em um único host, permitindo testar novas funcionalidades sem impactar o ambiente de produção.

Para alcançar esse objetivo, é fundamental entender como configurar portas distintas para cada instância do serviço. Essa configuração garante que as aplicações não interfiram entre si, possibilitando um deploy mais seguro e controlado. Assim, a implementação de versões diferentes torna-se não apenas factível, mas também prática, contribuindo para uma estratégia de deploy a/b que permite comparar as eficácias de cada versão em tempo real.

Neste artigo, vamos explorar as melhores práticas para rodar múltiplas versões de um serviço usando Docker, discutindo desde a configuração inicial até a realização de testes eficazes, tudo isso enquanto mantemos a integridade de cada ambiente isolado.

Criando uma imagem Docker para múltiplas versões

Para criar uma imagem Docker que suporte múltiplas versões do mesmo serviço, é fundamental estruturar adequadamente os arquivos de configuração e definição da imagem.

Primeiramente, você deve criar um Dockerfile que permita especificar a versão desejada como um argumento. Assim, cada vez que uma imagem é construída, é possível escolher a versão que será utilizada.

FROM node:{versão}
WORKDIR /app
COPY . .
RUN npm install
CMD ["node", "app.js"]

Neste exemplo, substitua {versão} pela versão real do Node que você deseja usar. Isso proporciona flexibilidade para construir imagens com diferentes versões conforme necessário.

Outra abordagem é utilizar o docker-compose para definir containers que possam rodar simultaneamente. Criando um arquivo docker-compose.yml, você poderá especificar múltiplos serviços, cada um com sua própria configuração de versão.

version: '3'
services:
app_v1:
build:
context: .
dockerfile: Dockerfile
args:
versao: '14'
app_v2:
build:
context: .
dockerfile: Dockerfile
args:
versao: '16'

Com essa configuração, o docker-compose irá criar e gerenciar as diferentes versões do serviço, permitindo que você teste e utilize várias instâncias de forma isolada.

Por fim, lembre-se da importância de gerenciar as dependências e variáveis de ambiente de cada versão, utilizando arquivos de configuração específicos quando necessário, assim você garante que cada instância funcione conforme o esperado.

Configurando o Docker Compose para gerenciar diferentes versões

O Docker Compose simplifica a orquestração de múltiplos containers, e se torna uma ferramenta poderosa para gerenciar diferentes versões de um mesmo serviço. Usando o Compose, podemos definir a configuração de cada versão em um arquivo `docker-compose.yml` ou múltiplos arquivos, facilitando o deploy e o rollback.

Para implementar o versionamento paralelo, cada versão do serviço deve possuir um nome de container distinto, evitando conflitos de rede e nomes. Podemos realizar isso definindo um `container_name` específico para cada serviço no arquivo `docker-compose.yml`. Além disso, o isolamento por volume é crucial. Certifique-se de que cada versão utilize volumes distintos para dados persistentes, evitando a sobrescrita ou o compartilhamento indesejado de dados entre as versões.

Exemplo:

version: "3.9"
services:
meu_servico_v1:
image: meu_servico:v1
container_name: meu_servico_v1
ports:
- "8080:8080"
volumes:
- meu_volume_v1:/data
meu_servico_v2:
image: meu_servico:v2
container_name: meu_servico_v2
ports:
- "8081:8080"
volumes:
- meu_volume_v2:/data
volumes:
meu_volume_v1:
meu_volume_v2:

Neste exemplo, temos duas versões do `meu_servico`: `v1` e `v2`. Cada uma tem seu próprio nome de container, porta e volume. Isto permite que ambas as versões rodem simultaneamente sem conflitos.

Para um deploy A/B, você pode rotear o tráfego para diferentes versões do serviço, monitorando o desempenho de cada uma. Com Docker Compose, é possível controlar a quantidade de instâncias de cada versão, permitindo ajustar a distribuição do tráfego durante o deploy.

Atualizar versões com Docker Compose é simples. Altere a tag da imagem no arquivo `docker-compose.yml` e execute `docker-compose up -d` para recriar o container com a nova versão, mantendo o isolamento das versões anteriores.

Alternando entre versões do serviço durante a execução

Uma das principais vantagens de utilizar o Docker é a capacidade de gerenciar múltiplas versões de um mesmo serviço. Isso permite que você faça rollback de versão com facilidade, além de possibilitar o deploy A/B para testar novas funcionalidades de forma controlada.

Para alternar entre versões durante a execução, você pode utilizar recursos como o isolamento por volume. Dessa forma, os dados específicos de cada versão ficam armazenados em volumes separados, garantindo o versionamento paralelo e evitando conflitos entre as diferentes versões do serviço.

Outra abordagem é utilizar o multi build, que permite que você construa e gerencie diferentes versões da sua imagem Docker em um único processo. Isso facilita a automação do processo de implantação e simplifica a manutenção do seu ambiente.

Atualizando e fazendo rollback de versões do serviço

Implementar atualizações e rollback de versão de forma segura e controlada é crucial ao executar múltiplas versões de um serviço com Docker. Aqui estão algumas estratégias e considerações importantes:

• Atualizações Graduais: Em vez de substituir todas as instâncias de uma versão por outra simultaneamente, implemente uma atualização gradual. Isso pode ser alcançado substituindo containers um por um ou em pequenos grupos, monitorando a saúde da nova versão antes de prosseguir.
• Testes Lado a Lado: Utilize o versionamento paralelo para executar a nova versão ao lado da versão antiga, roteando uma pequena porcentagem do tráfego para a nova versão. Isso permite testes em produção com dados reais, minimizando o risco de interrupções. O compose múltiplo pode auxiliar nesta configuração.
• Monitoramento Contínuo: Implemente um sistema de monitoramento robusto para acompanhar a saúde, desempenho e logs de todas as versões em execução. Defina alertas para detectar anomalias e problemas o mais rápido possível.
• Estratégia de Rollback: Tenha um plano de rollback de versão bem definido e automatizado. Se a nova versão apresentar problemas, você deve ser capaz de reverter rapidamente para a versão anterior. Este processo deve ser o mais automatizado possível.

Considerações Técnicas:

• Portas Distintas: Ao executar múltiplas versões do mesmo serviço, cada versão deve utilizar portas distintas. Isso garante que não haja conflitos e que o tráfego seja roteado corretamente para cada versão.
• Isolamento por Volume: Se as diferentes versões do serviço exigem configurações ou dados diferentes, utilize o isolamento por volume para separar os dados de cada versão.
• Versionamento Dinâmico: Implemente um sistema de versionamento dinâmico para rastrear e gerenciar as diferentes versões do seu serviço. Isso pode incluir tags de imagem Docker, variáveis de ambiente ou outros mecanismos. Consulte https://mundodocker.com.br/ para mais informações.
• Multi Build: A utilização de `multi build` dentro do Dockerfile pode auxiliar na criação de imagens otimizadas para diferentes versões, reduzindo o tamanho da imagem e o tempo de build.
• Containers Simultâneos: Gerencie cuidadosamente a execução de containers simultâneos, garantindo recursos suficientes para cada versão e evitando gargalos.

A chave para um bom sistema de versionamento e rollback de versão é o planejamento e a automação. Teste seu processo de rollback de versão regularmente para garantir que ele funcione conforme o esperado e esteja preparado para lidar com problemas inesperados. Um bom planejamento garante um rollback de versão rápido e eficaz.