DOCKER —- SUPREME GUIDE

📘 Sobre Docker: Entendendo Containers x Máquinas Virtuais de Forma Técnica e Profunda

🧠 Módulo 1: Fundamentos da Virtualização — Docker vs Máquinas Virtuais

🧱 1.1. Arquitetura Computacional: Recursos Fundamentais

• CPU (Unidade Central de Processamento): núcleo(s) de processamento responsáveis por executar instruções;

• Memória RAM (Random Access Memory): armazenamento volátil de alta velocidade, usado para manter dados e processos temporariamente em execução;

• Armazenamento (HD/SSD): onde os dados persistentes são mantidos — variando entre gigabytes (GB) e terabytes (TB);

• Periféricos: dispositivos de entrada e saída, como câmera, microfone, teclado, GPU, etc.

🔧 1.2. Papel do Sistema Operacional e do Kernel

• Kernel (Núcleo): a camada mais fundamental do sistema. Atua como intermediário entre o hardware físico e os processos (softwares) executados. Ele gerencia:
• A alocação de memória,
• A execução e escalonamento de processos,
• A comunicação com drivers de dispositivos,
• E o controle de permissões e chamadas de sistema.

• Processos de Espaço do Usuário: aplicações e serviços que interagem com o kernel através de APIs, bibliotecas e chamadas de sistema.

🧩 1.3. A Nova Era da Eficiência: Virtualização e Portabilidade

🖥️ 1.4. Como Funcionam as Máquinas Virtuais

• Um sistema operacional próprio (Guest OS),

• Suas bibliotecas,

• Suas dependências,

• E seus arquivos e aplicações.

⚙️ Exemplo Prático

• 12 núcleos de CPU

• 24 GB de memória RAM

• 4 núcleos de CPU

• 8 GB de RAM

• A VM consome exclusivamente os 4 núcleos e 8 GB enquanto estiver ativa;

• Esses recursos ficam inacessíveis ao sistema Host (Linux) durante o tempo de execução;

• Periféricos (como webcam ou microfone) podem ser "passados" diretamente à VM — mas novamente, ficam indisponíveis para o Host até a VM ser desligada.

🧠 Observação crítica: A tecnologia que viabiliza essa virtualização de hardware é chamada de Hypervisor— um software especializado que gerencia múltiplos sistemas operacionais no mesmo hardware físico.

⚖️ 1.5. Características Técnicas das VMs

✅ Vantagens:

• Isolamento Total: cada VM opera em um ambiente fechado, ideal para segurança, sandboxing, ambientes heterogêneos (Linux dentro de Windows e vice-versa);

• Ambientes Dedicados: perfeito para simular infraestruturas completas;

• Compatibilidade Completa: permite rodar aplicações que exigem um sistema operacional específico.

❌ Desvantagens:

• Alto consumo de recursos: exige memória e armazenamento duplicado por conta de múltiplos SOs;

• Inicialização demorada: boot do SO, carregamento de serviços e inicialização de aplicações;

• Menor portabilidade: mover VMs entre sistemas exige muito mais tempo, configuração e compatibilidade.

🔎 1.6. O Papel das VMs na Arquitetura Moderna

• Data centers corporativos tradicionais

• Ambientes regulados ou com requisitos legais de isolamento

• Execução de sistemas legados, onde não há opção de migrar para contêineres,

• Simulações e testes de segurança, onde o isolamento é vital.

🐳 1.7. O Modelo Docker: Containerização Moderna de Aplicações

🚢 A Filosofia por Trás do Docker

🔬 1.8. O Que São Containers, Tecnicamente?

• O kernel é único e compartilhado

• Mas cada container possui:
• Suas próprias bibliotecas,
• Suas dependências,
• Suas variáveis de ambiente,
• E sua percepção isolada do sistema.

• Rode como se estivesse em um sistema separado,

• Mas com muito menos sobrecarga que uma VM.

🧱 1.9. Containerização na Prática: Eficiência por Design

• Por padrão, ele enxerga todos os recursos do host (12 núcleos, 24GB);

• No entanto, você pode restringir explicitamente os recursos disponíveis com flags como -cpus, -memory ou control groups (cgroups).

🧠 Exemplo:

bash
CopiarEditar
docker run --cpus="2.0" --memory="1g" ubuntu

