Padrões OCI & Docker Debian 13 (Trixie) Compose, Swarm & K3s Podman Rootless & Cgroups v2

Containers e Orquestração no Debian 13

Guia aprofundado para planejamento, implantação e operação de ambientes de contêineres modernos no Debian GNU/Linux 13 (Trixie). Compreenda o isolamento em nível de kernel com namespaces e cgroups v2, instale e configure o Docker Engine oficial, automatize pilhas multicontêiner com Docker Compose v2, construa clusters de alta disponibilidade nativos com Docker Swarm, opere contêineres seguros sem privilégios de root (rootless) com Podman e orquestre microsserviços com a distribuição leve certificada de Kubernetes (k3s).

Ecossistema de Containers e Isolamento em Kernel

Diferente das máquinas virtuais tradicionais — que emulam placas-mãe, controladoras e executam um kernel próprio —, um contêiner no Linux não é uma máquina virtual. Trata-se de um conjunto de processos convencionais em espaço de usuário que compartilham o mesmo kernel do hospedeiro, mas que são rigorosamente isolados e delimitados por quatro primitivas fundamentais do kernel Linux:

1. Linux Namespaces

Isolam a visão do sistema para cada processo: pid (processos), net (rede/portas), mnt (pontos de montagem), ipc (mensageria), uts (hostname) e user (mapeamento de UID/GID).

2. Control Groups v2

Hierarquia unificada nativa no Debian 13 que audita e limita cotas máximas de CPU, memória RAM, I/O de disco e impede ataques de negação de serviço por esgotamento de processos (fork bombs via pids.max).

3. Armazenamento Overlay2

Sistema de arquivos de união (OverlayFS) que sobrepõe camadas imutáveis de imagem somente leitura (lowerdir) com uma camada superior efêmera de escrita (upperdir), otimizando I/O e economizando espaço.

4. Defesa em Profundidade

Políticas de Controle de Acesso Obrigatório com AppArmor (padrão ativo no Debian), filtros de chamadas de sistema com seccomp e eliminação seletiva de capacidades de superusuário (Linux Capabilities).

Matriz Comparativa das Ferramentas de Contêineres
Ferramenta Arquitetura Modelo de Privilégios Escopo de Execução Gerenciador / Runtime Melhor Caso de Uso
Docker Engine (CE) Cliente-Servidor (Daemon) Root / Grupo Docker Host Único (Standalone) dockerd + containerd / runc Desenvolvimento ágil, servidores de aplicação convencionais e pipelines de CI/CD.
Docker Compose v2 Plugin CLI Declarativo Herda do Docker Engine Host Único (Multicontêiner) Arquivo docker-compose.yml Pilhas completas locais (App + Banco + Cache + Proxy) com redes e volumes privados.
Docker Swarm Orquestrador Nativo embutido Nós Managers e Workers Cluster Multi-Host Algoritmo Raft + VXLAN Overlay Clusters leves de alta disponibilidade com balanceamento automático e baixa complexidade.
Podman Daemonless (Sem Daemon) Rootless por Padrão Host Único / Pods Locais crun / conmon + Systemd Ambientes com requisitos rígidos de conformidade, segurança multiusuário e execução via systemd.
Kubernetes (k3s) Plataforma de Orquestração Control Plane + Agentes Cluster Multi-Host Escalável Binário Único CNCF + Flannel / Traefik Microsserviços em escala, ambientes de borda (Edge), laboratórios de computação em nuvem.
Índice dos Tutoriais de Containers

Navegue diretamente para cada um dos tutoriais práticos deste módulo técnico:

1 Instalação Oficial do Docker Engine (CE)
Docker CE Docker Community Edition 27+ Repositório Upstream • cgroups v2 • containerd • daemon.json
Fundamentação Teórica

O Docker Engine é a plataforma de contêineres mais disseminada na indústria de software. Ele opera sob o modelo cliente-servidor:

  • Cliente CLI (docker): Binário de terminal utilizado pelos operadores para emitir comandos e instruções via chamadas de API REST.
  • Daemon do Servidor (dockerd): Serviço de sistema permanente que gerencia objetos do Docker (imagens, contêineres, redes e volumes).
  • Runtime de Execução (containerd & runc): O daemon transfere a execução direta dos contêineres para o containerd, que invoca o runtime compatível com OCI runc para configurar os namespaces e cgroups diretamente no kernel.

