Docker: tutorial completo para executar containers

Docker é uma plataforma aberta criada para simplificar o desenvolvimento, a distribuição e a execução de aplicações. Ele torna a entrega de software mais eficiente ao usar a containerização – uma tecnologia que empacota a aplicação e todas as suas dependências em unidades isoladas e prontas para rodar, chamadas de containers. Assim, o software se comporta da mesma forma em qualquer ambiente, do computador local ao servidor de produção.

Na prática, o Docker funciona a partir de alguns conceitos fundamentais: Docker Engine, Docker Hub, imagens, containers, Dockerfiles e Docker Compose. Entender como cada um desses elementos se conecta é essencial para criar, implantar e gerenciar aplicações em containers com mais controle e segurança.

Você pode usar o Docker principalmente pela linha de comando (CLI), executando comandos específicos, mas a plataforma também oferece uma versão desktop com interface gráfica. O processo de instalação muda de acordo com a opção escolhida: a versão desktop funciona como um aplicativo comum (.dmg no macOS ou .exe no Windows), enquanto a CLI costuma ser instalada por meio de gerenciadores de pacotes, como APT ou Homebrew.

Ao trabalhar com o ecossistema Docker, é normal se deparar com erros em diferentes camadas – seja na imagem, no Dockerfile ou no próprio container. Como esses problemas podem comprometer todo o ambiente de containerização, é importante entender quais são os erros mais comuns, por que eles acontecem e como resolvê-los. Vamos abordar esses pontos mais adiante, depois de passar pelos conceitos essenciais deste tutorial.

O que é containerização?

Containerização é uma forma de virtualização em nível de sistema operacional que empacota aplicações para rodarem em espaços isolados chamados containers.

Em termos práticos, um container reúne tudo o que a aplicação precisa para funcionar – código, bibliotecas do sistema, dependências e arquivos de configuração – criando um ambiente isolado e previsível para a execução do software.

Diferentemente das máquinas virtuais (VMs), os containers são mais leves porque compartilham o mesmo kernel do sistema operacional do host. Isso reduz o consumo de recursos e elimina a dependência de uma infraestrutura específica, permitindo que a aplicação rode da mesma forma em ambientes diferentes.

Os principais benefícios da containerização incluem:

• Portabilidade. Containers funcionam de forma consistente em qualquer ambiente – do computador local a um servidor remoto, como os oferecidos pela Hostinger. Isso evita problemas comuns de compatibilidade ao mover aplicações entre sistemas ou equipes.
• Eficiência. Enquanto VMs exigem um sistema operacional completo e um hipervisor, os containers não precisam disso. O resultado é uma virtualização mais leve, rápida e econômica em recursos.
• Isolamento. Cada container executa seus processos de forma isolada, com seu próprio software, configurações, rede e variáveis de ambiente. Isso aumenta a segurança e reduz conflitos entre aplicações.

Por que usar Docker?

Você deve usar o Docker porque ele oferece uma maneira confiável, eficiente e padronizada de criar, compartilhar e executar aplicativos. Ele resolve diversos problemas reais de desenvolvimento e implantação de software:

• Funciona em qualquer máquina Com Docker, a aplicação roda exatamente da mesma forma para todos os desenvolvedores e em todas as etapas do projeto. Isso elimina bugs causados por diferenças de ambiente.
• Desenvolvimento e deploy mais rápidos. O Docker facilita a criação de ambientes reproduzíveis. Dá para integrar recursos como mapas ou gateways de pagamento sem precisar configurar tudo do zero, o que acelera o trabalho.
• Escalabilidade e portabilidade. Com ferramentas como o Docker Compose, você define uma aplicação completa, com vários containers, em um único arquivo. Isso torna mais fácil compartilhar o setup com o time, manter consistência e escalar serviços quando necessário.
• Uso eficiente de recursos. Como os containers são leves e compartilham o kernel do sistema operacional do host, eles consomem menos recursos do que máquinas virtuais tradicionais.

Quais são os conceitos fundamentais do Docker?

O Docker organiza a ideia de containerização em um conjunto de componentes centrais que se conectam entre si. Juntos, esses elementos formam uma plataforma capaz de gerenciar todo o ciclo de vida de uma aplicação em containers – desde a criação da estrutura inicial até a execução de aplicações completas com vários serviços.

Docker Engine

O Docker Engine é o núcleo da tecnologia Docker e a base para criar e executar aplicações em containers. Ele funciona com uma arquitetura cliente–servidor e é responsável por gerenciar todos os objetos do Docker, como imagens, containers, redes e volumes.

O Docker Engine é composto por três partes principais:

