Docker para Iniciantes: Um Guia Prático para Contêineres

Conceitos Básicos do Docker

Agora que você tem o Docker instalado, pode estar ansioso para começar a executar containers. Mas antes de fazer isso, é importante entender alguns conceitos-chave que formam a base do trabalho do Docker. Esses conceitos irão ajudá-lo a navegar no Docker de forma mais eficaz e evitar armadilhas comuns para iniciantes.

No cerne do Docker estão imagens, que servem como plantas para os containers; containers, que são as instâncias em execução dessas imagens; e Docker Hub, um repositório centralizado para compartilhar e gerenciar imagens.

Vamos explorar cada um desses conceitos em mais detalhes.

Imagens do Docker

As imagens do Docker são os blocos de construção fundamentais dos containers. Elas são modelos imutáveis e somente leitura que contêm tudo o que é necessário para executar uma aplicação, incluindo o sistema operacional, código da aplicação, tempo de execução e dependências.

As imagens são construídas usando um Dockerfile, que define as instruções para criar uma imagem camada por camada.

As imagens podem ser armazenadas e recuperadas de registros de containers como o Docker Hub.

Aqui estão alguns comandos de exemplo para trabalhar com imagens:

• docker pull nginx: Buscar a última imagem do Nginx no Docker Hub.
• docker images: Listar todas as imagens disponíveis na máquina local.
• docker rmi nginx: Remover uma imagem da máquina local.

Containers do Docker

Um container do Docker é uma instância em execução de uma imagem do Docker. Os containers fornecem um ambiente de tempo de execução isolado onde as aplicações podem ser executadas sem interferir umas com as outras ou com o sistema hospedeiro. Cada container possui seu próprio sistema de arquivos, rede e espaço de processos, mas compartilha o kernel do hospedeiro.

Os containers seguem um ciclo de vida simples envolvendo criação, inicialização, parada e exclusão. Aqui está uma lista de comandos comuns de gerenciamento de containers:

1. Criando um contêiner: docker create ou docker run
2. Iniciando um contêiner: docker start
3. Parando um contêiner: docker stop
4. Reiniciando um contêiner: docker restart
5. Excluindo um contêiner: docker rm

Vamos ver um exemplo prático. O comando a seguir executa um contêiner do Nginx em modo detachado (executando em segundo plano), mapeando a porta 80 dentro do contêiner para a porta 8080 na máquina hospedeira:

docker run -d -p 8080:80 nginx

Após executar este comando, o Docker irá baixar a imagem do Nginx (se ainda não estiver disponível), criar um contêiner e iniciá-lo.

Para verificar todos os contêineres em execução e parados:

docker ps -a

Isso irá exibir uma lista de todos os containers e detalhes como o status deles e as portas atribuídas.

Hub Docker

O Hub Docker é um serviço de registro baseado em nuvem para encontrar, armazenar e distribuir imagens de containers. Os usuários podem enviar imagens personalizadas para o Hub Docker e compartilhá-las publicamente ou de forma privada.

Aqui estão alguns comandos para interagir com o Hub Docker:

• docker login: Autenticar com o Hub Docker.
• docker push my-image: Enviar uma imagem personalizada para o Hub Docker.
• docker search ubuntu: Buscar imagens oficiais e da comunidade.
• docker pull ubuntu: Baixar uma imagem do Ubuntu do Hub Docker.

Novo na containerização? Obtenha uma base sólida com o curso Conceitos de Containerização e Virtualização.

Executando Seu Primeiro Container Docker

Agora que cobrimos os conceitos principais do Docker, é hora de colocá-los em ação! Vamos começar executando nosso primeiro container para garantir que o Docker esteja instalado corretamente e funcionando conforme o esperado.

Para testar sua instalação do Docker, abra o PowerShell (Windows) ou Terminal (Mac e Linux) e execute:

docker run hello-world

Isso baixa a imagem hello-world do DockerHub e a executa em um container.

Exemplo de imagem hello-world do Docker

Agora, vamos um passo adiante e executar uma aplicação do mundo real – um servidor web Nginx. Execute o seguinte comando:

docker run -d -p 8080:80 nginx

O comando acima faz o seguinte:

• A flag -d executa o contêiner no modo destacado, o que significa que ele é executado em segundo plano.
• A flag -p 8080:80 mapeia a porta 80 dentro do contêiner para a porta 8080 em sua máquina local, permitindo que você acesse o servidor web.

Assim que o comando for executado com sucesso, abra um navegador e visite: http://localhost:8080

Acessando o servidor web em localhost:8080

Você deverá ver a página de boas-vindas padrão do Nginx, confirmando que seu servidor web está em execução dentro de um contêiner!

Você também verá um contêiner em execução em seu Docker Desktop:

Contêiner Nginx em execução na porta 8080

Construindo Sua Primeira Imagem Docker

Até agora, temos utilizado imagens pré-configuradas do Docker Hub. Mas e se você precisar de um ambiente personalizado adaptado à sua aplicação? É aí que entra a construção da sua própria imagem Docker.

A criação de uma imagem Docker envolve a escrita de um Dockerfile, um script que automatiza a construção da imagem. Isso garante consistência e portabilidade em diferentes ambientes. Uma vez que uma imagem é construída, ela pode ser executada como um contêiner para executar aplicações em um ambiente isolado.

Nesta seção, vamos aprender os fundamentos da escrita de um Dockerfile, construção de uma imagem personalizada e execução dela como um contêiner.

Princípios básicos do Dockerfile

Um Dockerfile é um script contendo uma série de instruções que definem como uma imagem Docker é construída. Ele automatiza o processo de criação da imagem, garantindo consistência em diferentes ambientes. Cada instrução em um Dockerfile cria uma nova camada na imagem. Aqui está uma explicação de um exemplo de Dockerfile para um aplicativo Python Flask simples:

# Imagem base contendo o tempo de execução do Python
FROM python:3.9

# Definir o diretório de trabalho dentro do contêiner
WORKDIR /app

# Copiar os arquivos do aplicativo do host para o contêiner
COPY . /app

# Instalar as dependências listadas no requirements.txt
RUN pip install -r requirements.txt

# Definir o comando para executar o aplicativo Flask quando o contêiner iniciar
CMD ["python", "app.py"]

No comando acima:

• -v meu-volume:/app/data monta o armazenamento meu-volume no diretório /app/data dentro do contêiner.
• Quaisquer dados armazenados em /app/data persistirão mesmo se o contêiner parar ou for removido.

Desmembrando o Dockerfile acima:

• FROM python:3.9: Especifica a imagem base com Python 3.9 pré-instalado.
• WORKDIR /app: Define /app como o diretório de trabalho dentro do contêiner.
• COPY . /app: Copia todos os arquivos do diretório atual do host para /app no contêiner.
• RUN pip install -r requirements.txt: Instala todas as dependências necessárias dentro do contêiner.
• CMD ["python", "app.py"]: Define o comando a ser executado quando o contêiner é iniciado.

Construindo e executando a imagem

Uma vez que o Dockerfile está definido, você pode construir e executar a imagem usando os seguintes comandos:

Passo 1: Construir a imagem

docker build -t my-flask-app .

O comando acima:

• Usa o diretório atual (.) como contexto de construção.
• Leia o Dockerfile e execute suas instruções.
• Marca (-t) a imagem resultante como my-flask-app.

Passo 2: Execute a imagem como um contêiner

docker run -d -p 5000:5000 my-flask-app

O comando acima:

• Executa o contêiner em modo destacado (-d).
• Mapeia a porta 5000 dentro do contêiner para a porta 5000 no host (-p 5000:5000).

Depois de iniciado, você pode acessar a aplicação Flask navegando até http://localhost:5000 em um navegador.

Volumes e Persistência do Docker

Por padrão, os dados dentro de um contêiner Docker são temporários— uma vez que o contêiner é interrompido ou removido, os dados desaparecem. Para persistir dados através de reinicializações do contêiner e compartilhá-los entre vários contêineres, o Docker fornece volumes, um mecanismo integrado para gerenciar armazenamento persistente de forma eficiente.

