Docker para iniciantes: Um guia prático para contêineres

Conceitos básicos do Docker

Agora que você tem o Docker instalado, talvez esteja ansioso para começar a executar contêineres. Mas antes de fazer isso, é importante que você entenda alguns conceitos-chave que formam a base do trabalho do Docker. Esses conceitos ajudarão você a navegar no Docker com mais eficiência e a evitar as armadilhas comuns dos iniciantes.

No coração do Docker estão as imagensque servem como modelos para contêineres; contêineresque são as instâncias em execução dessas imagens; e o Docker Hubum 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. São modelos imutáveis e somente leitura que contêm tudo o que é necessário para executar um aplicativo, inclusive o sistema operacional, o código do aplicativo, o tempo de execução e as dependências.

As imagens são criadas usando um Dockerfile, que define as instruções para a criação de 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 exemplos de comandos para você trabalhar com imagens:

• docker pull nginx: Você pode obter a imagem mais recente do Nginx no Docker Hub.
• docker images: Lista todas as imagens disponíveis no computador local.
• docker rmi nginx: Remover uma imagem do computador local.

Contêineres do Docker

Um contêiner do Docker é uma instância em execução de uma imagem do Docker. Os contêineres oferecem um ambiente de tempo de execução isolado no qual os aplicativos podem ser executados sem interferir uns nos outros ou no sistema host. Cada contêiner tem seu próprio sistema de arquivos, rede e espaço de processo, mas compartilha o kernel do host.

Os contêineres seguem um ciclo de vida simples que envolve criação, inicialização, interrupção e exclusão. Aqui está um detalhamento 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. Interromper um contêiner: docker stop
4. Reiniciar um contêiner: docker restart
5. Exclusão de um contêiner: docker rm