1. Servidor. Um processo em segundo plano (o daemon, chamado dockerd) que cuida das tarefas essenciais, como criar, iniciar e remover containers.
2. APIs. Interfaces que permitem que outros programas – incluindo o Docker CLI – se comuniquem com o daemon e enviem instruções.
3. Cliente CLI. A ferramenta de linha de comando do Docker, que é a principal forma de interação do usuário com a plataforma.

Para facilitar o entendimento, dá para imaginar o Docker Engine como um restaurante:

• O servidor (dockerd) é o chef, responsável por preparar os pratos – ou seja, executar os containers.
• As APIs funcionam como o cardápio e os pedidos, dizendo ao chef o que precisa ser feito.
• O Docker CLI é o garçom, que recebe seus comandos e os leva até a cozinha.

Para verificar se o Docker Engine está em execução e se o cliente está conectado corretamente, basta rodar um comando simples no terminal, como este:

docker ps

Esse comando pede ao Docker Daemon que liste todos os containers em execução no momento. Se o Docker estiver funcionando corretamente, você verá a lista dos containers ativos.

Docker Hub

O Docker Hub é o registro público padrão do Docker – um serviço de armazenamento e distribuição de imagens Docker. Ele hospeda imagens oficiais para softwares populares como nginx, node e python, e permite que os usuários criem repositórios privados para suas imagens personalizadas.

Ao criar um container, você precisa instalar diversos pacotes de software a partir de imagens. O Docker Hub simplifica o processo, permitindo que você baixe imagens de um repositório centralizado.

O Docker Hub usa tags para rotular e identificar imagens, que denotam uma versão específica do pacote de software, como latest. Isso mantém a consistência e a funcionalidade do contêiner em diferentes ambientes.

Uma boa forma de entender o Docker Hub é pensar nele como uma biblioteca comunitária de receitas. Ela guarda receitas prontas de pratos comuns que qualquer pessoa pode baixar e usar. Você também pode adicionar suas próprias receitas – seja para compartilhar com outros ou manter como backup privado.

Você pode interagir com o Docker Hub usando o comando Docker. Por exemplo, use o seguinte comando para baixar uma imagem do registro:

docker pull <nome>:<tag>

Por exemplo, para baixar a imagem oficial mais recente do Ubuntu:

docker pull ubuntu:latest

Docker images

Uma Docker image é um modelo somente leitura que contém tudo o que é necessário para criar um container. Ela inclui o código da aplicação, arquivos de configuração, bibliotecas do sistema e até os arquivos básicos do sistema operacional usados como base.

As imagens são criadas a partir de um Dockerfile. Cada instrução nesse arquivo gera uma camada independente e imutável, que define o que a imagem contém ou executa. Esse modelo em camadas ajuda no reaproveitamento e torna o processo mais eficiente.

De forma simples, a imagem funciona como o projeto de uma máquina. Ela descreve exatamente como o ambiente final deve ser, mas não pode ser alterada depois de criada. Quando esse projeto é usado, o resultado é um container Docker em execução.

Para listar as imagens que você já tem baixadas localmente, execute:

docker images

Já o comando abaixo cria uma imagem no diretório atual com base no Dockerfile presente ali. Se a imagem base ainda não estiver no seu sistema, o Docker faz o download automaticamente a partir do Docker Hub:

docker build -t nome-da-sua-imagem:latest.

A melhor prática ao usar imagens é utilizar uma imagem base mínima para reduzir o tamanho e minimizar a superfície de ataque potencial, geralmente introduzida por pacotes ou componentes desnecessários.

Docker containers

Um Docker container é a instância em execução de uma imagem. É dentro dele que a aplicação roda, junto com suas configurações, dependências e os pacotes de software necessários para funcionar.

Quando um container é criado, o Docker adiciona uma camada gravável sobre as camadas somente leitura da imagem. Isso permite fazer alterações no sistema de arquivos do container sem modificar a imagem original.

Os containers são pensados para serem temporários (stateless). Isso significa que podem ser iniciados, parados, removidos e recriados com facilidade, sem grandes ajustes. Containers individuais costumam ser gerenciados via Docker CLI, enquanto ambientes com vários containers são administrados com ferramentas como Docker Compose ou soluções de orquestração, como o Kubernetes.

Seguindo a mesma analogia usada antes, o container é a máquina em funcionamento, construída a partir do projeto (a imagem). Ao criar um container Docker, você está montando e ligando essa máquina para executar os processos definidos na imagem.

Para criar um container e rodar um comando dentro dele, use o comando run:

docker run -it ubuntu /bin/bash

