Reduzindo o Bloat das Imagens OCI no Ubuntu: Guia Prático para Sysadmins

Introdução
A recente iniciativa da Canonical, descrita como "Cut bloat, not features", traz ao Ubuntu um conjunto de ferramentas e metadados que permitem a criação de imagens OCI (Open Container Initiative) significativamente menores, sem sacrificar funcionalidades críticas. Para equipes de DevOps e administradores de sistemas que entregam aplicações containerizadas a clientes corporativos, a redução do tamanho da imagem tem impacto direto na velocidade de deploy, consumo de banda e, principalmente, na clareza das análises de vulnerabilidade (CVE). Este artigo explora, de forma prática e detalhada, como aplicar as novidades nos ambientes de produção – VPS, nuvem pública ou privada – e quais são as implicações para a segurança do kernel e a gestão de containers Docker e LXD.

O que há de novo no Ubuntu?
A Canonical lançou, a partir da versão 24.04 LTS, um novo conjunto de pacotes "ubuntu-minimal-oci" e um meta‑pacote "ubuntu-oci-base" que substitui o tradicional "ubuntu:latest" nas builds Docker. As imagens base são construídas a partir de um rootfs enxuto, contendo apenas o kernel, bibliotecas essenciais (glibc, libssl) e o gerenciador de pacotes apt, removendo ferramentas de depuração, documentação e outros arquivos que inflavam o tamanho das imagens.

Além disso, o Ubuntu agora disponibiliza um "manifesto de segurança OCI" que lista, de forma verificável, todas as vulnerabilidades conhecidas incluídas na imagem, permitindo que scanners como Trivy, Grype ou Clair façam a correlação de forma 100 % transparente.

Impacto prático para Sysadmins
* **Velocidade de download** – Imagens que antes chegavam a 300 MB podem ser reduzidas para 80‑100 MB, diminuindo o tempo de pull em ambientes de CI/CD.
* **Economia de armazenamento** – Em clusters com milhares de nós, a economia pode ultrapassar 200 GB.
* **Redução de ruído de CVE** – Menos pacotes = menos falsos positivos, facilitando a priorização de patches críticos.
* **Compatibilidade garantida** – As imagens minimalistas mantêm o mesmo ABI das versões completas, evitando que aplicações que dependem de bibliotecas padrão quebrem.

Como reduzir o tamanho de imagens OCI
1. **Escolha a base correta**
   ```bash
   # Em vez de usar "ubuntu:22.04" use a imagem mínima
   FROM ubuntu-oci-base:24.04
   ```
2. **Utilize multi‑stage builds**
   ```Dockerfile
   # Etapa de compilação
   FROM ubuntu-oci-base:24.04 AS builder
   RUN apt-get update && apt-get install -y build-essential cmake
   WORKDIR /src
   COPY . .
   RUN cmake . && make

   # Etapa final enxuta
   FROM ubuntu-oci-base:24.04
   COPY --from=builder /src/myapp /usr/local/bin/myapp
   ENTRYPOINT ["/usr/local/bin/myapp"]
   ```
3. **Remova caches e arquivos temporários**
   ```Dockerfile
   RUN apt-get purge -y --auto-remove build-essential && \\
       apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
   ```
4. **Aproveite o recurso --squash** (Docker 23.0+)
   ```bash
   docker build --squash -t myapp:latest .
   ```
5. **Assine a imagem com o manifesto de segurança**
   ```bash
   cosign sign --key cosign.key myapp:latest
   ```

Segurança do Kernel e visibilidade de CVE
As imagens OCI mínimas mantêm o kernel do host (por padrão, o kernel do Ubuntu LTS) e não incluem módulos adicionais. Isso reduz a superfície de ataque dentro do container, pois não há drivers ou utilitários que possam ser explorados. O manifesto de segurança OCI inclui um hash SHA‑256 de cada pacote instalado, permitindo que ferramentas como Trivy comparem a lista de CVEs contra a base de dados NVD sem precisar analisar arquivos de configuração ausentes.

Para garantir que o kernel do host esteja alinhado com as recomendações de segurança, execute:
```bash
# Verifica se o kernel está na versão LTS suportada
uname -r
# Aplica patches críticos automaticamente
sudo unattended-upgrade --dry-run
```
Em ambientes LXD, a mesma imagem pode ser usada como "image" para containers LXC:
```bash
lxc launch ubuntu-oci-base:24.04 mycontainer
```
Isso traz a mesma economia de espaço e clareza de CVE para workloads que ainda utilizam LXD ao invés de Docker.

Passo a passo: construção de imagem mínima
1. **Instale o meta‑pacote** no seu build host
   ```bash
   sudo apt update && sudo apt install ubuntu-minimal-oci
   ```
2. **Crie o Dockerfile** (conforme exemplo acima) e salve como `Dockerfile.min`
3. **Execute o build**
   ```bash
   docker build -f Dockerfile.min -t empresa/app:min .
   ```
4. **Teste a imagem**
   ```bash
   docker run --rm -it empresa/app:min --version
   ```
5. **Escaneie a imagem**
   ```bash
   trivy image empresa/app:min
   ```
   O relatório deve apresentar significativamente menos vulnerabilidades de baixa/mediana gravidade.

Conclusão
A estratégia "Cut bloat, not features" da Canonical representa um avanço concreto para quem precisa equilibrar entrega rápida de software com rigor de segurança. Ao adotar as imagens OCI mínimas do Ubuntu, sysadmins ganham performance nas pipelines CI/CD, reduzem custos de armazenamento e, sobretudo, aumentam a confiabilidade das análises de vulnerabilidade. A compatibilidade total com o ecossistema Docker e LXD garante uma transição suave, permitindo que equipes de operações mantenham a estabilidade já conhecida nas versões LTS do Ubuntu, enquanto colhem os benefícios de um footprint de container mais enxuto e controlado.