Aqui, você está limitando o container a 2 núcleos de CPU e 1GB de RAM, mesmo que o host tenha mais.

🔐 1.10. Isolamento com Namespaces

• PID Namespace → isola processos;

• NET Namespace → isola interfaces de rede;

• MNT Namespace → isola sistema de arquivos montado;

• UTS Namespace → isola hostname;

• IPC Namespace → isola comunicação entre processos;

• USER Namespace → permite mapeamento de UID/GID distintos.

🧬 Visualização:

• O container verá apenas o processo C;

• O host verá A, B e C.

• Segurança por isolamento,

• Redução de conflitos entre processos,

• Capacidade de executar múltiplos containers simultaneamente, mesmo com aplicações idênticas.

⚙️ 1.11. Leveza e Escalabilidade Extrema

• Iniciam em milissegundos;

• Consumem muito menos memória e disco;

• Permitem rodar dezenas, centenas ou milhares em uma única máquina poderosa — algo impossível com VMs.

• Cada container executa uma pequena parte (serviço) de uma aplicação maior;

• Serviços são escaláveis, modulares e substituíveis sem afetar o restante do sistema.

🧳 1.12. Portabilidade e Consistência Total

• Ambientes consistentes, independentemente de onde você executa:
• Sua máquina local,
• Um servidor de staging,
• Um cluster Kubernetes,
• Ou um provedor cloud como AWS, GCP ou Azure.

• Evita o clássico problema de "na minha máquina funciona".

🖥️ 1.13. Compatibilidade com Hosts Não-Linux

• Docker Desktop inicia uma VM leve com kernel Linux (geralmente via Hyper-V, WSL2 ou QEMU);

• Essa VM fornece o ambiente Linux necessário;

• O usuário continua interagindo normalmente com docker run, docker build, etc.

🧪 1.14. Aplicações Reais dos Containers

📦 Casos de uso ideais:

• Desenvolvimento de Software com Ambientes Consistentes

• Deploy de Aplicações em Produção

• Execução de Microserviços

• Testes Automatizados com Ambientes Isolados

• CI/CD Pipelines (Integração e Entrega Contínuas)

📘 1.15. Conceitos Fundamentais do Docker

🔍 O Que é o Docker?

• Código-fonte,

• Ambiente de execução (runtime),

• Bibliotecas e dependências do sistema,

• Ferramentas auxiliares (CLI, scripts, utilitários),

• Variáveis de ambiente e configurações,

📦 1.16. O Que é um Container Docker?

• Leve: Compartilha o kernel com o host e outros containers;

• Isolado: Cada container tem seu próprio espaço de execução e recursos isolados;

• Portável: Pode ser executado de forma idêntica em qualquer ambiente (dev, teste, produção, cloud);

• Reprodutível: Garante que o comportamento da aplicação seja o mesmo, independentemente de onde esteja rodando.

Resumo poderoso: Um container é como uma "mini máquina virtual" dedicada à sua aplicação — mas sem o peso e a sobrecarga de um sistema operacional completo.

🔧 1.17. Componentes Essenciais do Docker

1. Docker Engine

• A construção de imagens (docker build),

• A execução de containers (docker run),

• O controle de redes, volumes, logs, etc.

2. Docker Images

Exemplo de Dockerfile simplificado:

dockerfile
CopiarEditar
FROM python:3.11
COPY . /app
WORKDIR /app
RUN pip install -r requirements.txt
CMD ["python", "main.py"]

🧠 Isso cria uma imagem que:

• Usa Python 3.11 como base,

• Copia seu código para dentro do container,

• Instala as dependências,

• E executa o script main.py.

3. Docker Containers

• Imagem = blueprint (projeto arquitetônico);

• Container = construção final baseada nesse blueprint.

• Ter seu próprio ciclo de vida (start, stop, pause, remove),

• Ser destruído e recriado com facilidade,

• Ser atualizado de forma incremental com novos builds.

4. Docker Registry

• O Docker Hub é o registro público padrão e gratuito;

• Também existem registros privados como Harbor, GitLab Container Registry, AWS ECR, Azure ACR, entre outros.

Com um registry, você pode versionar suas imagens, compartilhá-las entre equipes, integrá-las com pipelines CI/CD e mantê-las seguras.