Ao contrário de armazenar dados dentro do sistema de arquivos do contêiner, os volumes são gerenciados separadamente pelo Docker, tornando-os mais eficientes, flexíveis e mais fáceis de fazer backup.

Na próxima seção, exploraremos como criar e usar volumes do Docker para garantir a persistência de dados em seus contêineres.

Criando e usando volumes do Docker

Passo 1: Criar um volume

Antes de usar um volume, precisamos criar um. Execute o seguinte comando:

docker volume create my-volume

Isto cria um volume nomeado chamado my-volume, que o Docker gerenciará separadamente de qualquer contêiner específico.Passo 2: Usar o volume em um contêiner

Agora, vamos iniciar um contêiner e montar o volume dentro dele:

docker run -d -v my-volume:/app/data my-app

No comando acima:

• -v my-volume:/app/data monta o armazenamento my-volume no diretório /app/data dentro do contêiner.
• Qualquer dado armazenado em /app/data permanecerá mesmo se o contêiner parar ou for removido.

Docker Compose para Aplicações Multi-Contêiner

Até agora, estivemos trabalhando com aplicações de contêiner único, mas muitas aplicações do mundo real requerem múltiplos contêineres para funcionar juntos. Por exemplo, uma aplicação web pode precisar de um servidor backend, um banco de dados e uma camada de cache – cada um executando em seu próprio contêiner. Gerenciar esses contêineres manualmente com comandos docker run separados pode se tornar rapidamente tedioso.

É aí que o Docker Compose entra.

O que é o Docker Compose?

O Docker Compose é uma ferramenta que simplifica a gestão de aplicações multi-container. Em vez de executar vários comandos docker run, você pode definir toda a pilha de aplicativos usando um arquivo docker-compose.yml e implantá-lo com um único comando.

Escrevendo um arquivo Docker Compose

Agora, vamos criar um exemplo do mundo real – uma aplicação Node.js simples que se conecta a um banco de dados MongoDB. Em vez de gerenciar os dois containers separadamente, vamos defini-los em um arquivo docker-compose.yml.

Aqui está como definimos nossa configuração multi-container no Docker Compose:

version: '3'
services:
  web:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - database
  database:
    image: mongo
    volumes:
      - db-data:/data/db
volumes:
  db-data:

Quebrando o arquivo acima:

• version: '3': Especifica a versão do Docker Compose.
• services:: Define serviços individuais (containers).
• web:: Define a aplicação web Node.js.
• database:: Define o container do banco de dados MongoDB.
• volumes:: Cria um volume nomeado (db-data) para a persistência de dados do MongoDB.

Executando aplicações multi-container

Assim que o arquivo docker-compose.yml estiver pronto, podemos iniciar toda a pilha de aplicativos com um único comando:

docker-compose up -d

O comando anterior inicia tanto os containers web quanto de banco de dados no modo destacado (-d).

Para parar todos os serviços, use:

docker-compose down

Isso para e remove todos os contêineres preservando volumes e configurações de rede.

Princípios Básicos de Rede do Docker

Até agora, focamos em executar contêineres e gerenciar armazenamento, mas o que acontece quando os contêineres precisam se comunicar entre si? Na maioria das aplicações do mundo real, os contêineres não operam de forma isolada – eles precisam trocar dados, seja um servidor web se comunicando com um banco de dados ou microsserviços interagindo entre si.

O Docker oferece uma variedade de opções de rede para acomodar diferentes casos de uso, desde redes internas isoladas até configurações acessíveis externamente.

Pronto para aprimorar suas habilidades no Docker? Matricule-se no Docker Intermediário para explorar builds em várias etapas, redes avançadas e muito mais!

O que é a rede Docker?

A rede Docker é um recurso integrado que permite que os contêineres se comuniquem entre si, seja no mesmo host ou em vários hosts em um ambiente distribuído. Ela fornece isolamento de rede, segmentação e opções de conectividade adequadas para diferentes cenários de implantação.

O Docker suporta vários tipos de redes, cada um atendendo a diferentes casos de uso:

