Reduza o Peso das Imagens OCI sem Perder Funcionalidades – Guia Prático para Sysadmins Ubuntu

Introdução
A recente iniciativa "Cut bloat, not features" anunciada pela equipe de desenvolvimento do Ubuntu traz uma abordagem inovadora para a criação de imagens OCI (Open Container Initiative) enxutas, mantendo a visibilidade de segurança necessária para ISVs e ambientes corporativos. Em um cenário onde o tamanho da imagem impacta diretamente o tempo de deploy, a largura de banda e a superfície de ataque, esta atualização permite que administradores de sistemas entreguem containers mais leves sem sacrificar a capacidade de detecção de vulnerabilidades críticas.

O que há de novo no Ubuntu?
- **Ferramentas de construção de imagens otimizadas**: o Ubuntu introduziu o "ubuntu-minimal-image" e aprimorou o Snapcraft para gerar camadas de base minimalistas.
- **Integração nativa com scanners de vulnerabilidade**: novos metadados OCI permitem que ferramentas como Trivy, Grype e Clair leiam informações de pacotes ausentes, reduzindo falsos positivos.
- **Suporte avançado a multi‑stage builds**: o buildkit do Docker e o LXD agora reconhecem diretivas específicas para descartar arquivos de desenvolvimento e documentação durante o estágio final.

Impacto prático para Sysadmins
A adoção dessas melhorias afeta diretamente servidores de produção, VPS, clouds públicas e privadas, bem como a segurança do kernel. A seguir, alguns casos de uso e comandos que facilitam a transição.

1. Construindo imagens mínimas com o ubuntu-minimal-image
```bash
# Instale o utilitário (disponível a partir do Ubuntu 24.04)
sudo apt update && sudo apt install ubuntu-minimal-image

# Crie uma imagem base mínima para Python 3.12
ubuntu-minimal-image \\
  --base ubuntu:24.04 \\
  --install "python3.12 python3-pip" \\
  --exclude "manpages-doc doc locales" \\
  --output python-minimal:3.12
```
O parâmetro `--exclude` remove pacotes de documentação e arquivos de localização que normalmente aumentam o tamanho da camada em até 30%.

2. Utilizando multi‑stage builds no Dockerfile
```Dockerfile
# Stage 1 – Build
FROM ubuntu:24.04 AS builder
RUN apt-get update && apt-get install -y build-essential cmake git
WORKDIR /src
COPY . .
RUN cmake . && make && make install DESTDIR=/install

# Stage 2 – Runtime (minimal)
FROM ubuntu-minimal:24.04
COPY --from=builder /install/usr/local/bin/app /usr/local/bin/app
ENTRYPOINT ["/usr/local/bin/app"]
```
Ao usar a imagem `ubuntu-minimal:24.04` no estágio final, eliminamos ferramentas de compilação, reduzindo a imagem final para menos de 80 MB.

3. Visibilidade de vulnerabilidades com metadados OCI
As novas imagens incluem um arquivo `sbom.json` (Software Bill of Materials) que descreve exatamente quais pacotes foram instalados. Para escanear com Trivy:
```bash
trivy image --sbom python-minimal:3.12
```
O scanner lê o SBOM e ignora pacotes ausentes, diminuindo o ruído de CVEs irrelevantes.

4. Segurança do Kernel e políticas AppArmor
Imagens menores reduzem a superfície de ataque, mas ainda é essencial aplicar perfis AppArmor restritos. Exemplo de perfil simplificado para um container de API:
```text
profile docker-default flags=(attach_disconnected,mediate_deleted) {
  # Permitir apenas leitura de /etc/passwd
  file,
    /etc/passwd r,
    /proc/** r,
    network inet stream,
    capability net_bind_service,
    deny /** wxl,
}
```
Carregue o perfil com:
```bash
sudo apparmor_parser -r -W /etc/apparmor.d/docker-api-profile
```

5. Deploy em ambientes Cloud (VPS, Kubernetes)
A redução de tamanho impacta diretamente o tempo de pull nas pipelines CI/CD. Em um cluster Kubernetes, ajuste o `imagePullPolicy` para `IfNotPresent` e defina `resources.limits` adequados, já que containers menores consomem menos memória.
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-prod
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: api
        image: registry.example.com/python-minimal:3.12
        imagePullPolicy: IfNotPresent
        resources:
          limits:
            cpu: "500m"
            memory: "256Mi"
```

Conclusão
A estratégia "Cut bloat, not features" oferece aos sysadmins Ubuntu uma caixa de ferramentas robusta para gerar imagens OCI significativamente menores, mantendo a rastreabilidade de vulnerabilidades e a compatibilidade com políticas de segurança como AppArmor. Ao integrar o `ubuntu-minimal-image`, aproveitar multi‑stage builds e utilizar SBOMs nos scanners, é possível reduzir custos de banda, acelerar deployments e melhorar a postura de segurança sem comprometer a estabilidade dos serviços em produção. Recomenda‑se testar as novas imagens em ambientes de staging antes de promover à produção, monitorando métricas de tempo de start‑up e taxa de false‑positive nos scanners, garantindo assim uma transição suave e confiável para a nova geração de containers Ubuntu.