Learn Docker Help

Containers 101

╔═══════════════════════════════════════════════════════════════════════╗ ║ CONTAINER BASICS MATRIX ║ ║ ║ ║ [ Container = Aplicação + Dependências + Runtime ] ║ ║ ║ ║ "Tudo que você precisa, nada que você não precisa" ║ ║ ║ ╚═══════════════════════════════════════════════════════════════════════╝

O que é um Container? 📦

Um container é como uma cápsula auto-suficiente que contém:

  • Sua aplicação

  • Bibliotecas necessárias

  • Configurações

  • Runtime environment

┌──────────────────────┐ │ Sua Aplicação │ ├──────────────────────┤ │ Dependências │ ├──────────────────────┤ │ Runtime │ └──────────────────────┘

Anatomia de um Container 🔬

Componentes Principais

  1. Namespace - Isolamento de processos

  2. Cgroups - Controle de recursos

  3. Union Filesystem - Sistema de arquivos em camadas

  4. Container Runtime - Motor de execução

Por Que Usar Containers? 🤔

Benefícios

  • Isolamento consistente

  • Portabilidade garantida

  • Deploy simplificado

  • Escalabilidade fácil

  • Versionamento eficiente

Waifu Tips 💡

Conceitos Fundamentais 📚

1. Imutabilidade

  • Containers não devem ser modificados em runtime

  • Mudanças através de novas builds

  • Tratados como gado, não como pets

2. Isolamento

┌────────────App 1─────┐ ┌────────────App 2─────┐ │ ┌──────────────┐ │ │ ┌──────────────┐ │ │ │ Process │ │ │ │ Process │ │ │ └──────────────┘ │ │ └──────────────┘ │ │ ▼ │ │ ▼ │ │ ┌──────────────┐ │ │ ┌──────────────┐ │ │ │ Filesystem │ │ │ │ Filesystem │ │ │ └──────────────┘ │ │ └──────────────┘ │ └────────────────────┘ └────────────────────────┘

3. Recursos Limitados

  • CPU controlada

  • Memória definida

  • I/O gerenciado

  • Network isolada

Primeiros Passos 👣

Hello World Container

# Rode seu primeiro container docker run hello-world # Veja o que está rodando docker ps # Veja todos os containers docker ps -a

Container Interativo

# Ubuntu container interativo docker run -it ubuntu bash # Alpine container leve docker run -it alpine sh

Container Lifecycle 🔄

┌──────────┐ ┌──────────┐ ┌──────────┐ │ Created │ ─► │ Running │ ─► │ Stopped │ └──────────┘ └──────────┘ └──────────┘ ▲ │ └──────────────────────────────┘

Comandos de Ciclo de Vida

# Criar container docker create nginx # Iniciar container docker start <container-id> # Parar container docker stop <container-id> # Remover container docker rm <container-id>

Práticas Recomendadas 🎯

DO's ✅

  • Um processo por container

  • Use tags específicas

  • Defina limites de recursos

  • Monitore seus containers

  • Use health checks

DON'Ts ❌

  • Não armazene dados no container

  • Evite containers muito grandes

  • Não use latest tag

  • Não rode como root

  • Não ignore security scans

Exercícios Práticos 🏋️

  1. Hello Container

    # Rode e entenda o hello-world docker run hello-world

  2. Container Persistente

    # Rode nginx com porta exposta docker run -d -p 8080:80 nginx

  3. Container Exploração

    # Entre em um container rodando docker exec -it <container-id> bash

Debug Básico 🔍

Comandos Essenciais

# Logs do container docker logs <container-id> # Processos rodando docker top <container-id> # Estatísticas de uso docker stats <container-id>

Checkpoint ✅

Você agora sabe:

  • [x] O que são containers

  • [x] Como eles funcionam

  • [x] Comandos básicos

  • [x] Boas práticas

  • [x] Ciclo de vida

Próximos Passos 🎯

  1. Explore Docker Hub

  2. Crie seus próprios containers

  3. Aprenda sobre networking

  4. Estude volumes

  5. Pratique com projetos reais

Deep Dive: Camadas de um Container 🧅

Union File System

┌────────────────────────┐ │ Camada R/W │ <- Container Layer ├────────────────────────┤ │ Aplicação │ <- Image Layer 3 ├────────────────────────┤ │ Dependências │ <- Image Layer 2 ├────────────────────────┤ │ Sistema Base │ <- Image Layer 1 └────────────────────────┘

Como as Camadas Funcionam

  1. Base Layer: Sistema operacional mínimo

  2. Middleware Layer: Runtime, libs

  3. Application Layer: Seu código

  4. Container Layer: Mudanças em runtime

Networking Básico 🌐

Tipos de Rede

# Lista redes disponíveis docker network ls # Cria rede customizada docker network create minha-rede # Conecta container à rede docker network connect minha-rede container-id

Modelos de Rede

  1. Bridge (default)

    docker run --network bridge nginx

  2. Host (usa rede do host)

    docker run --network host nginx

  3. None (sem rede)

    docker run --network none nginx

Storage & Volumes 💾