• Ponte (padrão): Contêineres no mesmo host se comunicam por meio de uma rede virtual interna. Cada contêiner recebe seu próprio endereço IP privado dentro da rede de ponte, e eles podem se alcançar por meio dos nomes dos contêineres.
• Exemplo: docker network create minha-rede-ponte
• Ideal para executar vários contêineres em um único host que precisam se comunicar de forma segura sem expor os serviços externamente.
• Host: Os contêineres compartilham a pilha de rede do host e usam diretamente o endereço IP e as portas do host.
• Exemplo: docker run --network host nginx
• Útil quando você precisa de alto desempenho e não requer isolamento de rede, como executar agentes de monitoramento ou aplicativos de baixa latência.
• Sobreposição: Permite a comunicação entre contêineres em hosts diferentes, criando uma rede distribuída.
• Exemplo: docker network create --driver overlay my-overlay-network
• Projetado para implantações orquestradas como o Docker Swarm, onde os serviços abrangem vários nós.
• Macvlan: Atribui um endereço MAC único a cada contêiner, fazendo com que ele pareça um dispositivo físico na rede.
• Exemplo: docker network create -d macvlan --subnet=192.168.1.0/24 my-macvlan
• Usado quando os contêineres precisam de acesso direto à rede, como na integração de sistemas legados ou interação com redes físicas.

Executando contêineres em redes personalizadas

Vamos mostrar como configurar e usar uma rede de ponte personalizada para comunicação entre contêineres.

Passo 1: Criar uma rede personalizada

Antes de executar os contêineres, precisamos primeiro criar uma rede dedicada:

docker network create my-custom-network

Este comando cria uma rede isolada à qual os contêineres podem se juntar para comunicação entre contêineres.

Passo 2: Execute contêineres na rede

Agora, vamos iniciar dois contêineres e conectá-los à nossa rede recém-criada:

docker run -d --network my-custom-network --name app1 my-app
docker run -d --network my-custom-network --name app2 my-app

• O sinalizador --network my-custom-network conecta o contêiner à rede especificada.
• O sinalizador --name atribui um nome de contêiner único, tornando mais fácil a referência.

Agora, ambos app1 e app2 podem se comunicar usando seus nomes de contêiner. Você pode testar a conectividade usando o comando ping dentro de um dos contêineres:

docker exec -it app1 ping app2

Se tudo estiver configurado corretamente, você verá uma resposta confirmando que os contêineres podem se comunicar.

Inspeção de redes do Docker

Para verificar as configurações de rede e os contêineres conectados, use:

docker network inspect my-custom-network

Este comando fornece detalhes sobre a rede, incluindo intervalos de IP, contêineres conectados e configurações.

Expondo e publicando portas

Ao executar contêineres que precisam ser acessíveis externamente, você pode expor portas específicas.

Por exemplo, para executar um servidor web Nginx e expô-lo na porta 8080 da sua máquina local, use:

docker run -d -p 8080:80 nginx

Isso mapeia a porta 80 dentro do contêiner para a porta 8080 no host, tornando o serviço acessível via http://localhost:8080.

Práticas recomendadas para redes do Docker

• Use redes personalizadas: Evite usar a rede bridge padrão para implantações de produção para reduzir o acesso não intencional entre contêineres.
• Aproveite a descoberta baseada em DNS: Em vez de codificar endereços IP, use nomes de contêineres para permitir a descoberta dinâmica de serviços.
• Restringir exposição externa: Use firewalls ou políticas de rede para controlar o acesso aos serviços.
• Monitorar tráfego: Use ferramentas como docker network inspect, Wireshark ou Prometheus para analisar o tráfego de rede e detectar anomalias.
• Otimizar redes sobrepostas: Se estiver implantando em uma configuração distribuída, ajuste as redes sobrepostas para reduzir a latência, aproveitando as opções de roteamento local do host.

Docker Best Practices e Próximos Passos

Agora que você aprendeu os fundamentos do Docker, é hora de aprimorar suas habilidades e adotar as melhores práticas que ajudarão você a construir aplicativos containerizados seguros, eficientes e fáceis de manter.