Esse comando inicia um container a partir da imagem Ubuntu, abre uma sessão interativa e executa o shell /bin/bash.

Dockerfiles

Um Dockerfile é um arquivo de texto simples que contém instruções passo a passo para criar uma Docker image. Ele define todo o ambiente da aplicação – desde a imagem base do sistema operacional até variáveis de ambiente, dependências e o código da aplicação.

Abaixo estão algumas das instruções mais comuns em um Dockerfile e para que elas servem:

• FROM. Define a imagem base usada no início do build.
• RUN. Executa comandos durante o processo de criação da imagem.
• COPY ou ADD. Copia arquivos do contexto de build para dentro da imagem.
• CMD ou ENTRYPOINT. Define o comando executado quando o container é iniciado.
• ENV. Define variáveis de ambiente disponíveis durante o build e em tempo de execução.
• WORKDIR. Define o diretório de trabalho usado pelas instruções seguintes, como RUN, CMD, ENTRYPOINT, COPY e ADD.

Algumas dessas instruções criam camadas na imagem – cada camada representa um passo no processo de build. Já instruções voltadas apenas para configuração ou metadados, como WORKDIR, não geram camadas.

Veja abaixo um exemplo simples de Dockerfile:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "app.py"]

Docker Compose

O Docker Compose é uma ferramenta que simplifica a definição e o gerenciamento de aplicações com múltiplos contêineres usando um único arquivo de configuração, geralmente chamado docker-compose.yml.

Nesse arquivo, você define todos os containers, redes e volumes necessários para montar uma aplicação completa. Depois disso, é possível iniciar, parar e gerenciar todos os containers — chamados de services no contexto do Docker Compose — com apenas um comando.

Sem o Docker Compose, seria necessário configurar cada container manualmente e gerenciá-los individualmente via Docker CLI. Em aplicações formadas por vários serviços interligados, esse processo rapidamente se torna trabalhoso e difícil de manter.

Seguindo a analogia anterior, se um container é um único eletrodoméstico, o Docker Compose funciona como o esquema elétrico de uma cozinha inteira. Ele define como o forno, a geladeira e a torradeira se conectam e são ligados juntos, tudo com um único botão.

Veja abaixo um exemplo de arquivo Docker Compose:

services:
  web:
    build: ./web  # Cria a imagem a partir do Dockerfile no diretório ./web
    ports:
      - "8000:8000"  # Mapeia a porta 8000 do host para a porta 8000 do container
    depends_on:
      - db     # Aguarda o serviço db iniciar
      - redis  # Aguarda o serviço redis iniciar

  db:
    image: postgres:15  # Usa a imagem oficial do PostgreSQL 15
    environment:
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
      POSTGRES_DB: mydb
    volumes:
      - db-data:/var/lib/postgresql/data  # Persiste os dados do banco em um volume nomeado

  redis:
    image: redis:alpine  # Usa uma imagem leve do Redis para cache

volumes:
  db-data:  # Define um volume nomeado para armazenar os dados do banco

Para construir e iniciar todos os serviços definidos no seu arquivo docker-compose.yml em segundo plano, execute o comando com a flag -d ou detached:

docker compose up -d

Existem outros comandos do Docker Compose que permitem gerenciar todos os contêineres simultaneamente ao longo do ciclo de vida da aplicação.

Como instalar o Docker

O processo de instalação do Docker varia conforme a versão que você pretende usar. Se optar pelo Docker Desktop, basta baixar o instalador no site oficial e seguir o mesmo procedimento de qualquer outro aplicativo no seu sistema.

Entretanto, você pode instalar o Docker CLI com comandos usando o gerenciador de pacotes do seu sistema, como o APT do Ubuntu ou o Homebrew do macOS. Consulte a documentação oficial para saber mais sobre os comandos para configurar o Docker no seu sistema operacional.

Observe que o Docker CLI não inclui certos recursos, como o Docker Compose, o que significa que você precisa instalá-los separadamente. Se você utiliza a solução de hospedagem Docker da Hostinger, não precisa configurá-la separadamente, pois nosso recurso integrado de Gerenciador Docker possui funcionalidade Compose.

Entendendo os comandos básicos do Docker

Utilize a CLI do Docker para interagir com o Docker Engine e gerenciar seus contêineres. Aqui estão alguns dos comandos Docker mais essenciais para diferentes tarefas:

• docker ps -a. Lista todos os contêineres, incluindo aqueles que estão parados.
• docker pull <nome>:<tag>. Faz o download de uma imagem do registro para o seu computador.
• docker rmi <imagem>. Exclui uma imagem local.
• docker stop <container>. Interrompe corretamente um contêiner em execução.
• docker rm <container>. Exclui um contêiner.