Tipos de Storage

  1. Volumes (gerenciado pelo Docker)

    # Cria volume docker volume create meu-volume # Usa volume docker run -v meu-volume:/data nginx

  2. Bind Mounts (path do host)

    # Monta diretório local docker run -v $(pwd):/app nginx

  3. tmpfs (memória)

    # Armazenamento temporário docker run --tmpfs /app nginx

Container Security 🔒

Boas Práticas de Segurança

  1. Rootless Containers

    # No Dockerfile USER non-root-user

  2. Scan de Vulnerabilidades

    # Scan de imagem docker scan nginx:latest

  3. Limites de Recursos

    # Limita CPU e memória docker run --cpus=.5 --memory=512m nginx

Advanced Commands 🚀

Container Stats

# Stats em tempo real docker stats --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}" # Info detalhada docker inspect container-id

Batch Operations

# Para todos containers docker stop $(docker ps -q) # Remove containers parados docker container prune # Remove tudo docker system prune -a

Troubleshooting Matrix 🔍

Common Issues

Problema

Comando de Debug

Solução

Container não inicia

docker logs

Verifique logs

Porta em uso

docker port

Mude a porta

Sem espaço

docker system df

Limpe recursos

Debug Commands

# Histórico de comandos docker history imagem:tag # Eventos em tempo real docker events # Diff de alterações docker diff container-id

Container Development Workflow 🔄

Local Development

  1. Build Local

    docker build -t app:dev .

  2. Hot Reload

    docker run -v $(pwd):/app app:dev

  3. Debug Mode

    docker run --rm -it app:dev sh

Multi-container Setup

# docker-compose.yml version: '3.8' services: app: build: . ports: - "3000:3000" db: image: postgres environment: POSTGRES_PASSWORD: secret

Performance Tuning 🏎️

Otimizações

  1. Multi-stage Builds

    FROM node:alpine AS builder WORKDIR /app COPY . . RUN npm run build FROM nginx:alpine COPY --from=builder /app/dist /usr/share/nginx/html

  2. Cache Optimization

    COPY package*.json ./ RUN npm install COPY . .

  3. Resource Limits

    docker run \ --cpus=2 \ --memory=2g \ --memory-reservation=1g \ --memory-swap=4g \ nginx

Waifu Advanced Tips 🎮

Container Patterns 📋

Sidecar Pattern

┌────────────────────┐ │ Main Container │◄──┐ └────────────────────┘ │ │ ┌────────────────────┐ │ │ Sidecar Container │───┘ └────────────────────┘

Ambassador Pattern

┌────────────────────┐ ┌────────────────┐ │ Main Container │◄──│ Ambassador │ └────────────────────┘ └────────────────┘

Exercícios Avançados 🏋️‍♂️

  1. Multi-container App

    • Crie uma aplicação web com frontend, backend e database

    • Use docker-compose

    • Implemente volumes persistentes

  2. Custom Network

    • Configure rede bridge customizada

    • Conecte múltiplos containers

    • Teste comunicação entre containers

  3. Resource Monitoring

    • Configure limites de recursos

    • Monitore uso com docker stats

    • Implemente health checks

Certificação Checkpoint 📝

Prepare-se para certificações Docker com estes conceitos:

  • [x] Container internals

  • [x] Networking modes

  • [x] Storage options

  • [x] Security best practices

  • [x] Resource management

  • [x] Troubleshooting

  • [x] Container patterns

Stateful vs Stateless 🔄

Stateless Containers

┌────────────────────┐ │ Stateless App │ │ ┌──────────────┐ │ │ │ Request │ │ │ │ Process │──┼─► Response │ │ Response │ │ │ └──────────────┘ │ └────────────────────┘ No State ❌

Características

  • Não mantém estado entre requisições

  • Facilmente escalável

  • Pode ser substituído a qualquer momento

  • Ideal para microserviços

Exemplos de Uso

  • Web servers

  • API endpoints

  • Processamento de filas

  • Transformação de dados

Stateful Containers

┌────────────────────┐ │ Stateful App │ │ ┌──────────────┐ │ │ │ Process │ │ │ └──────┬───────┘ │ │ ▼ │ │ ┌──────────────┐ │ │ │ State │ │ │ └──────────────┘ │ └────────────────────┘ Persistent ✅

Características

  • Mantém dados entre restarts

  • Requer volumes persistentes

  • Mais complexo para escalar

  • Precisa de backup strategy

Exemplos de Uso

  • Databases

  • Cache systems

  • Message queues

  • Session stores

Containers vs VMs: Análise Detalhada 🔍

Comparação de Arquitetura

┌─────────Containers─────────┐ ┌──────────VMs──────────┐ │ ┌────┐ ┌────┐ ┌────┐ │ │ ┌────┐ ┌────┐ ┌────┐ │ │ │App1│ │App2│ │App3│ │ │ │App1│ │App2│ │App3│ │ │ └────┘ └────┘ └────┘ │ │ └────┘ └────┘ └────┘ │ │ Container Engine │ │ ┌────┐ ┌────┐ ┌────┐ │ │ │ │ │ │ OS │ │ OS │ │ OS │ │ │ Host Kernel │ │ └────┘ └────┘ └────┘ │ └───────────────────────────┘ │ Hypervisor │ └─────────────────────────┘