🏗️ 1.18. Arquitetura do Docker: Modelo Cliente-Servidor

🖥️ 1. Docker Daemon (dockerd)

• É o servidor que escuta comandos do cliente;

• Gerencia os containers, imagens, volumes, redes;

• Exige permissões administrativas para rodar;

• Roda como serviço em segundo plano.

💻 2. Docker Client (docker)

• Interface linha de comando (CLI) com a qual o desenvolvedor interage diretamente;

• Cada comando que você roda (docker run, docker build, etc.) envia instruções ao dockerd via API HTTP(RESTful).

🧠 Exemplo:

bash
CopiarEditar
docker run nginx

Esse comando envia uma requisição HTTP para o daemon requisitando a execução de um container baseado na imagem nginx.

☁️ 3. Docker Registry

• Onde as imagens são armazenadas, versionadas e publicadas;

• O daemon pode puxar (pull) ou publicar (push) imagens para o registro;

• Registries privados exigem autenticação via docker login.

🔐 1.19. Isolamento, Segurança e Modularidade

• Isolamento de rede

• Isolamento de sistema de arquivos

• Controle de acesso ao hardware

• Capacidades reduzidas por padrão

🚀 1.20. Por Que o Docker Revolucionou o Desenvolvimento?

Vantagens Estratégicas:

• Elimina problemas de ambiente: "Funciona na minha máquina" não existe mais.

• Reduz tempo de setup: de horas para segundos.

• Permite DevOps real: integração contínua, testes, deploys automatizados.

• Padroniza ambientes: em times pequenos ou empresas globais.

• Acelera escopo de CI/CD, microserviços e escalabilidade.

📘 1.21. Uso Prático do Docker: Instalação, Testes e Primeiros Passos

🧰 Instalação do Docker: Abordagens Práticas por Sistema Operacional

🖥️ 1. Docker Desktop (GUI)

• Interface gráfica para gerenciamento de containers, imagens, volumes e redes;

• Visualização de consumo de recursos em tempo real;

• Instalação simplificada do Docker Engine + CLI + VM de suporte.

✅ Recomendado para iniciantes, desenvolvedores e ambientes locais.

🔗 Link oficial:

🍎 2. Instalação via Homebrew (macOS e Linux)

💻 Comando:

bash
CopiarEditar
brew install docker

🐧 3. Instalação Manual no Linux (Servidor)

✅ Recomendado para sysadmins, servidores cloud, ambientes de produção.

📚 Guia prático:

• O tutorial completo de instalação pode ser acessado em:
👉 Instalação Docker Engine no Linux (docker.io)

1. Atualizar pacotes;

2. Adicionar o repositório oficial do Docker;

3. Instalar os pacotes docker-ce, docker-ce-cli, containerd.io;

4. Habilitar o serviço com systemctl.

🤖 1.22. Comando Inicial: docker run hello-world

bash
CopiarEditar
docker run hello-world

🔍 O Que Esse Comando Faz?

🚀 Etapas que acontecem nos bastidores:

1. Busca local da imagem:
O Docker verifica se a imagem hello-world já está presente localmente.

2. Download da imagem (se necessário):
Se a imagem não estiver presente, o Docker realiza o pull automático do repositório Docker Hub, o registro público padrão.

3. Criação do container:
Com a imagem em mãos, o Docker instancia um container temporário com base nela.

4. Execução do código contido na imagem:
O container executa um simples programa que imprime uma mensagem confirmando que o Docker está funcionando corretamente.

5. Finalização automática:
O container é encerrado assim que a execução termina, pois sua função é unicamente exibir a mensagem.

📦 Output Esperado:

bash
CopiarEditar
Hello from Docker!
This message shows that your installation appears to be working correctly.

Se você recebeu essa mensagem, sua instalação está 100% funcional.

📘 1.23. Detalhamento Técnico do docker run

bash
CopiarEditar
docker run hello-world

🔬 Componente por componente:

• docker: chama o cliente da CLI;

• run: comando que solicita ao Docker Engine que:
• baixe a imagem (se necessário),
• crie um container,
• execute o processo padrão da imagem (definido no Dockerfile);

• hello-world: nome da imagem que será utilizada como base.

🎯 1.24. Por que esse comando é importante?

• Valida a instalação do Docker localmente;