Vamos ver um exemplo prático. O comando a seguir executa um contêiner Nginx no modo desanexado (executado 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

Depois de executar esse comando, o Docker extrairá a imagem do Nginx (se ainda não estiver disponível), criará um contêiner e o iniciará.

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

docker ps -a

Isso exibirá uma lista de todos os contêineres e detalhes como status e portas atribuídas.

Docker Hub

O Docker Hub é um serviço de registro baseado em nuvem para localizar, armazenar e distribuir imagens de contêineres. Os usuários podem enviar imagens personalizadas para o Docker Hub e compartilhá-las de forma pública ou privada.

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

• docker login: Faça a autenticação com o Docker Hub.
• docker push my-image: Faça upload de uma imagem personalizada para o Docker Hub.
• docker search ubuntu: Pesquise imagens oficiais e da comunidade.
• docker pull ubuntu: Baixe uma imagem do Ubuntu do Docker Hub.

Você é novo na conteinerização? Obtenha uma base sólida com o curso Conceitos de Containerização e Virtualização.

Executando seu primeiro contêiner do Docker

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

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

docker run hello-world

Isso extrai a imagem hello-world do DockerHub e a executa em um contêiner.

Exemplo de imagem do Docker hello-world

Agora, vamos dar um passo adiante e executar um aplicativo do mundo real: um servidor da Web Nginx. Execute o seguinte comando:

docker run -d -p 8080:80 nginx

O comando acima faz o seguinte:

• O sinalizador -d executa o contêiner no modo desanexado, o que significa que ele é executado em segundo plano.
• O sinalizador -p 8080:80 mapeia a porta 80 dentro do contêiner para a porta 8080 no seu computador local, permitindo que você acesse o servidor Web.

Depois que o comando for executado com êxito, abra um navegador e acesse: http://localhost:8080

Acesso ao servidor da Web em localhost:8080

Você deverá ver a página de boas-vindas padrão do Nginx, confirmando que seu servidor da Web está sendo executado dentro de um contêiner!

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

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

Criando sua primeira imagem do Docker

Até o momento, estamos executando imagens pré-criadas do Docker Hub. Mas e se você precisar de um ambiente personalizado e adaptado ao seu aplicativo? É aí que entra a criação de sua própria imagem do Docker.

A criação de uma imagem do Docker envolve escrever um Dockerfile, um script que automatiza a criação de imagens. Isso garante a consistência e a portabilidade em diferentes ambientes. Depois que uma imagem é criada, ela pode ser executada como um contêiner para executar aplicativos em um ambiente isolado. 

Nesta seção, aprenderemos os fundamentos de como escrever um Dockerfile, criar uma imagem personalizada e executá-la como um contêiner.

Noções básicas de Dockerfile

Um Dockerfile é um script que contém uma série de instruções que definem como uma imagem do Docker é criada. Ele automatiza o processo de criação de imagens, garantindo a consistência entre os ambientes. Cada instrução em um Dockerfile cria uma nova camada na imagem. Aqui está uma análise de um exemplo de Dockerfile para um aplicativo simples do Python Flask:

# Base image containing Python runtime
FROM python:3.9

# Set the working directory inside the container
WORKDIR /app

# Copy the application files from the host to the container
COPY . /app

# Install the dependencies listed in requirements.txt
RUN pip install -r requirements.txt

# Define the command to run the Flask app when the container starts
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.
• Todos os dados armazenados em /app/data persistirão mesmo que o contêiner pare ou seja removido.

Detalhando o Dockerfile acima:

• FROM python:3.9: Especifica a imagem base com o 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 for iniciado.

Criação e execução da imagem

Depois que o Dockerfile for definido, você poderá criar e executar a imagem usando os seguintes comandos:

Etapa 1: Crie a imagem

docker build -t my-flask-app .

O comando acima:

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

Etapa 2: Execute a imagem como um contêiner

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

O comando acima:

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

Após a execução, você pode acessar o aplicativo Flask navegando para http://localhost:5000 em um navegador.

Volumes e persistência do Docker

Por padrão, os dados dentro de um contêiner do Docker são temporários- quando o contêiner para ou é removido, os dados desaparecem. Para manter os dados entre as 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.

Ao contrário do armazenamento de dados dentro do sistema de arquivos do contêiner, os volumes são gerenciados separadamente pelo Docker, o que os torna mais eficientes, flexíveis e 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 nos seus contêineres.

Criar e usar volumes do Docker

Etapa 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.Etapa 2: Use 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.
• Todos os dados armazenados em /app/data persistirão mesmo que o contêiner pare ou seja removido.

Docker Compose para aplicativos com vários contêineres

Até agora, trabalhamos com aplicativos de contêiner único, mas muitos aplicativos do mundo real exigem que vários contêineres trabalhem juntos. Por exemplo, um aplicativo da Web pode precisar de um servidor de back-end, um banco de dados e uma camada de cache, cada um executado em seu próprio contêiner. Gerenciar esses contêineres manualmente com comandos docker run separados pode rapidamente se tornar entediante.

É aí que entra o Docker Compose.

O que é o Docker Compose?

O Docker Compose é uma ferramenta que simplifica o gerenciamento de aplicativos com vários contêineres. Em vez de executar vários comandos docker run, você pode definir uma pilha inteira de aplicativos usando um arquivo docker-compose.yml e implantá-la com um único comando.

Escrevendo um arquivo Docker Compose

Agora, vamos criar um exemplo do mundo real: um aplicativo Node.js simples que se conecta a um banco de dados MongoDB. Em vez de gerenciar os dois contêineres separadamente, nós os definiremos em um arquivo docker-compose.yml.

Veja como definimos nossa configuração de vários 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:

Detalhando o arquivo acima:

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

Execução de aplicativos com vários contêineres

Quando o arquivo docker-compose.yml estiver pronto, você poderá iniciar toda a pilha de aplicativos com um único comando:

docker-compose up -d

O comando anterior inicia os contêineres da Web e do banco de dados no modo desanexado (-d).

Para interromper todos os serviços, use:

docker-compose down

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

Noções básicas de rede do Docker

Até agora, concentramo-nos em executar contêineres e gerenciar o armazenamento, mas o que acontece quando os contêineres precisam se comunicar uns com os outros? Na maioria dos aplicativos do mundo real, os contêineres não operam isoladamente - eles precisam trocar dados, quer um servidor da Web converse com um banco de dados ou os microsserviços interajam 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.

Você está pronto para aprimorar suas habilidades com o Docker? Inscreva-se no Docker Intermediário para explorar compilações em vários estágios, 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. Ele oferece isolamento de rede, segmentação e opções de conectividade adequadas a diferentes cenários de implementação.

O Docker oferece suporte a vários tipos de rede, cada um atendendo a diferentes casos de uso:

• Bridge (padrão): Os contêineres no mesmo host se comunicam por meio de uma rede virtual interna. Cada contêiner obtém seu endereço IP privado dentro da rede de ponte, e eles podem se comunicar entre si por meio de nomes de contêineres.
• Exemplo: docker network create my-bridge-network
• Ideal para executar vários contêineres em um único host que precisam se comunicar com segurança sem expor 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 a execução de agentes de monitoramento ou aplicativos de baixa latência.
• Sobreposição: Permite a comunicação de contêineres em diferentes hosts, criando uma rede distribuída.
• Exemplo: docker network create --driver overlay my-overlay-network
• Projetado para implementações orquestradas, como o Docker Swarm, em que os serviços abrangem vários nós.
• Macvlan: Atribui um endereço MAC exclusivo a cada contêiner, fazendo com que ele apareça como 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 na interação com redes físicas.

Execução de contêineres em redes personalizadas

Vamos ver como você pode configurar e usar uma rede bridge personalizada. rede de ponte personalizada personalizada para comunicação com contêineres.

Etapa 1: Criar uma rede personalizada

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

docker network create my-custom-network

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

Etapa 2: Executar 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 anexa o contêiner à rede especificada.
• O sinalizador --name atribui um nome de contêiner exclusivo, o que facilita a referência.

Ambos app11 and app2 can now communicate using their container names. You can test the connectivity using the 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

Esse 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 da Web Nginx e expô-lo na porta 8080 de seu computador 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

• Use redes personalizadas: Evite usar a rede bridge padrão para implementaçõ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 a exposição externa: Use firewalls ou políticas de rede para controlar o acesso ao serviço.
• Monitorar o tráfego: Use ferramentas como docker network inspect, Wireshark ou Prometheus para analisar o tráfego de rede e detectar anomalias.
• Otimize as redes de sobreposição: Se você estiver implementando em uma configuração distribuída, ajuste as redes de sobreposição para reduzir a latência, aproveitando as opções de roteamento local do host.

Práticas recomendadas do Docker e próximas etapas

Agora que você aprendeu os fundamentos do Docker, é hora de aprimorar suas habilidades e adotar as práticas recomendadas que o ajudarão a criar aplicativos em contêineres seguros, eficientes e de fácil manutenção.

As práticas recomendadas a seguir ajudarão você a otimizar seus fluxos de trabalho do Docker e evitar armadilhas comuns.

• Use imagens de base oficiais: Sempre prefira imagens de base oficiais e bem mantidas para garantir a segurança e a estabilidade. As imagens oficiais são otimizadas, atualizadas regularmente e têm menor probabilidade de conter vulnerabilidades.
• Mantenha as imagens pequenas: Reduza o tamanho da imagem escolhendo imagens de 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 extração.
• Use compilações em vários estágios: Otimize os Dockerfiles separando as dependências de compilação e de tempo de execução. As compilações em vários estágios 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 com versão (por exemplo, my-app:v1.0.0) em vez de latest para evitar atualizações inesperadas ao extrair imagens.
• Examinar imagens em busca de vulnerabilidades: Use ferramentas de varredura de segurança como docker scan, Trivy ou Clair para identificar e corrigir vulnerabilidades de segurança em suas imagens antes da implementação.
• Gerencie variáveis de ambiente com segurança: Evite armazenar credenciais confidenciais em imagens. Use segredos do Docker, variáveis de ambiente ou ferramentas externas de gerenciamento de segredos, como o AWS Secrets Manager ou o HashiCorp Vault.
• Use arquivos .dockerignore: Exclua arquivos desnecessários (por exemplo, .git, node_modules, venv) para reduzir o tamanho do contexto de compilação e evitar a inclusão acidental de arquivos confidenciais nas imagens.
• Habilite o registro e o monitoramento: Utilize ferramentas como Prometheus, Grafana e Fluentd para logs e monitoramento de contêineres. Inspecione os registros usando docker logs e ative o registro estruturado para melhor observabilidade.

Depois que você dominar os conceitos básicos do Docker, há muitos tópicos avançados a serem explorados. Aqui estão algumas áreas que você deve explorar em seguida:

• Docker Swarm e Kubernetes: Explore o Docker Swarm (cluster integradog) e o 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 proteger aplicativos em contêineres, siga as diretrizes do CIS Docker Benchmark e implemente o RBAC (Role-Based Access Control, controle de acesso baseado em função).
• Pipelines de CI/CD com o Docker: Automatize as compilações de imagens, as verificações de segurança e as implementações usando o GitHub Actions, o GitLab CI ou o Jenkins.
• Desenvolvimento nativo da nuvem: Aproveite o Docker com plataformas de nuvem como AWS ECS, Azure Container Instances e Google Cloud Run para implantações escalonáveis e gerenciadas.
• Estratégias de persistência de dados: Para otimizar o gerenciamento do armazenamento, entenda as diferenças entre os volumes do Docker, as montagens bind e o tmpfs.

Conclusão

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

Neste tutorial, abordamos o assunto:

• O que é o Docker e por que ele é importante
• Como instalar e executar seu primeiro contêiner
• Conceitos-chave como imagens, contêineres e redes
• Armazenamento persistente com volumes do Docker
• Aplicativos com vários contêineres com o Docker Compose
• Práticas recomendadas de segurança, desempenho e dimensionamento

Mas isso é apenas o começo! Se quiser aprofundar sua experiência com o Docker, você pode fazer um curso de Introdução ao Docker para iniciantes. Para obter um conhecimento mais aprofundado, você pode fazer um curso intermediário do Docker que abrange compilações em vários estágios, ferramentas de rede do Docker e o Docker Compose. Por fim, você também pode buscar a certificação do Docker. Se estiver interessado, confira o Guia completo de certificação do Docker (DCA) para 2025!