Por que utilizar o Repositório Upstream Oficial em vez do pacote docker.io do Debian?
O pacote empacotado pelo projeto Debian (docker.io) costuma ter versões congeladas e defasadas, sem os plugins modernos como docker-compose-plugin e docker-buildx-plugin. O repositório oficial da Docker Inc. fornece as versões estáveis mais recentes com correções críticas de segurança e compatibilidade total com cgroups v2 nativo do Debian 13.

Segurança do Socket Unix (/var/run/docker.sock):
Conceder acesso a esse socket (seja diretamente ou incluindo um usuário no grupo de sistema docker) é equivalente a conceder privilégios de superusuário root sem senha, pois um usuário pode montar a raiz do sistema de arquivos físico (/) dentro de um contêiner privilegiado. Em ambientes de produção de alta conformidade, restrinja o acesso ou adote soluções sem privilégios como o Podman Rootless.

Roteiro Prático: Instalação Oficial e Configuração Otimizada
terminal — Debian 13
# 1. Remover pacotes legados e conflitantes não oficiais
for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do sudo apt-get remove -y $pkg; done

# 2. Instalar certificados CA e ferramentas de transporte HTTPS
sudo apt update && sudo apt install -y ca-certificates curl gnupg

# 3. Adicionar a chave GPG pública oficial da Docker Inc. no formato moderno de chaveiro
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# 4. Adicionar o repositório estável oficial do Docker Engine
echo   "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian   bookworm stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
# Nota: Na fase de transição do Trixie, a base bookworm garante pacotes upstream com estabilidade

# 5. Instalar o Docker Engine, containerd e os plugins oficiais (Compose v2 e Buildx)
sudo apt update && sudo apt install -y   docker-ce   docker-ce-cli   containerd.io   docker-buildx-plugin   docker-compose-plugin

# 6. Criar o arquivo de configuração de produção (/etc/docker/daemon.json)
# Configura rotação defensiva de logs e mantém containers vivos no restart do daemon
sudo tee /etc/docker/daemon.json << 'END_DAEMON'
{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "20m",
    "max-file": "3"
  },
  "live-restore": true,
  "userland-proxy": false,
  "default-ulimits": {
    "nofile": {
      "Name": "nofile",
      "Hard": 64000,
      "Soft": 64000
    }
  }
}
END_DAEMON

# 7. Reiniciar o serviço Docker e habilitar inicialização no boot
sudo systemctl restart docker
sudo systemctl enable docker

# 8. Permitir execução sem sudo adicionando seu usuário ao grupo 'docker'
sudo usermod -aG docker $USER
newgrp docker

# 9. Executar container de teste com limites explícitos de memória e CPU
docker run -d --name web-teste   --memory="256m"   --cpus="1.0"   --restart=unless-stopped   -p 8080:80   nginx:alpine
Validação e Verificação
validação — docker info e containers
# Confirmar a versão do Engine e plugins instalados
docker version

# Validar se o storage driver é 'overlay2' e o driver de cgroup é 'systemd'
docker info | grep -E '(Storage Driver|Cgroup Driver|Cgroup Version)'

# Inspecionar consumo de recursos do container em tempo real
docker stats --no-stream web-teste

# Testar requisição HTTP na porta publicada
curl -I http://localhost:8080
2 Orquestração Multi-container com Docker Compose
Compose v2 Compose Specification Infraestrutura como Código • Redes Isoladas • Healthchecks
Fundamentação Teórica

O Docker Compose v2 é a ferramenta declarativa de Infrastructure as Code (IaC) para definição e orquestração de aplicações multicontêiner. Ele substitui totalmente o legado em Python (docker-compose v1) por um binário moderno compilado em Go, integrado diretamente à CLI oficial como docker compose.