Para obter uma referência completa dos comandos mais usados para imagens, contêineres, volumes e muito mais, confira nosso guia de referência rápida do Docker.

Como gerenciar volumes do Docker

Os volumes são o principal mecanismo do Docker para garantir persistência de dados. Eles permitem que as informações continuem disponíveis mesmo depois que um container é removido.

Isso é essencial porque, ao longo do ciclo de vida de uma aplicação, é comum parar, recriar ou substituir containers para atualizações e manutenção. Se o container executa algo crítico, como um banco de dados, configurar volumes corretamente é indispensável para não perder dados.

O Docker oferece três tipos principais de armazenamento:

• Volumes. Armazenam dados persistentes em uma área gerenciada pelo Docker, geralmente localizada em /var/lib/docker/volumes/ no host.
• Bind mounts. Mapeiam diretamente um arquivo ou diretório do sistema host para dentro do container.
• tmpfs mounts. Mantêm os dados na memória do host; tudo é perdido quando o container é interrompido.

A seguir estão os passos básicos para criar e gerenciar um volume persistente:

1. Crie um volume nomeado usando o seguinte comando. Por exemplo, isso criará um volume chamado my-database-data:

docker volume create my-database-data

2. Inicie o container usando o volume. Use a flag -v para mapear o volume para o diretório interno onde os dados serão armazenados:

docker run -d \
  --name my-database \
  -e MYSQL_ROOT_PASSWORD=senhasegura \
  -v my-database-data:/var/lib/mysql \
  mysql:latest

3. Para verificar os detalhes e a localização do volume no host, execute o seguinte comando:

docker volume inspect my-database-data

4. Para remover volumes não utilizados que não estejam associados a nenhum contêiner e liberar espaço em disco, utilize:

docker volume prune -a

Em vez de usar comandos, você também pode declarar e montar volumes diretamente no arquivo YAML do Docker Compose. Isso facilita o controle de quais volumes cada serviço utiliza, especialmente em aplicações com múltiplos containers.

Por exemplo, o arquivo abaixo recria o mesmo cenário usando Docker Compose:

services:
  my-database:
    image: mysql:latest
    container_name: my-database
    environment:
      MYSQL_ROOT_PASSWORD: securepassword
    volumes:
      - my-database-data:/var/lib/mysql

volumes:
  my-database-data:

Como criar uma rede Docker

As redes do Docker garantem isolamento entre containers e permitem a comunicação tanto entre serviços quanto com sistemas externos. Por padrão, todo container é conectado a uma rede do tipo bridge. No entanto, para aplicações com vários serviços, o ideal é criar uma bridge personalizada.

O Docker usa redes para permitir que containers conversem entre si e com o ambiente externo. Quando você inicia um container sem nenhuma configuração extra, ele é conectado à default bridge network, que permite comunicação básica com o host. O problema é que essa rede padrão tem recursos limitados e não funciona bem em cenários com múltiplos containers interdependentes.

Em aplicações com vários serviços, a boa prática é criar uma rede bridge definida pelo usuário. Esse tipo de rede permite que os containers se comuniquem usando o nome do serviço, o que facilita a descoberta entre eles, melhora o controle da comunicação e reduz interferências entre aplicações.

A forma mais simples de usar uma rede personalizada é declará-la diretamente no arquivo YAML do Docker Compose, usando a diretiva networks. Veja um exemplo:

services:
  my-database:
    image: mysql:latest
    container_name: my-database
    environment:
      MYSQL_ROOT_PASSWORD: senhasegura
    volumes:
      - my-database-data:/var/lib/mysql
    networks:
      - my-app-network  # rede criada para a aplicação

Outra opção é criar a rede manualmente via Docker CLI. O comando abaixo cria uma rede bridge chamada my-app-network:

docker network create my-app-network

Depois disso, você pode iniciar um container e conectá-lo a essa rede usando a flag –network. O exemplo abaixo também define o nome do serviço com –name:

docker run -d \
  --name my-database \
  --network my-app-network \
  -e MYSQL_ROOT_PASSWORD=senhasegura \
  -v my-database-data:/var/lib/mysql \
  mysql:latest

Para adicionar outro container à mesma rede, basta repetir o processo com os ajustes necessários. No exemplo a seguir, a flag -p publica a porta interna 80 do container na porta 8080 do host, permitindo acesso externo:

docker run -d \
  --name my-webapp \
  --network my-app-network \
  -p 8080:80 \
  my-web-app-image:latest

Solucionando problemas comuns do Docker

