Post

Entendendo Containers: Linux, Docker e Kubernetes

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”

AspectoContainer LinuxDocker
ComplexidadeAlta (configuração manual)Baixa (comandos simples)
PortabilidadeLimitadaAlta (imagens padronizadas)
GerenciamentoManualAutomático
NetworkingConfiguração complexaRedes virtuais automáticas
VolumesMounts manuaisGerenciamento 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

AspectoDockerKubernetes
EscopoSingle hostCluster multi-host
OrquestraçãoLimitada (Docker Compose)Completa
NetworkingBridge/HostCNI plugins
StorageVolumes locaisPersistent Volumes
Load BalancingBásicoAvanç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.

This post is licensed under CC BY 4.0 by the author.