Vantagens Operacionais do Compose v2:

  • Isolamento Automático de Rede (Service Discovery): Ao subir uma pilha declarada em um arquivo docker-compose.yml, o Compose provisiona uma rede bridge virtual privada exclusiva para o projeto. Os contêineres comunicam-se entre si resolvendo nomes de serviço diretamente pelo DNS interno do Docker (ex: uma aplicação conecta ao banco via db:3306 em vez de endereços IP voláteis).
  • Gestão de Dependências e Healthchecks: Através da combinação de depends_on com condições service_healthy, o Compose garante que serviços de aplicação dependentes (como APIs web) só recebam sinal de inicialização após os serviços de backend (como MariaDB ou Redis) estarem completamente aptos a responder requisições de rede.
  • Persistência Segura com Volumes Nomeados: Permite desvincular o ciclo de vida dos dados do ciclo de vida dos contêineres. Ao destruir ou recriar instâncias, os dados do banco de dados permanecem íntegros nos volumes corporativos gerenciados.
Roteiro Prático: Implantação de Pilha Web Completa (Nginx + PHP + MariaDB + Redis)
terminal — Debian 13
# 1. Criar o diretório do projeto corporativo
mkdir -p ~/pilha-web && cd ~/pilha-web

# 2. Criar o arquivo de variáveis de ambiente (.env) com permissões restritas
cat << 'END_ENV' > .env
DB_DATABASE=app_producao
DB_USER=usuario_app
DB_PASSWORD=SenhaForteDB_2026!
DB_ROOT_PASSWORD=SuperRootPassword_2026!
END_ENV
chmod 600 .env

# 3. Criar a especificação declarativa do docker-compose.yml
cat << 'END_COMPOSE' > docker-compose.yml
services:
  # Servidor Web Front-end (Nginx)
  web:
    image: nginx:alpine
    container_name: web_proxy
    restart: unless-stopped
    ports:
      - "80:80"
    volumes:
      - ./app:/var/www/html:ro
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - rede_interna

  # Banco de Dados Relacional (MariaDB)
  db:
    image: mariadb:11.4
    container_name: db_dados
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: ${DB_DATABASE}
      MYSQL_USER: ${DB_USER}
      MYSQL_PASSWORD: ${DB_PASSWORD}
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
    volumes:
      - dados_mysql:/var/lib/mysql
    networks:
      - rede_interna
    healthcheck:
      test: ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 20s

  # Cache em Memória e Sessões (Redis)
  redis:
    image: redis:7-alpine
    container_name: cache_redis
    restart: unless-stopped
    command: redis-server --save 60 1 --loglevel warning
    volumes:
      - dados_redis:/data
    networks:
      - rede_interna

# Definição de Volumes Persistentes Nomeados
volumes:
  dados_mysql:
    driver: local
  dados_redis:
    driver: local

# Definição da Rede Privada Isolada do Projeto
networks:
  rede_interna:
    driver: bridge
END_COMPOSE

# 4. Criar pasta da aplicação com página de teste
mkdir -p app
echo "<h1>morais.eti.br • Pilha Docker Compose Operacional no Debian 13</h1>" > app/index.html

# 5. Inicializar e construir toda a pilha em segundo plano
docker compose up -d

# 6. OPERAÇÕES DO DIA A DIA COM DOCKER COMPOSE:
# Acompanhar logs de todos os serviços de forma combinada
docker compose logs -f --tail=20

# Executar comandos administrativos diretamente no banco de dados
docker compose exec db mariadb -u root -p${DB_ROOT_PASSWORD} -e "SHOW DATABASES;"

# Parar e remover a pilha mantendo os volumes persistentes preservados
docker compose down
Validação e Verificação
validação — compose ps e volumes
# Listar status e checagem de saúde (healthy) de todos os contêineres
docker compose ps

# Validar existência dos volumes persistentes
docker volume ls | grep pilha-web

# Validar requisição direta no proxy web da pilha
curl -s http://localhost | grep "Debian 13"
3 Clusterização Nativa com Docker Swarm
Docker Swarm Orquestração em Cluster Consenso Raft • Redes Overlay VXLAN • Routing Mesh
Fundamentação Teórica