• Testa a comunicação entre cliente e daemon;

• Confirma acesso ao Docker Hub (internet + autenticação se necessário);

• Demonstra o ciclo completo: Pull → Create → Start → Execute → Exit.

🧠 Dica de diagnóstico: Se o docker run hello-world falhar, o problema pode estar na instalação, no daemon ou no acesso à internet (pull de imagem).

🔄 Fluxo Resumido: Primeira Execução com Docker

plaintext
CopiarEditar
[CLI] docker run hello-world
  ↓
[Cliente] Envia requisição → [Daemon]
  ↓
[Daemon] Verifica se a imagem existe localmente
  ↓
[Se não] → Puxa imagem do Docker Hub
  ↓
Cria container → Executa aplicação → Exibe mensagem → Container f

📘 1.25. Dockerfile: Construindo Imagens de Forma Declarativa

🧱 O Que é um Dockerfile?

• O sistema operacional base,

• As bibliotecas,

• O código da aplicação,

• E os comandos padrão de execução.

📝 1.26. Exemplo Simples de Dockerfile

dockerfile
CopiarEditar
FROM alpine
CMD ["echo", "simple echo output"]

🔍 Análise Linha a Linha

🔹 FROM alpine

• Especifica a imagem base da qual a nova imagem será construída.

• Neste caso, estamos utilizando a imagem oficial Alpine Linux — uma distribuição minimalista, extremamente leve (~5MB), ideal para containers enxutos e rápidos.

Fonte: Alpine no Docker Hub

🔹 CMD ["echo", "simple echo output"]

• Define o comando padrão que será executado quando o container for iniciado.

• O uso de sintaxe em forma de array JSON é preferido, pois evita invocação de um shell (sh -c) e oferece maior previsibilidade.

Ao executar o container, ele rodará:

bash
CopiarEditar
echo "simple echo output"

🏗️ 1.27. Construindo uma Imagem Docker com o Dockerfile

bash
CopiarEditar
docker build --tag test:0.1 .

🔍 Explicação dos parâmetros:

• docker build: comando que constrói uma nova imagem Docker;

• -tag test:0.1: define a tag (nome + versão) da imagem gerada. Nesse caso, o nome é test e a versão é 0.1;

• . (ponto): indica que o Dockerfile está localizado no diretório atual.

Por convenção, imagens seguem o formato:

nome_da_imagem:tag

Exemplo: nginx:latest, python:3.11-slim

🚀 1.28. Executando a Imagem Criada

bash
CopiarEditar
docker run test:0.1

Isso criará um novo container, baseado na imagem test:0.1, que executará:

bash
CopiarEditar
echo "simple echo output"

bash
CopiarEditar
simple echo output

🔎 1.29. Explorando a Imagem e o Container Criado

📦 Listar Imagens Disponíveis

bash
CopiarEditar
docker images

Exibe todas as imagens disponíveis localmente, incluindo:

• Nome (REPOSITORY)

• Tag (TAG)

• ID da imagem (IMAGE ID)

• Data de criação

• Tamanho

📋 Ver Containers em Execução

bash
CopiarEditar
docker container ls

Mostra apenas os containers ativos no momento.

🧟 Ver Todos os Containers (incluindo encerrados)

bash
CopiarEditar
docker container ls -a

Lista todos os containers, inclusive os que já foram finalizados (Exited).

🧠 Dica Profissional: Ciclo de Vida do Container

plaintext
CopiarEditar
docker build → cria imagem
↓
docker run   → instancia container da imagem
↓
Container executa o comando
↓
Comando finaliza → Container entra em estado "Exited"
↓
Container pode ser reiniciado, removido, ou inspecionado

🧪 1.30. Boas Práticas com Dockerfile

• ❗ Sempre comece com a menor imagem base possível (Alpine, Slim, etc.);

• 🔁 Use múltiplos estágios de build (multi-stage builds) para otimizar imagens de produção;

• 🧹 Remova dependências desnecessárias no final da build;

• 🔒 Nunca inclua segredos, tokens ou credenciais dentro do Dockerfile;

• 📂 Use .dockerignore para excluir arquivos inúteis da build (como .git, node_modules, etc).

📘 1.31. Execução Interativa e Gerenciamento de Containers no Docker

