Reduza o Inchaço, Não os Recursos: Imagens OCI Mínimas para Entrega de Software Segura no Ubuntu

Introdução
A entrega de aplicações containerizadas em ambientes corporativos tem sido historicamente um jogo de concessões: imagens menores reduzem o tempo de download e o consumo de armazenamento, mas podem sacrificar a visibilidade de segurança, gerando ruído de CVEs ou, pior, deixando vulnerabilidades críticas invisíveis aos scanners.  O Ubuntu, líder em distribuições Linux para servidores, acaba de anunciar uma iniciativa que promete "cortar o inchaço, não os recursos" – a criação de imagens OCI (Open Container Initiative) minimalistas que mantêm a rastreabilidade de pacotes e a integração com as ferramentas de segurança da Canonical.  Neste artigo, analisaremos o impacto prático desta novidade para servidores de produção, segurança de kernel e administração de containers Docker/LXD.

O que há de novo no Ubuntu?
A Canonical introduziu o **ubuntu‑image‑minimizer**, um conjunto de scripts e metadados que permitem gerar imagens OCI a partir de uma base Ubuntu LTS (22.04 ou 24.04) com apenas os pacotes essenciais para a aplicação.  Diferente das abordagens tradicionais que utilizam *scratch* ou *alpine*, o novo fluxo preserva o **manifesto de pacotes apt** (incluindo as versões exatas) e inclui automaticamente os metadados de segurança do **Ubuntu Security Tracker**.  Isso significa que ferramentas como *Trivy*, *Grype* ou *Clair* podem correlacionar vulnerabilidades diretamente com os CVEs publicados pela Canonical, eliminando falsos positivos e lacunas de detecção.

Impacto prático para Sysadmins
* **VPS e Cloud** – Imagens que pesam menos de 80 MB (comparado a ~200 MB das imagens padrão) reduzem o tempo de provisionamento em até 60 %, especialmente relevante em ambientes de auto‑escalamento.  Menor tamanho também implica menor custo de armazenamento em block‑stores de nuvem.
* **Segurança do Kernel** – As imagens minimalistas ainda carregam o kernel LTS da Ubuntu, permitindo a ativação de recursos como *kernel.lockdown*, *AppArmor* e *Secure Boot* sem a necessidade de recompilar.  Isso garante que a superfície de ataque permaneça reduzida enquanto o kernel continua recebendo patches de segurança.
* **Containers Docker e LXD** – O fluxo de geração funciona tanto para *Dockerfile* quanto para *LXD image* via `lxc image import`.  Sysadmins podem padronizar uma única pipeline para ambos os runtimes, simplificando a gestão de políticas de compliance.

Como gerar e validar imagens OCI mínimas
```bash
# Instalar o minimizer (disponível no PPA oficial)
sudo add-apt-repository ppa:canonical/ubuntu-image-minimizer
sudo apt update && sudo apt install ubuntu-image-minimizer

# Criar um diretório de trabalho
mkdir -p ~/oci-minimal && cd ~/oci-minimal

# Definir o manifesto de pacotes (exemplo para uma app Python)
echo "python3-minimal python3-pip" > packages.txt

# Gerar a imagem OCI
ubuntu-image-minimizer build \\
    --release jammy \\
    --packages $(cat packages.txt) \\
    --output myapp-oci.tar.gz

# Inspecionar o tamanho da camada raiz
tar -tzf myapp-oci.tar.gz | wc -l
```
Após a construção, a imagem pode ser carregada no Docker ou no LXD:
```bash
# Docker
docker load < myapp-oci.tar.gz

docker run --rm myapp-oci:latest python3 -c "print('Hello')"

# LXD
lxc image import myapp-oci.tar.gz --alias myapp-oci
lxc launch myapp-oci mycontainer
```
Para validar a segurança, use um scanner integrado ao feed da Canonical:
```bash
trivy image myapp-oci:latest --scanners vuln,config --severity HIGH,CRITICAL
```
O relatório mostrará apenas vulnerabilidades realmente presentes nos pacotes instalados, sem o ruído típico de imagens baseadas em *alpine* que não possuem mapeamento de CVE.

Integração com Docker, LXD e scanners de vulnerabilidade
O minimizer exporta um **manifest.json** contendo o hash de cada pacote apt, a sua versão e o link para o CVE correspondente.  Ferramentas como *Cosign* podem assinar esse manifesto, garantindo a integridade da cadeia de suprimentos:
```bash
cosign sign-blob --key cosign.key myapp-oci.tar.gz > myapp-oci.sig
```
No pipeline CI/CD (GitLab, GitHub Actions, Jenkins), inclua etapas de assinatura e verificação antes de promover a imagem para produção.  Em ambientes LXD, o perfil de segurança pode ser atualizado automaticamente:
```bash
cat < /etc/lxc/default.profile
config:
  security.nesting: "true"
  security.privileged: "false"
  raw.lxc: "lxc.apparmor.profile=unconfined"
EOF
lxc profile edit default < /etc/lxc/default.profile
```

Boas práticas de hardening e atualização de kernel
1. **Habilite o Livepatch** – Reduza a necessidade de reboot ao aplicar patches críticos do kernel:
```bash
sudo ua enable livepatch
```
2. **Lockdown do kernel** – Ative o modo *lockdown* para impedir a modificação do kernel em tempo de execução:
```bash
sudo grubby --update-kernel=ALL --args="lockdown=confidentiality"
```
3. **AppArmor profiles** – Mantenha perfis atualizados para a aplicação containerizada.  Use `aa-genprof` para gerar perfis a partir de logs de acesso.
4. **Rotina de escaneamento** – Agende `trivy` ou `grype` diariamente via cron e envie relatórios para o SIEM.

Conclusão – estabilidade e futuro
A estratégia de gerar imagens OCI mínimas, porém completas em termos de metadados de segurança, traz um equilíbrio raro entre agilidade de entrega e governança corporativa.  Para sysadmins que gerenciam milhares de instâncias em VPS, Cloud ou data‑centers on‑premise, a redução de 50 % a 70 % no tamanho das imagens se traduz em menor latência de implantação, economia de banda e, sobretudo, em um panorama de vulnerabilidades mais limpo e confiável.  Como a Canonical continua a integrar o *Ubuntu Security Tracker* ao fluxo de construção, podemos esperar que futuras versões incluam otimizações automáticas de dependências e suporte nativo ao *SBOM* (Software Bill of Materials).  Enquanto isso, adotar o ubuntu‑image‑minimizer nas pipelines CI/CD já é uma prática recomendada para garantir que a estabilidade do kernel e a visibilidade de CVEs permaneçam intactas, mesmo em ambientes de contêineres altamente dinâmicos.