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

Conceitos Básicos do Docker

Agora que você instalou o Docker, pode estar ansioso para começar a executar containers. Mas antes de fazer isso, é importante entender alguns conceitos-chave que formam a base do funcionamento do Docker. Esses conceitos ajudarão você a navegar no Docker de forma mais eficaz e evitar erros comuns de iniciantes.

No coração do Docker estão imagens, que servem como modelos para contêineres; contêineres, 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 contêineres. 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 contêineres como o Docker Hub.

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

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

Contêineres do Docker

Um contêiner do Docker é uma instância em execução de uma imagem do Docker. Os contêineres 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 contêiner tem seu próprio sistema de arquivos, rede e espaço de processo, mas compartilha o kernel do hospedeiro.

Os contêineres seguem um ciclo de vida simples envolvendo a criação, inicialização, paralisação e exclusão. Aqui está uma quebra dos comandos comuns de gerenciamento de contêineres:

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 Nginx em modo destacado (executando em segundo plano), mapeando a porta 80 dentro do contêiner para a porta 8080 na máquina host:

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 exibirá uma lista de todos os containers e detalhes como o status deles e as portas atribuídas.

Docker Hub

O Docker Hub é 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 Docker Hub e compartilhá-las publicamente ou de forma privada.

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

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

Novo na containerização? Obtenha uma base sólida com o curso de 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 prática! 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 o 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 da imagem hello-world do Docker

Agora, vamos um passo além 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 em modo destacado, o que significa que ele roda em segundo plano.
• A flag -p 8080:80 mapeia a porta 80 dentro do contêiner para a porta 8080 na sua máquina local, permitindo que você acesse o servidor web.

Uma vez que o comando seja executado com sucesso, abra um navegador e visite: http://localhost:8080

Acessando o servidor web em localhost:8080

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

Você também verá um contêiner rodando no seu Docker Desktop:

Contêiner Nginx rodando na porta 8080

Construindo Sua Primeira Imagem Docker

Até agora, temos utilizado imagens predefinidas do Docker Hub. Mas e se você precisar de um ambiente personalizado adaptado para a 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 rodar 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 simples Python Flask:

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

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

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

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

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

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 persistirá 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

Depois que o Dockerfile for 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:

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

Passo 2: Executar 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).

Uma vez em execução, 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 os dados entre reinicializações do contêiner e compartilhá-los entre vários contêineres, o Docker fornece volumes, um mecanismo integrado para gerenciar o armazenamento persistente de forma eficiente.

Diferentemente 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, vamos explorar 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

Isso 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 persistirá mesmo se o contêiner parar ou for removido.

O Docker Compose para Aplicações de Múltiplos Contêineres

Até agora, estávamos 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 sendo executado em seu próprio contêiner. Gerenciar esses contêineres manualmente com comandos separados de docker run 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-contêineres. Em vez de executar vários comandos docker run, você pode definir toda uma 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 contêineres separadamente, vamos defini-los em um arquivo docker-compose.yml.

Aqui está como definimos nossa configuração multi-contêineres 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 (contêineres).
• web:: Define a aplicação web Node.js.
• database:: Define o contêiner do banco de dados MongoDB.
• volumes:: Cria um volume nomeado (db-data) para persistência de dados do MongoDB.

Executando aplicações multi-contêineres

Depois 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 contêineres web quanto de banco de dados no modo destacado (-d).

Para parar todos os serviços, use:

docker-compose down

Isso interrompe e remove todos os contêineres enquanto preserva volumes e configurações de rede.

Princípios Básicos de Rede do Docker

Até agora, focamos na execução de contêineres e no gerenciamento de 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 fornece 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 com o Docker? Matricule-se no curso Docker Intermediário para explorar construções de várias etapas, redes avançadas e muito mais!

O que é a rede do Docker?

A rede do 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 rede, 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 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-de-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 diferentes hosts, 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 ser 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 ver como configurar e usar uma rede de bridge personalizada para comunicação entre contêineres.

Passo 1: Criar uma rede personalizada

Antes de executar os contêineres, primeiro precisamos 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

• A flag --network my-custom-network anexa o contêiner à rede especificada.
• A flag --name atribui um nome único ao contêiner, facilitando a referência.

Agora, tanto app11 quanto 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.

Inspecionando redes 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 a rede do Docker

• Usar 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.
• Restrinja a exposição externa: Use firewalls ou políticas de rede para controlar o acesso aos serviços.
• Monitore o tráfego: Use ferramentas como docker network inspect, Wireshark ou Prometheus para analisar o tráfego de rede e detectar anomalias.
• Otimizar redes sobrepostas: Ao implantar em um ambiente distribuído, ajuste as redes sobrepostas para reduzir a latência, aproveitando as opções de roteamento local do host.

Práticas recomendadas do Docker 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 em contêiner seguros, eficientes e fáceis de manter.

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

• Use 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 armazenamento e tempos de download.
• Use builds de múltiplas etapas: Otimize os Dockerfiles separando as dependências de compilação e de tempo de execução. 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 as imagens corretamente: Sempre use tags versionadas (por exemplo, meu-app:v1.0.0) em vez de latest para evitar atualizações inesperadas ao puxar imagens.
• Escaneie imagens em busca de vulnerabilidades: Utilize ferramentas de escaneamento 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: Ao evitar armazenar credenciais sensíveis dentro das imagens. Utilize 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.
• Ative o registro e monitoramento: Utilize ferramentas como Prometheus, Grafana e Fluentd para logs e monitoramento de contêineres. Inspecione logs usando docker logs e ative o registro 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.
• Melhores práticas 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ção (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 gerenciamento de armazenamento otimizado, entenda as diferenças entre volumes do Docker, montagens de 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, abordamos:

• O que é o Docker e por que é importante
• Como instalar e executar seu primeiro contêiner
• Conceitos-chave como imagens, contêineres e redes
• 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 várias etapas, ferramentas de rede do Docker e Docker Compose. Por fim, também é possível obter certificação em Docker, confira O Guia Completo de Certificação Docker (DCA) para 2025 se tiver interesse!