🧪 Relembrando: Por que o container anterior desapareceu do docker container ls?

📌 Como visualizar containers encerrados?

bash
CopiarEditar
docker container ls -a

Esse comando lista todos os containers, inclusive os que já terminaram a execução.

🚀 Execução Interativa de Container com Shell

bash
CopiarEditar
docker run --rm -it --name test_container test:0.1 /bin/sh

🔍 Análise Completa do Comando

🧠 O comando sh é o shell padrão minimalista disponível em sistemas Alpine Linux.

✅ O Que Acontece Quando Você Executa Isso:

1. O Docker cria um container com base na imagem test:0.1;

2. Entra no modo interativo;

3. Abre um shell (sh) dentro do container;

4. Permite você usar comandos como ls, cd, echo, etc;

5. Ao digitar exit, o container termina;

6. Como foi executado com -rm, o container é automaticamente removido.

🖥️ Exemplos de Uso Dentro do Container

bash
CopiarEditar
ls            # Listar arquivos
cat /etc/os-release   # Ver informações do Alpine Linux
apk add curl          # Instalar pacotes via gerenciador Alpine

🧹 Limpando Containers que Já Terminaram

📋 Ver containers finalizados:

bash
CopiarEditar
docker container ls -a

plaintext
CopiarEditar
CONTAINER ID   IMAGE        COMMAND                 STATUS                     NAMES
ed35a0fceeaa   test:0.1     "echo simple echo ..."  Exited (0) 2 minutes ago   sharp_minsky

🗑️ Remover container usando ID (parcial):

bash
CopiarEditar
docker container rm ed35

Pode usar apenas os 4 primeiros dígitos do ID, se forem únicos.

🗑️ Remover usando nome:

bash
CopiarEditar
docker container rm sharp_minsky

🧠 Dica Profissional: Automatize a Limpeza

bash
CopiarEditar
docker container prune

⚠️ Cuidado: remove todos containers que estão em Exited, sem perguntar.

📜 Fluxo Completo: Criar, Explorar e Limpar

bash
CopiarEditar
docker build -t test:0.1 .                  # Cria imagem
docker run test:0.1                         # Executa (comando echo, sai rapidamente)
docker container ls -a                      # Verifica container Exited
docker run --rm -it --name test_container test:0.1 /bin/sh   # Executa interativamente
(exit)                                      # Sai do container
docker container ls                         # Nada aparece (foi removido com --rm)
docker container rm <ID ou nome>            # Remove containers residuais

📘 1.32. Persistência de Dados em Containers com Volumes

🧪 O Problema da Volatilidade de Containers

• Geram logs,

• Armazenam arquivos temporários,

• Usam bancos de dados locais,

• Fazem uploads de usuários.

💾 A Solução: Volumes

• Compartilhar dados entre containers;

• Manter dados intactos mesmo após a destruição do container;

• Controlar de forma mais precisa a origem e o destino dos arquivos usados.

🧰 1.33. Tipos de Volumes no Docker

1. Bind Mounts (Montagens Diretas do Host)

🔧 Sintaxe:

bash
CopiarEditar
docker run -v <caminho_no_host>:<caminho_no_container> <imagem>

📌 Exemplo prático:

bash
CopiarEditar
docker run -v $(pwd)/data:/app/data alpine ls /app/data

Monta o diretório local ./data no caminho /app/data dentro do container Alpine, e lista os arquivos contidos.

2. Named Volumes (Volumes Gerenciados pelo Docker)

🔧 Sintaxe:

bash
CopiarEditar
docker volume create meu_volume
docker run -v meu_volume:/app/data alpine

Docker irá automaticamente:

• Criar o volume (se não existir),

• Mapear o volume para o caminho dentro do container.

📂 1.34. Bind Mount vs Named Volume: Diferenças Estratégicas

🔐 1.35. Permissões e Propriedade de Arquivos

• Qualquer arquivo criado em um volume montado (via v) será propriedade do root;

• Pode causar problemas de permissões no host (ex: arquivos não-editáveis sem sudo);

• Em macOS, o Docker Desktop faz o bind mount como o usuário que executou o comando.

🧠 Solução Profissional:

• Use -user para mapear UID/GID manualmente;

• Configure permissões no host;

• Use volumes Docker gerenciados em produção para evitar conflitos.

