Entendendo Containers: Linux, Docker e Kubernetes
O Que São Containers?
Containers são uma tecnologia de isolamento de recursos ao nível do sistema operacional que permite empacotar e executar aplicações de forma isolada, leve e portável. Diferentemente das máquinas virtuais tradicionais que virtualizam hardware completo, os containers compartilham o kernel do sistema operacional hospedeiro e utilizam mecanismos nativos do Linux para criar isolamento, tornando-os muito mais eficientes em termos de recursos.
A Base: Containers no Linux
Como Funcionam os Containers Linux
Os containers no Linux são construídos sobre tecnologias fundamentais do kernel:
1. Namespaces
Fornecem isolamento de recursos do sistema:
- PID Namespace: Isola a árvore de processos
- Network Namespace: Isola interfaces de rede
- Mount Namespace: Isola pontos de montagem do sistema de arquivos
- UTS Namespace: Isola hostname e domainname
- IPC Namespace: Isola comunicação entre processos
- User Namespace: Isola usuários e grupos
2. Control Groups (cgroups)
Limitam e controlam o uso de recursos:
- CPU
- Memória
- I/O de disco
- Rede
3. Union File Systems
Permitem camadas de sistema de arquivos sobrepostas, criando a ilusão de um único sistema de arquivos.
Exemplo Prático: Criando um Container “Manualmente”
1
2
3
4
5
6
# Criar um novo namespace PID e mount
sudo unshare --pid --mount --fork /bin/bash
# Dentro do novo namespace
mount -t proc proc /proc
ps aux # Mostra apenas os processos do namespace
Docker: Simplificando os Containers
O que é o Docker?
Docker é uma plataforma que simplifica drasticamente o uso de containers, fornecendo:
- Engine: Runtime para executar containers
- Images: Templates imutáveis para criar containers
- Dockerfile: Linguagem declarativa para criar imagens
- Registry: Repositório para compartilhar imagens
Principais Diferenças do Container Linux “Puro”
Aspecto | Container Linux | Docker |
---|---|---|
Complexidade | Alta (configuração manual) | Baixa (comandos simples) |
Portabilidade | Limitada | Alta (imagens padronizadas) |
Gerenciamento | Manual | Automático |
Networking | Configuração complexa | Redes virtuais automáticas |
Volumes | Mounts manuais | Gerenciamento de volumes |
Exemplo Prático com Docker
1
2
3
4
5
6
7
8
9
# Dockerfile
FROM alpine:latest
RUN apk add --no-cache nodejs npm
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]
1
2
3
# Construir e executar
docker build -t minha-app .
docker run -p 3000:3000 minha-app
Kubernetes: Orquestrando Containers em Escala
O que é o Kubernetes?
Kubernetes é um sistema de orquestração que gerencia containers em clusters, fornecendo:
- Scheduling: Distribuição automática de containers
- Service Discovery: Descoberta e balanceamento de carga
- Auto-scaling: Escalabilidade automática
- Self-healing: Recuperação automática de falhas
- Rolling Updates: Atualizações sem downtime
Principais Diferenças
Aspecto | Docker | Kubernetes |
---|---|---|
Escopo | Single host | Cluster multi-host |
Orquestração | Limitada (Docker Compose) | Completa |
Networking | Bridge/Host | CNI plugins |
Storage | Volumes locais | Persistent Volumes |
Load Balancing | Básico | Avançado (Services, Ingress) |
Exemplo: Deploy no Kubernetes
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: minha-app
spec:
replicas: 3
selector:
matchLabels:
app: minha-app
template:
metadata:
labels:
app: minha-app
spec:
containers:
- name: app
image: minha-app:latest
ports:
- containerPort: 3000
---
apiVersion: v1
kind: Service
metadata:
name: minha-app-service
spec:
selector:
app: minha-app
ports:
- port: 80
targetPort: 3000
type: LoadBalancer
1
2
3
kubectl apply -f deployment.yaml
kubectl get pods
kubectl get services
Conclusão
Containers revolucionaram o desenvolvimento e deploy de aplicações. Começando com tecnologias nativas do Linux, evoluindo para a simplicidade do Docker, até a orquestração do Kubernetes, cada ferramenta tem seu lugar no ecosistema de desenvolvimento.
A escolha entre elas depende das necessidades específicas do projeto: complexidade, escala, recursos disponíveis e expertise da equipe.