Matriz de Comparação

Aspecto

Containers

VMs

Boot Time

Segundos

Minutos

Tamanho

MBs

GBs

Performance

Próximo ao bare metal

Overhead significativo

Isolamento

Processo-level

Hardware-level

Portabilidade

Muito alta

Limitada

Segurança

Compartilha kernel

Totalmente isolada

Densidade

Alta (100s)

Baixa (10s)

Use Cases Detalhados 🎯

Ideal para Containers

  1. Microserviços

┌────────────────────────────────────────┐ │ Microservices Architecture │ │ ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐ │ │ │API │ │Auth│ │Cart│ │User│ │Pay │ │ │ └────┘ └────┘ └────┘ └────┘ └────┘ │ └────────────────────────────────────────┘

  1. CI/CD Pipelines

┌─────┐ ┌──────┐ ┌─────┐ ┌──────┐ │Build│ ► │Test │ ► │Stage│ ► │Deploy│ └─────┘ └──────┘ └─────┘ └──────┘

  1. Desenvolvimento Local

┌────────────────────┐ │ Dev Environment │ │ ┌────┐ ┌────────┐ │ │ │App │ │Database│ │ │ └────┘ └────────┘ │ └────────────────────┘

Ideal para VMs

  1. Legacy Applications

┌────────────────────────┐ │ Monolithic App │ │ ┌──────────────────┐ │ │ │ Full Stack App │ │ │ │ + Dependencies │ │ │ │ + Full OS │ │ │ └──────────────────┘ │ └────────────────────────┘

  1. Isolamento Completo

┌────────────────────┐ │ Secure VM │ │ ┌───────────────┐ │ │ │ Encrypted │ │ │ │ Environment │ │ │ └───────────────┘ │ └────────────────────┘

Padrões de Deployment 🚀

Blue-Green Deployment

┌────────Blue───────┐ ┌────────Green──────┐ │ Version 1.0 │ │ Version 1.1 │ │ ┌────────────┐ │ │ ┌────────────┐ │ │ │ Container │ │ │ │ Container │ │ │ └────────────┘ │ │ └────────────┘ │ └──────────┬────────┘ └──────────┬────────┘ │ │ ┌──────┴───────────────────────┴───────┐ │ Load Balancer │ └────────────────────────────────────┬─┘ │ Traffic

Rolling Updates

┌────────────────────────────────────────┐ │ V1 │ V1 │ V2 │ V2 │ ├──────────┼──────────┼──────────┼───────┤ │ V1 │ V2 │ V2 │ V2 │ └────────────────────────────────────────┘ Time ───────────────────────►

Estratégias de Persistência 💾

Volume Types

┌────────────────────┐ │ Container │ │ ┌──────────────┐ │ │ │ Application │ │ │ └──────┬───────┘ │ │ ▼ │ │ ┌──────────────┐ │ │ │ Volume │──┼──► Host Storage │ └──────────────┘ │ └────────────────────┘

  1. Named Volumes

docker volume create mydata docker run -v mydata:/data nginx

  1. Bind Mounts

docker run -v /host/path:/container/path nginx

  1. tmpfs Mounts

docker run --tmpfs /tmp nginx

Networking Avançado 🌐

Network Types

┌────────────────────┐ │ Container A │ │ 172.17.0.2 │ └──────────┬─────────┘ │ ┌──────────┴─────────┐ │ Docker Network │ │ 172.17.0.0/16 │ └──────────┬─────────┘ │ ┌──────────┴─────────┐ │ Container B │ │ 172.17.0.3 │ └────────────────────┘

Network Modes

  1. Bridge Network

    • Default network driver

    • Isolated network

    • Port mapping

  2. Host Network

    • Uses host networking

    • Better performance

    • Less isolation

  3. Overlay Network

    • Multi-host networking

    • Swarm mode

    • Service discovery

Monitoramento e Logging 📊

Monitoring Stack

┌────────────────┐ ┌────────────────┐ │ Container │ │ Prometheus │ │ ┌──────────┐ │ │ Metrics DB │ │ │ App │ │ │ │ │ │ +Metrics │ │───►│ ┌──────────┐ │ │ └──────────┘ │ │ │ Grafana │ │ └────────────────┘ │ └──────────┘ │ └────────────────┘

Logging Patterns

  1. Stdout/Stderr

docker logs container_id

  1. Sidecar Logger

services: app: image: myapp logger: image: fluentd volumes: - /var/log:/logs

Waifu Tips 🎮

Próximos Passos 🎯

  1. Explore Docker Hub

  2. Crie seus próprios containers

  3. Aprenda sobre networking

  4. Estude volumes

  5. Pratique com projetos reais

15 abril 2025
CLI Basics: Dominando o Terminal Docker 🎮Ciclo de Vida dos Containers: Do Nascimento à Transcendência 🔄