O Docker Swarm Mode é a solução de orquestração distribuída integrada diretamente ao Docker Engine. Para equipes que buscam balanceamento de carga, tolerância a falhas e escalabilidade horizontal sem a complexidade operacional do Kubernetes completo, o Swarm é a escolha ideal.

Arquitetura e Conceitos do Swarm:

  • Nós Managers: Responsáveis pelo gerenciamento de estado do cluster, agendamento de tarefas e orquestração. Mantêm a integridade através do algoritmo de consenso distribuído Raft (exige quórum de (N/2) + 1 managers ativos para tolerar falhas de nós).
  • Nós Workers: Servidores dedicados exclusivamente à execução das réplicas (chamadas de Tasks) despachadas pelos managers.
  • Redes Virtuais Overlay (VXLAN): Criam uma camada de rede encapsulada sobre a porta UDP 4789 com suporte opcional a criptografia IPsec automática (AES). Contêineres rodando em nós físicos geograficamente separados comunicam-se de forma transparente na mesma sub-rede virtual.
  • Ingress Routing Mesh (Malha de Roteamento): Cada nó do cluster escuta na porta publicada do serviço. Se uma requisição chegar a um nó que não possui o contêiner em execução, o kernel roteia o tráfego internamente via IPVS para um nó que possua uma réplica ativa, realizando balanceamento de carga transparente.
Roteiro Prático: Inicialização do Cluster, Criação de Serviço e Rolling Updates
terminal — Debian 13 (Nó Manager)
# 1. Inicializar o cluster Docker Swarm no nó principal
sudo docker swarm init --advertise-addr 192.168.56.10

# 2. Exibir o comando e token de ingresso para adicionar nós Workers ao cluster
sudo docker swarm join-token worker
# Saída gerada para ser executada nos demais nós Debian:
# docker swarm join --token SWMTKN-1-... 192.168.56.10:2377

# 3. Criar uma rede virtual Overlay criptografada para o cluster
sudo docker network create --driver overlay --opt encrypted rede_swarm_segura

# 4. Criar um Serviço Replicado de alta disponibilidade (3 réplicas do Nginx)
sudo docker service create   --name app_cluster   --replicas 3   --network rede_swarm_segura   --publish published=8088,target=80   --update-delay 10s   --update-parallelism 1   nginx:alpine

# 5. Escalonamento Elástico (Scale Out para 5 réplicas em segundos)
sudo docker service scale app_cluster=5

# 6. Atualização Gradual sem Queda de Serviço (Rolling Update)
# Atualiza as réplicas gradualmente, monitorando se a nova versão responde com sucesso
sudo docker service update --image nginx:1.27-alpine app_cluster
Validação e Verificação
validação — status do cluster
# Listar nós participantes do cluster Swarm e seus papéis
sudo docker node ls

# Listar serviços ativos e contagem de réplicas em execução
sudo docker service ls

# Verificar a distribuição geográfica das réplicas entre os nós do cluster
sudo docker service ps app_cluster

# Testar a Malha de Roteamento em qualquer nó
curl -I http://192.168.56.10:8088
4 Containers sem Daemon e sem Root com Podman
Podman Rootless por Padrão Arquitetura Daemonless • SubUIDs • Systemd Integration
Fundamentação Teórica

O Podman (Pod Manager) é uma ferramenta de contêineres de última geração compatível com as especificações da Open Container Initiative (OCI). Ele foi desenvolvido para resolver as principais restrições arquiteturais e vulnerabilidades do modelo clássico baseado em daemons:

  • Arquitetura Daemonless (Sem Ponto Único de Falha): O Docker depende do daemon dockerd executando constantemente como root. Se esse daemon falhar, todos os contêineres do host podem ser afetados. O Podman não possui daemon central; cada contêiner é gerado como um processo filho direto através de um monitor leve em C (conmon) e do runtime crun, consumindo recursos apenas enquanto está ativo.
  • Execução Rootless Nativa: O Podman permite que usuários sem privilégios criem, baixem e executem contêineres sem necessidade de sudo. Utiliza o recurso de User Namespaces do kernel e os arquivos /etc/subuid e /etc/subgid para mapear um intervalo de 65.536 IDs de usuários não privilegiados no host para UIDs virtuais dentro do contêiner. Se um processo sofrer invasão e escapar do contêiner, ele se encontrará no host como um usuário sem privilégios, sem qualquer capacidade de alterar o sistema operacional.
  • Conceito de Pods Nativos: O Podman implementa nativamente o conceito de Pod (o mesmo do Kubernetes). Um Pod agrupa múltiplos contêineres que compartilham a mesma pilha de rede (endereço IP e portas) e diretórios de armazenamento, simplificando a transição para ambientes Kubernetes.
