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).
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. |
Navegue diretamente para cada um dos tutoriais práticos deste módulo técnico:
Repositório oficial da Docker Inc., chaveiro GPG, containerd, cgroups v2 e ajuste fino do daemon.json.
Compose Spec v2, pilhas multicontêiner com Nginx, PHP e Banco de Dados, redes isoladas e healthchecks.
Consenso Raft, redes virtuais Overlay criptografadas, Routing Mesh, escalonamento e rolling updates.
Segurança Rootless com subuid/subgid, criação de Pods locais e geração de unidades de serviço do systemd.
Instalação certificada do k3s, nós master/worker, Deployments declarativos, Services NodePort e kubectl.
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 ocontainerd, que invoca o runtime compatível com OCIruncpara 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
# 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
# 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
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 viadb:3306em vez de endereços IP voláteis). - Gestão de Dependências e Healthchecks: Através da combinação de
depends_oncom condiçõesservice_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)
# 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
# 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"
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) + 1managers 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
# 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
# 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
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
dockerdexecutando 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 runtimecrun, 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/subuide/etc/subgidpara 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
# 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
# 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
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
etcdpor 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
# 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
# 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