Dev containers com Docker + VS Code: ambiente reproduzível do zero

Introdução

O desenvolvimento de software é cada vez mais complexo e demanda, tornando-se desafiador garantir a reprodução exata de ambientes de desenvolvimento. Ferramentas como containers com Docker têm sido amplamente utilizadas para solucionar esse problema, permitindo que os desenvolvedores trabalhem em ambientes isolados e controláveis.

A combinação de Docker com o Visual Studio Code (VS Code) torna possível criar ambientes reproduzíveis do zero, onde os desenvolvedores podem trabalhar de forma eficiente e sem preocupações com as dependências e configurações específicas da equipe. Nesse artigo, exploraremos como utilizar containers com Docker em conjunto com o VS Code para criar ambientes reproduzíveis e escaláveis.

Ao final dessa exploração prática, você aprenderá a:

• Configurar ambientes de desenvolvimento isolados utilizando containers com Docker;
• Utilizar o VS Code para criar e gerenciar containers Docker;
• Reproduzir exatamente os mesmos ambientes em diferentes máquinas ou equipes;
• Aumentar a produtividade da equipe ao eliminar as variáveis de dependência e configuração.

O que é e por que importa

Containers com Docker são uma tecnologia de virtualização que permite executar aplicações em ambientes isolados, garantindo a integridade das dependências e configurações específicas do projeto. A ideia central é criar um ambiente self-suficiente, onde todos os componentes necessários para o funcionamento da aplicação estão presentes, incluindo bibliotecas, frameworks e outros recursos.

A motivação por trás da utilização de containers Docker está em resolver problemas típicos no desenvolvimento de software, como:

• Variabilidade das dependências: diferentes equipes ou máquinas podem ter configurações e dependências diferentes;
• Configurações específicas do projeto: é comum que os projetos tenham requisitos específicos para execução, como bancos de dados, servidores de cache ou outros recursos;
• Complexidade na gestão dos ambientes: a criação e gerenciamento de ambientes de desenvolvimento pode ser um processo complexo e demorado.

Ao utilizar containers Docker em conjunto com o VS Code, é possível criar ambientes reproduzíveis do zero, eliminando as variáveis de dependência e configuração. Isso permite que os desenvolvedores trabalhem de forma eficiente, focados no código e na lógica da aplicação, sem preocupações com a criação e manutenção dos ambientes.

Como funciona na prática

Ao trabalhar com containers Docker no VS Code, há algumas etapas importantes que ocorrem por trás dos bastidores para criar ambientes reproduzíveis do zero:

• Definição de imagens Docker: é necessário definir as imagens Docker que irão compor o ambiente. Isso envolve especificar os repositórios de código-fonte, bibliotecas e frameworks necessários.
• Criação de containers: a partir das imagens Docker definidas, são criados containers que simbolizam o ambiente isolado para a aplicação. Cada container é um "pacote" com todas as dependências e configurações específicas do projeto.
• Injeção de recursos: os containers recebem recursos necessários, como volumes (áreas de armazenamento compartilhadas), rede e até mesmo servidores de banco de dados ou outros serviços.
• Conexão dos containers: se necessário, os containers podem se comunicar entre si, permitindo que as aplicações compartilhem recursos ou serviços sem a necessidade de configurações adicionais.
• Execução da aplicação: com o ambiente preparado e configurado corretamente, a aplicação é executada dentro do container. O VS Code fornece ferramentas para monitorar e debugar a execução da aplicação em tempo real.

Ao integrar Docker no fluxo de trabalho com o VS Code, os desenvolvedores podem aproveitar ao máximo as vantagens dos ambientes reproduzíveis e isolados, maximizando a produtividade e reduzindo erros e problemas relacionados às variáveis de dependência e configuração.

Exemplo real

Vamos criar um exemplo simples de uma aplicação Node.js que utiliza MongoDB como banco de dados. O objetivo é criar um ambiente reproduzível para a aplicação, com todas as dependências e configurações específicas do projeto.

// Arquivo docker-compose.yml
version: '3'
services:
  backend:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - mongo
    environment:
      MONGO_URI: mongodb://mongo:27017/
  mongo:
    image: mongo:latest

// Arquivo Dockerfile (dentro da pasta do projeto)
RUN npm install

COPY . /app

CMD ["node", "server.js"]

// Arquivo server.js (dentro da pasta do projeto)
const express = require('express');
const app = express();
const mongoose = require('mongoose');

mongoose.connect('mongodb://mongo:27017/', { useNewUrlParser: true, useUnifiedTopology: true });

app.listen(3000, () => {
  console.log('Servidor rodando na porta 3000');
});