📦 1.36. Criando e Gerenciando Named Volumes

✅ Criar um volume:

bash
CopiarEditar
docker volume create meu_volume

🔍 Listar volumes:

bash
CopiarEditar
docker volume ls

🔎 Inspecionar detalhes:

bash
CopiarEditar
docker volume inspect meu_volume

🧹 Remover volume:

bash
CopiarEditar
docker volume rm meu_volume

🔁 1.37. Exemplo Avançado: Usando Named Volume com MySQL

bash
CopiarEditar
docker volume create mysql_data

docker run -d \
  --name meu_mysql \
  -e MYSQL_ROOT_PASSWORD=123456 \
  -v mysql_data:/var/lib/mysql \
  mysql:5.7

Isso cria um container do MySQL persistente com os dados gravados em um volume chamado mysql_data, que não será removido ao deletar o container.

🧪 1.38. Dica: Visualizando Conteúdo de Volumes

bash
CopiarEditar
sudo ls /var/lib/docker/volumes/meu_volume/_data

🧠 Conclusão Técnica: Quando Usar o Que?

📘 1.39. Expondo Portas no Docker: Comunicação com o Mundo Externo

🌐 O Problema: Como tornar um serviço acessível fora do container?

🔧 1.40. Duas Etapas para Expor uma Porta Docker

✅ 1. No Dockerfile: Definir a porta interna

dockerfile
CopiarEditar
EXPOSE <porta_interna>

Esta instrução é documentacional — serve para registrar qual porta o container usa internamente.

Ela não mapeia automaticamente a porta para o host. Essa ação é feita no próximo passo.

✅ 2. No docker run: Mapear porta do container para o host

bash
CopiarEditar
docker run -p <porta_host>:<porta_container> <imagem>

Isso cria um redirecionamento entre a porta pública no host e a porta interna usada pelo serviço no container.

🧠 Entendendo a Sintaxe do p

bash
CopiarEditar
-p 8080:80

• A porta 80 (interna ao container) será acessível externamente via porta 8080 no host.

• Se você abrir http://localhost:8080, estará atingindo o serviço rodando na porta 80 do container.

📦 Exemplo Prático: Jupyter com TensorFlow + PyTorch

bash
CopiarEditar
docker run --rm \
  -v $(pwd):/iti \
  -p 8765:8888 \
  infotrend/ctpo-jupyter-tensorflow_pytorch_opencv

🔍 Análise Detalhada:

🧪 O que esse comando faz?

• Roda um container que inicia um servidor Jupyter Lab escutando na porta 8888;

• Monta o diretório atual para salvar os notebooks e arquivos usados;

• Torna o Jupyter acessível via http://localhost:8765 no navegador do host;

• Após encerramento do container (CTRL+C ou exit no Jupyter), ele é automaticamente removido.

🔐 Considerações de Segurança

• Ao usar p, você está expondo um serviço local na rede externa. Em ambientes de produção, isso pode representar risco.

• Use firewalls, reverse proxies (ex: Nginx) e autenticação JWT quando necessário.

• Nunca exponha serviços sem autenticação em portas públicas da internet (ex: Redis, MySQL, APIs REST).

⚙️ EXPOSE vs -p: Diferenças Fundamentais

🎯 Visualização do Fluxo de Rede

plaintext
CopiarEditar
[Internet ou Navegador Local]
       ↓
Host:Porta 8765
       ↓
(Docker Engine faz NAT)
       ↓
Container:Porta 8888 (Jupyter)

🧠 Dica de Diagnóstico

• Use docker container inspect <container> para verificar as portas expostas e mapeadas;

• Use ss -tuln ou netstat -tuln no host para ver quais portas estão abertas;

• Com Docker Desktop, você pode visualizar as portas ativas diretamente pela interface gráfica.

🔄 Exemplo de Dockerfile com EXPOSE

dockerfile
CopiarEditar
FROM python:3.11-slim
RUN pip install jupyter
WORKDIR /notebooks
EXPOSE 8888
CMD ["jupyter", "lab", "--ip=0.0.0.0", "--port=8888", "--allow-root", "--no-browser"]

Aqui, estamos criando uma imagem com Jupyter configurado e expondo a porta 8888, que depois pode ser publicada com -p.

Autor do artigo

AGENDE AGORA !