Roteiro Prático: Instalação, Execução Rootless e Serviços do Systemd
terminal — Debian 13
# 1. Instalar o Podman, runtime crun e utilitários de rede de usuário
sudo apt update && sudo apt install -y podman crun slirp4netns uidmap

# 2. Verificar se o mapeamento de subuids e subgids está configurado para o seu usuário
grep $USER /etc/subuid /etc/subgid
# Caso não conste, adicione com: sudo usermod --add-subuids 100000-165535 --add-subgids 100000-165535 $USER

# 3. Habilitar a persistência de processos para o usuário após logout (Linger)
sudo loginctl enable-linger $USER

# 4. Executar um contêiner Nginx de forma 100% ROOTLESS (como usuário comum!)
podman run -d --name web-rootless -p 8085:80 docker.io/library/nginx:alpine

# 5. Criar um POD nativo (agrupando dois contêineres na mesma rede)
podman pod create --name pod-servicos -p 9000:80
podman run -d --pod pod-servicos --name app-frontend docker.io/library/nginx:alpine

# 6. INTEGRAR CONTÊINERES AO SYSTEMD DO USUÁRIO:
# Gerar arquivos de unidade systemd para inicialização automática no boot do sistema
mkdir -p ~/.config/systemd/user
cd ~/.config/systemd/user
podman generate systemd --new --files --name web-rootless

# Recarregar o daemon do systemd de usuário e habilitar o serviço
systemctl --user daemon-reload
systemctl --user enable --now container-web-rootless.service
Validação e Verificação
validação — podman e isolamento
# Listar contêineres e verificar que executam sob a conta do usuário comum
podman ps

# Inspecionar os pods ativos e portas vinculadas
podman pod ps

# Provar o isolamento: inspecionar o processo no sistema operacional
# Note que o processo crun roda com o seu UID regular (ex: 1000) e NÃO como root!
ps -ef | grep crun

# Validar o serviço gerenciado pelo systemd do usuário
systemctl --user status container-web-rootless.service --no-pager
5 Cluster Leve Kubernetes com k3s
Kubernetes k3s Certificado CNCF Consumo < 512 MB • Flannel • Traefik • kubectl
Fundamentação Teórica

O k3s é uma distribuição Kubernetes oficial certificada pela Cloud Native Computing Foundation (CNCF), desenvolvida pela Rancher/SUSE e amplamente adotada pela comunidade Linux para ambientes corporativos de borda (Edge), IoT, desenvolvimento e servidores de produção de pequeno e médio porte.

Diferenciais Arquiteturais do k3s em relação ao Kubernetes Clássico:

  • Binário Único Compacto: O Kubernetes tradicional (k8s padrão com kubeadm) consome gigabytes de RAM e opera dezenas de processos desacoplados. O k3s reúne o Control Plane (API Server, Controller Manager, Scheduler) e o Agent (Kubelet, Kube-Proxy) em um único executável estático com consumo inferior a 512 MB de memória RAM.
  • Banco de Dados Embutido: Substitui a exigência do pesado cluster etcd por um mecanismo de armazenamento SQLite embutido para nós únicos, com suporte nativo a bancos relacionais externos (PostgreSQL/MariaDB) ou etcd para clusters de alta disponibilidade (HA).
  • Baterias Inclusas: O k3s já vem pré-configurado com os componentes fundamentais de rede e roteamento: runtime containerd, plugin CNI de rede em malha Flannel, balanceador de carga de serviços Klipper-LB, Ingress Controller Traefik e provisionador de armazenamento local (Local Path Provisioner).
