Redes e Armazenamento

Redes Docker

# Tipos de rede
docker network ls

# Bridge (padrão) — isolamento entre containers no mesmo host
docker network create --driver bridge minha-rede
docker run --network minha-rede --name app nginx:alpine

# Host — container usa rede do host (sem isolamento)
docker run --network host nginx:alpine

# None — sem rede
docker run --network none alpine:latest

# Overlay — multi-host (Swarm)
docker network create --driver overlay --attachable meu-overlay

Comunicação entre Containers

# Na mesma rede bridge, containers se veem pelo nome
docker network create app-net
docker run -d --network app-net --name db postgres:16-alpine
docker run -d --network app-net --name api -p 3000:3000 minha-api

# De dentro do api:
ping db       # resolve para IP do container db
psql -h db    # conecta no postgres pelo nome do container

DNS e Port Mapping

# Port mapping (acesso externo)
docker run -p 80:80 nginx:alpine          # acesso em localhost:80
docker run -p 127.0.0.1:3000:3000 node    # apenas localhost

# DNS interno do Docker usa embedded DNS (127.0.0.11)
# Containers na mesma rede se resolvem pelo nome do container

Volumes vs Bind Mounts

# Volume — gerenciado pelo Docker
docker volume create app-data
docker volume ls
docker volume inspect app-data
docker run -v app-data:/data nginx:alpine

# Bind Mount — path local
docker run -v $(pwd)/html:/usr/share/nginx/html:ro nginx:alpine

# tmpfs — em memória
docker run --tmpfs /tmp alpine:latest

# Backup de volume
docker run --rm -v app-data:/data -v $(pwd):/backup alpine \
  tar czf /backup/app-data.tar.gz -C /data .

Storage Drivers

Docker → Storage Driver → Filesystem
├── overlay2 (padrão, recomendado)
├── fuse-overlay2 (rootless)
├── devicemapper (legado, evitar)
└── btrfs/zfs (se o filesystem suportar)

docker info | grep Storage  # verificar driver atual

Docker Layers e Cache

Dockerfile:
FROM node:20-alpine         → Layer 1 (base)
WORKDIR /app                → Layer 2 (metadados)
COPY package*.json ./       → Layer 3 (muda raramente → cache hit!)
RUN npm install             → Layer 4 (cache se package.json não mudou)
COPY . .                    → Layer 5 (muda sempre)
CMD ["node", "app.js"]      → Layer 6 (metadados)

# Ver layers
docker history minha-imagem

# Cache: layers são reusados se nada mudou
# Estratégia: copiar package.json ANTES do código
# para npm install ficar em cache

Lab: NFS Volume

# docker-compose com NFS
services:
  app:
    image: nginx:alpine
    volumes:
      - nfs-data:/data

volumes:
  nfs-data:
    driver: local
    driver_opts:
      type: nfs
      o: addr=192.168.1.100,rw,nfsvers=4
      device: :/exports/data

Entenda camadas (layers) para otimizar builds. Prefira volumes a bind mounts em produção. Network bridge com nome de container é o padrão para comunicação entre serviços.