Fedora Silverblue + Distrobox - Suzano Bitencourt

O Guia para um Setup de Desenvolvimento Imutável

O Fedora Silverblue mudou a forma como encaramos o sistema operacional: imutabilidade, segurança e reversão de atualizações (rollbacks) são pilares incríveis. No entanto, para desenvolvedores, instalar ferramentas como Git, Neovim, Hugo ou Jekyll diretamente na imagem base via rpm-ostree pode poluir o sistema e exigir reinicializações constantes.

A solução? Distrobox e sua interface gráfica, o BoxBuddy. Neste artigo, vamos aprender a criar, gerenciar, automatizar e até mover seus ambientes de desenvolvimento entre máquinas.

O que são Distrobox e BoxBuddy?

O Distrobox utiliza o Podman (ou Docker) para criar containers que se integram perfeitamente ao seu sistema host. Diferente de uma Máquina Virtual, o container compartilha seus arquivos da pasta /home e periféricos.

O BoxBuddy é a interface Flatpak que torna tudo isso visual. Ele permite criar distros com apenas alguns cliques, ideal para quem quer produtividade sem decorar centenas de flags de terminal.

Criando sua Primeira “Distro de Dev”

Via BoxBuddy (Interface Gráfica)

Abra o BoxBuddy.
Clique no ícone de “+” para criar um novo container.
Escolha a imagem (ex: Fedora, Debian ou Arch Linux).
Dê um nome organizado, como fedora-dev-utils.

Via Terminal

Se preferir o terminal, o comando equivalente seria:

# Criar um novo container
distrobox create --name fedora-dev-utils --image fedora:latest

# Acessar o ambiente
distrobox enter fedora-dev-utils

Instalando e Exportando Ferramentas

Uma vez dentro do container, você pode instalar o que quiser sem medo de quebrar o Silverblue. Vamos instalar as ferramentas essenciais:

# Atualiza os pacotes de software instalados no Linux (Fedora, RHEL, CentOS)
sudo dnf update

# Instalação dos programas 
sudo dnf install git neovim hugo jekyll

O pulo do gato

Para usar o Neovim ou o Hugo diretamente no terminal do Silverblue, você precisa exportá-los. Isso cria um pequeno script de ponte no seu host.

Execute DENTRO do container:

distrobox-export --bin /usr/bin/nvim --export-path ~/.local/bin
distrobox-export --bin /usr/bin/hugo --export-path ~/.local/bin

Dica de Expert:
Certifique-se de que a pasta ~/.local/bin está no seu PATH adicionando export PATH=”$HOME/.local/bin:$PATH” ao seu arquivo .bashrc.

Automatizando com Script

Se você tem muitas ferramentas, exportar uma por uma é cansativo. Podemos automatizar isso com um script simples dentro do container.

Crie o arquivo:

nano ~/exportar-tudo.sh

Cole o código abaixo:

#!/bin/bash
# Define que o interpretador a ser usado é o Bash.

# --- LISTAS DE EXPORTAÇÃO ---

# Lista de binários (programas de linha de comando).
# Exemplo: distrobox-export --bin /usr/bin/git
BINARIOS=(
"/usr/bin/git"
"/usr/bin/nvim"
"/usr/bin/hugo"
"/usr/bin/jekyll"
) # Fecha a lista de binários.

# Lista de aplicativos (geram ícones no menu do sistema).
# Exemplo: distrobox-export --app vlc
APLICATIVOS=(
) # Fecha a lista de aplicativos comerciais/GUI.

# Lista de serviços (daemons/systemd).
Exemplo: distrobox-export --service sshd
SERVICOS=(
) # Exemplo de lista vazia para testar a lógica do script.

# --- FUNÇÃO DE PROCESSAMENTO ---

# Criamos uma função para evitar repetir código para cada tipo de exportação.
exportar_tudo() {
    local TIPO=$1        # Primeiro argumento: o nome amigável (Binários, Aplicativos, etc).
    local FLAG=$2        # Segundo argumento: a flag do comando (--bin, --app, --service).
    shift 2              # Remove os dois primeiros argumentos para sobrar apenas a lista de itens.
    local ITENS=("$@")   # Armazena o restante dos argumentos como a lista de itens a processar.

    # Verifica se a quantidade de itens na lista é igual a zero.
    if [ ${#ITENS[@]} -eq 0 ]; then
        # Informa ao usuário que não há nada para processar nesta categoria.
        echo "--> [AVISO] A lista de $TIPO está vazia. Pulando..."
        # Retorna para continuar o script sem erro.
        return
    fi # Fim da verificação de lista vazia.

    # Exibe qual categoria está sendo processada no momento.
    echo "Iniciando exportação de $TIPO..."

    # Inicia o laço para percorrer cada item da lista recebida.
    for ITEM in "${ITENS[@]}"; do
        # O comando 'distrobox-export' faz a ponte entre o container e o host.
        # $FLAG define se é --bin, --app ou --service.
        distrobox-export "$FLAG" "$ITEM" --export-path ~/.local/bin
        
        # Exibe mensagem de confirmação para cada item processado.
        echo "[OK] $TIPO exportado: $ITEM"
    done # Fim do laço 'for'.
} # Fim da definição da função.

# --- EXECUÇÃO ---

# Chama a função para processar os Binários usando a flag --bin.
exportar_tudo "Binários" "--bin" "${BINARIOS[@]}"

# Chama a função para processar os Aplicativos usando a flag --app.
exportar_tudo "Aplicativos" "--app" "${APLICATIVOS[@]}"

# Chama a função para processar os Serviços usando a flag --service.
exportar_tudo "Serviços" "--service" "${SERVICOS[@]}"

# Exibe a mensagem final de conclusão do script.
echo "Processo concluído com sucesso!"

Dê permissão de execução:

chmod +x ~/exportar-tudo.sh/usr

Agora, sempre que configurar um novo container, basta rodar:

./exportar-tudo.sh.

Levando seu Container para outro PC

Configurou o ambiente perfeito no Desktop e quer levar para o Notebook? É fácil.

No Computador de Origem (Exportar)

Salve o container como uma imagem:

podman commit fedora-dev-utils meu-setup-custom

Exporte para um arquivo:

podman save meu-setup-custom -o meu-setup.tar

No Computador de Destino (Importar)

Transfira o arquivo .tar e carregue a imagem:

podman load -i meu-setup.tar

Recrie o container no Distrobox:

distrobox create --name fedora-dev-utils --image localhost/meu-setup-custom

Atenção:
Entre no container e rode o seu script exportar-tudo.sh para recriar os atalhos no novo sistema!

Dicas Extras de Performance

Mesclagem de Home: O Distrobox compartilha sua /home. Se você tem configurações de plugins do Neovim em ~/.config/nvim, elas funcionarão automaticamente em qualquer container que tenha o Neovim instalado.

Múltiplas Distros: Use um container Arch Linux via Distrobox para ter acesso ao AUR, enquanto mantém a estabilidade do Fedora Silverblue como base.

O uso de containers via Distrobox transforma o Fedora Silverblue em uma estação de trabalho indestrutível e altamente flexível.