As seguintes melhores práticas ajudarão você a otimizar seus fluxos de trabalho com o Docker e evitar armadilhas comuns.

• Utilize imagens base oficiais: Sempre prefira imagens base oficiais e bem mantidas para garantir segurança e estabilidade. As imagens oficiais são otimizadas, atualizadas regularmente e menos propensas a conter vulnerabilidades.
• Mantenha as imagens pequenas: Reduza o tamanho da imagem escolhendo imagens base mínimas (por exemplo, python:3.9-slim em vez de python:3.9). Remova dependências e arquivos desnecessários para otimizar o armazenamento e os tempos de download.
• Utilize builds de múltiplas etapas: Otimize os Dockerfiles separando as dependências de build e de tempo de execução. As builds de múltiplas etapas garantem que apenas os artefatos necessários sejam incluídos na imagem final, reduzindo o tamanho e a superfície de ataque.
• Marque corretamente as imagens: Sempre use tags versionadas (por exemplo, my-app:v1.0.0) em vez de latest para evitar atualizações inesperadas ao puxar imagens.
• Verifique as imagens em busca de vulnerabilidades: Use ferramentas de verificação de segurança como docker scan, Trivy ou Clair para identificar e remediar vulnerabilidades de segurança em suas imagens antes da implantação.
• Gerencie variáveis de ambiente de forma segura: Evite armazenar credenciais sensíveis dentro das imagens. Use segredos do Docker, variáveis de ambiente ou ferramentas externas de gerenciamento de segredos como AWS Secrets Manager ou HashiCorp Vault.
• Use arquivos .dockerignore: Exclua arquivos desnecessários (por exemplo, .git, node_modules, venv) para reduzir o tamanho do contexto de construção e evitar a inclusão acidental de arquivos sensíveis nas imagens.
• Habilitar logging e monitoramento: Utilize ferramentas como Prometheus, Grafana e Fluentd para logs e monitoramento de containers. Inspecione os logs usando docker logs e habilite o logging estruturado para uma melhor observabilidade.

Depois de dominar o básico do Docker, há muitos tópicos avançados para explorar. Aqui estão algumas áreas que valem a pena explorar a seguir:

• Docker Swarm & Kubernetes: Explore Docker Swarm (clusterização integrada) e Kubernetes (orquestração de nível empresarial com dimensionamento automático e descoberta de serviços) para orquestração de nível de produção.
• Práticas recomendadas de segurança de contêineres: Para garantir a segurança de aplicações em contêineres, siga as diretrizes do CIS Docker Benchmark e implemente o Controle de Acesso Baseado em Funções (RBAC).
• Pipelines CI/CD com Docker: Automatize a construção de imagens, análises de segurança e implantações usando GitHub Actions, GitLab CI ou Jenkins.
• Desenvolvimento nativo na nuvem: Aproveite o Docker com plataformas de nuvem como AWS ECS, Azure Container Instances e Google Cloud Run para implantações escaláveis e gerenciadas.
• Estratégias de persistência de dados: Para uma gestão de armazenamento otimizada, entenda as diferenças entre volumes Docker, pontos de montagem bind e tmpfs.

Conclusão

O Docker revolucionou a forma como os desenvolvedores constroem, enviam e executam aplicativos, tornando-se uma ferramenta essencial para o desenvolvimento de software moderno.

Neste tutorial, cobrimos:

• O que é o Docker e por que é importante
• Como instalar e executar seu primeiro contêiner
• Conceitos-chave como imagens, contêineres e rede
• Armazenamento persistente com volumes do Docker
• Aplicações de vários contêineres com Docker Compose
• Melhores práticas de segurança, desempenho e escalabilidade

Mas isso é apenas o começo! Se deseja aprofundar sua expertise em Docker, você pode fazer um curso de nível iniciante Introdução ao Docker. Para um conhecimento mais aprofundado, você pode fazer um curso Docker Intermediário que aborda builds de múltiplos estágios, ferramentas de rede do Docker e Docker Compose. Por fim, você também pode buscar a certificação Docker, confira O Guia Completo de Certificação Docker (DCA) para 2025 se estiver interessado!