Roteiro Prático: Instalação do k3s e Deploy de Aplicação Declarativa
terminal — Debian 13
# 1. Instalar o k3s Server (Control Plane + Worker integrado) com kubeconfig legível
curl -sfL https://get.k3s.io | sh -s - --write-kubeconfig-mode 644

# 2. Configurar a variável KUBECONFIG e criar alias para o kubectl
mkdir -p ~/.kube
sudo cp /etc/rancher/k3s/k3s.yaml ~/.kube/config
sudo chown $USER:$USER ~/.kube/config
echo "export KUBECONFIG=~/.kube/config" >> ~/.bashrc
echo "alias k=kubectl" >> ~/.bashrc
export KUBECONFIG=~/.kube/config

# 3. Consultar o token de registro para adicionar nós workers adicionais futuramente
sudo cat /var/lib/rancher/k3s/server/node-token
# Em nós workers adicionais, bastaria executar:
# curl -sfL https://get.k3s.io | K3S_URL=https://192.168.56.10:6443 K3S_TOKEN="" sh -

# 4. Criar um manifesto declarativo (app-k8s.yaml) com Deployment de 3 réplicas e Service NodePort
cat << 'END_K8S' > app-k8s.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: portal-web
spec:
  replicas: 3
  selector:
    matchLabels:
      app: portal-web
  template:
    metadata:
      labels:
        app: portal-web
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        ports:
        - containerPort: 80
        resources:
          limits:
            memory: "128Mi"
            cpu: "250m"
          requests:
            memory: "64Mi"
            cpu: "100m"
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  type: NodePort
  selector:
    app: portal-web
  ports:
    - port: 80
      targetPort: 80
      nodePort: 30080
END_K8S

# 5. Aplicar o manifesto no cluster Kubernetes
kubectl apply -f app-k8s.yaml

# 6. OPERAÇÕES ESSENCIAIS COM KUBECTL:
# Escalonar o deployment para 5 réplicas dinamicamente
kubectl scale deployment nginx-deployment --replicas=5

# Visualizar logs consolidados dos pods da aplicação
kubectl logs -l app=portal-web --tail=20
Validação e Verificação
validação — nós, pods e serviços
# Verificar o status dos nós do cluster (Ready)
kubectl get nodes -o wide

# Verificar todos os pods em execução e seus endereços IPs internos
kubectl get pods -o wide

# Inspecionar os detalhes do serviço NodePort
kubectl get services nginx-service

# Testar a requisição na porta 30080 publicada pelo NodePort
curl -I http://localhost:30080
Módulo Anterior: Virtualização Próximo Módulo: Serviço de Diretório

Privacidade e preferências

Responsável: Nathaniel Simch de Morais. Contato: nathaniel@morais.eti.br.

Preferência essencial: guardamos neste navegador a sua escolha por até 180 dias, para respeitá-la nas páginas deste mesmo endereço. Esse registro não é enviado ao Google.

Estatísticas opcionais: após sua aceitação, o Google Analytics 4 recebe informações de navegação, como páginas visitadas, origem do acesso, interações e informações técnicas do navegador e dispositivo, para produzir relatórios de uso. Utiliza identificadores em cookies, como _ga. Nesta integração, os cookies de análise têm duração configurada de até 180 dias, renovável com o uso autorizado.

A tag de análise não é carregada antes da aceitação nem quando você recusa. As opções de publicidade e personalização de anúncios desta integração permanecem desativadas.

Você pode retirar sua autorização aqui a qualquer momento. A retirada interrompe novas coletas neste navegador e remove os cookies de análise acessíveis a este site; não apaga automaticamente dados já enviados. Para solicitações sobre seus dados, utilize o contato acima.

O Google pode processar dados em servidores fora do seu país. Consulte a Política de Privacidade do Google. Recursos externos utilizados pelas páginas, como bibliotecas e fontes, e os registros técnicos da hospedagem são independentes desta preferência de Analytics.