Ao trabalhar com Docker, os pontos de falha mais comuns costumam estar ligados ao sistema em camadas da plataforma — imagens, containers, volumes e redes. A seguir, você vai ver alguns problemas recorrentes e o que fazer para resolvê-los.

O container encerra imediatamente

Um container pode parar logo após ser iniciado quando o processo principal, definido por CMD ou ENTRYPOINT no Dockerfile, termina a execução ou falha. Isso acontece com frequência quando o Docker tenta rodar um serviço que deveria permanecer ativo sem usar o modo detached.

Veja algumas formas de solucionar esse problema:

• Verifique os logs. Use docker logs <nome_do_container> para analisar as saídas padrão (stdout e stderr) e identificar a causa do encerramento.
• Revise o Dockerfile. Confirme se o arquivo contém as diretivas CMD ou ENTRYPOINT e se elas iniciam um processo de longa duração. Um servidor web, por exemplo, precisa continuar rodando para atender requisições.
• Use o modo detached. Se a aplicação deve rodar em segundo plano, execute o container com a flag -d ou –detach ao usar docker run ou docker compose run.

Problemas com cache de camadas de imagem

Se mudanças no Dockerfile — como a atualização de um pacote — não parecem surtir efeito, é bem provável que você esteja lidando com o cache de camadas do Docker. Esse mecanismo reaproveita camadas já construídas para acelerar o processo de build, em vez de recriar tudo do zero.

Isso melhora o desempenho, mas pode causar confusão quando alterações são feitas nas primeiras instruções do Dockerfile. Nesses casos, o Docker pode reutilizar camadas antigas, fazendo com que etapas posteriores usem versões desatualizadas, mesmo após a modificação do arquivo.

A solução mais simples para esse problema é forçar uma reconstrução completa e ignorar o cache de camadas. Faça isso adicionando o parâmetro –no-cache. opção ao iniciar o processo de compilação, como neste comando:

docker build --no-cache -t my-app:latest .

Ao instalar pacotes usando um Dockerfile, inclua também explicitamente um comando que impeça o gerenciador de pacotes de reutilizar camadas antigas com listas de pacotes desatualizadas. Em distribuições baseadas em Debian, você pode fazer isso combinando `apt-get update` e `apt-get install -y –no-install-recommend` no mesmo comando RUN. declaração como esta:

RUN apt-get update && apt-get install -y --no-install-recommends

Falha de autenticação no registry

Se ao enviar uma imagem para um registry — como o Docker Hub — você receber um erro do tipo “denied: requested access to the resource is denied”, isso indica que o Docker CLI não está autenticado no servidor do registry.

Para resolver, é preciso fazer login e autenticar sua conta. Siga os passos abaixo:

1. Faça login no registro usando o seguinte comando, sendo my-registry-example.com o endereço real do registro. Se você quiser enviar imagens para o Docker Hub, pode omitir o endereço:

docker login my-registry.example.com

2. Digite seu nome de usuário e senha quando solicitado.
3. Antes de enviar a imagem, marque-a corretamente com o host do registro, o repositório e a tag usando este comando:

docker tag my-local-image:latest my-registry.example.com/my-repo/my-local-image:latest

4. Envie a imagem para o registro executando este comando:

docker push my-registry.example.com/my-repo/my-local-image:latest

Quais são os próximos passos para dominar o Docker?

Para realmente dominar o Docker e usá-lo em cenários reais de produção, é preciso ir além do uso de um único container e de comandos básicos. Os próximos passos envolvem aprender técnicas mais avançadas para implantar e gerenciar aplicações complexas, escaláveis e com alta disponibilidade.

Além do Docker Compose, vale aprofundar o estudo em ferramentas de orquestração, como Docker Swarm e Kubernetes. Elas permitem gerenciar vários containers distribuídos em um cluster de máquinas, facilitando o balanceamento de carga, a escalabilidade e a automação do deploy.

Outro ponto importante é entender melhor os drivers de rede do Docker. Um exemplo é o Overlay Network Driver, usado no modo Swarm para conectar containers que rodam em hosts diferentes. Fazer essa conexão manualmente com a rede padrão do Docker é complexo, enquanto as redes overlay simplificam e automatizam a comunicação entre máquinas de forma confiável.

Por fim, explore diferentes casos de uso do Docker. Ver exemplos práticos ajuda a entender como aplicar a containerização em tarefas reais de desenvolvimento e implantação, além de mostrar como essa ferramenta se encaixa em fluxos modernos de trabalho.

Semua konten tutorial di website ini telah melalui peninjauan menyeluruh sesuai padrões editoriais e valores da Hostinger.