Nesse exemplo, estamos criando um ambiente reproduzível para uma aplicação Node.js que utiliza MongoDB como banco de dados. O arquivo docker-compose.yml define dois serviços: o backend e o mongo. O serviço backend é responsável por executar a aplicação, enquanto o serviço mongo é responsável por executar o container do MongoDB.

O arquivo Dockerfile é utilizado para criar uma imagem Docker personalizada para a aplicação, que inclui as dependências necessárias (express e mongoose) e o código-fonte da aplicação.

Por fim, o arquivo server.js define a configuração básica da aplicação, incluindo a conexão com o banco de dados MongoDB.

Boas práticas

Utilize um Dockerfile separado para dependências compartilhadas

Se sua aplicação e serviços dependentes compartilham as mesmas dependências, como Node.js ou uma biblioteca específica, é recomendável criar um Dockerfile separado para essas dependências. Isso evitará a duplicidade de dependências no projeto.

Utilize volumes do Docker para persistência de dados

Em vez de usar o container como uma base para armazenar dados persistentes, utilize volumes do Docker para persistir os dados fora do container. Isso facilita a gestão e a recuperação de dados em caso de falhas ou atualizações.

Utilize o comando docker-compose up --build para construir e subir serviços

Em vez de utilizar o comando docker-compose build separado, use docker-compose up --build para construir as imagens necessárias antes de subir os serviços. Isso evita a necessidade de parar e reiniciar o processo de construção.

Utilize um sistema de gerenciamento de dependências para controlar versões

Utilize um sistema de gerenciamento de dependências, como npm ou yarn, para controlar as versões das dependências da aplicação. Isso garante que as dependências estejam atualizadas e compatíveis com a aplicação.

Utilize o comando docker-compose exec para executar comandos no container

Em vez de acessar o container por meio do shell, utilize o comando docker-compose exec para executar comandos diretamente no container. Isso evita a necessidade de sair e entrar no container.

Armadilhas comuns

Não compartilhe containers entre desenvolvedores ou ambientes

Compartilhar containers pode causar problemas de compatibilidade, versionamento e gestão de dependências. Cada vez que um desenvolvedor trabalha em uma aplicação diferente, é recomendável criar um novo container para evitar conflitos.

Não use versões antigas do Docker ou Docker Compose

As versões antigas podem apresentar bugs e problemas conhecidos. Sempre verifique se a sua versão está atualizada para garantir que você esteja trabalhando com as funcionalidades mais recentes e seguras.

Não utilize o comando docker-compose up sem a opção -d

O comando docker-compose up pode executar os serviços no modo interativo, bloqueando a consola do usuário. Use a opção -d para executar os serviços em segundo plano e evitar problemas de desempenho.

Não utilize volumes do Docker como uma solução para persistência de dados

Embora os volumes sejam úteis para armazenar dados persistentes, eles não são projetados para serem usados como um banco de dados. Use um sistema de gerenciamento de bancos de dados dedicado, como MongoDB ou PostgreSQL.

Não utilize o comando docker-compose down sem a opção -v

O comando docker-compose down pode remover os volumes do Docker, mas não é garantido que todos os volumes sejam removidos. Use a opção -v para remover os volumes explicitamente e evitar problemas de persistência.

Conclusão

Os dev containers oferecem benefícios significativos ao desenvolvimento de software, como ambientes isolados e reprodutíveis. No entanto, é fundamental estar ciente das armadilhas comuns que podem afetar a eficiência e estabilidade do processo.

Ao adotar os dev containers, é crucial criar um ambiente de trabalho consistente, compartilhando conhecimentos e boas práticas entre o time. Além disso, é importante monitorar as atualizações da ferramenta Docker e utilizar a versão mais recente para evitar problemas conhecidos.

Proximamente, é recomendável explorar recursos avançados do Docker, como as features de segurança e autenticação, além de aprender sobre gerenciamento de configurações de ambiente com ferramentas como Ansible ou Terraform. Isso permitirá aos desenvolvedores criar ambientes mais robustos e escaláveis, contribuindo para a agilidade e eficiência no ciclo de vida do software.

Referências

• Docker. Guia de Inicialização. Disponível em: https://docs.docker.com/get-docker/. Acesso: 2024.
• VS Code. Guia para Desenvolvedores. Disponível em: https://code.visualstudio.com/docs. Acesso: 2024.
• Martin Fowler. Containerisation and the Cloud. Disponível em: https://martinfowler.com/bliki/Containerisation.html. Acesso: 2024.
• Docker. Documentação Oficial do Compose. Disponível em: https://docs.docker.com/compose/. Acesso: 2024.
• OWASP. Guia de Segurança para Aplicações Containerizadas. Disponível em: https://owasp.org/www-pdf/OWASP_Cloud_Computing_Top_10-2017.pdf. Acesso: 2024.