Garage S3 Self-Hosted: Armazenamento Distribuído e Alta Disponibilidade

Introdução ao Garage: A Evolução do Object Storage Self-Hosted

No cenário atual de infraestrutura DevOps, a necessidade de armazenamento escalável, durável e compatível com o protocolo S3 é crítica. Embora soluções consolidadas como MinIO sejam amplamente utilizadas em ambientes VPS e nuvens privadas, elas exigem uma gestão complexa de componentes sidecar para garantir alta disponibilidade e replicação consistente em clusters distribuídos. É nesse contexto que o Garage surge como uma alternativa moderna e eficiente. Desenvolvido pela equipe do CRI (Centre de Ressources Informatiques) da Universidade de Grenoble, o Garage é um servidor de armazenamento de objetos S3 auto-hospedado, projetado especificamente para ser distribuído em pequenos clusters, muitas vezes compostos por dispositivos de baixo consumo energético ou hardware reciclado.

Diferente de soluções tradicionais que dependem de discos RAID caros ou sistemas de arquivos centralizados complexos, o Garage utiliza um protocolo proprietário de replicação baseado no algoritmo Raft, mas adaptado para ambientes onde a latência de rede pode variar e os nós podem estar geograficamente dispersos. O objetivo principal é oferecer uma infraestrutura DevOps robusta que garanta a durabilidade dos dados (garantia de 99,999999999% - "eleven nines") sem a necessidade de grandes investimentos em hardware empresarial. Este tutorial guiará você pela instalação e configuração de um cluster Garage de alta disponibilidade.

Pré-requisitos e Arquitetura do Cluster

Para construir uma nuvem privada verdadeiramente resiliente, não devemos depender de um único ponto de falha. A arquitetura recomendada para o Garage consiste em um número ímpar de nós (geralmente 3 ou 5) para permitir a tolerância a falhas por maioria (quorum). Cada nó deve possuir recursos computacionais modestos, mas armazenamento dedicado e confiável.

Antes de prosseguir com a instalação, certifique-se de que seus servidores atendam aos seguintes requisitos básicos:

• Sistema Operacional: Linux moderno (Ubuntu 22.04 LTS, Debian 12 ou Arch Linux são os mais testados).
• Recursos: Mínimo de 1 CPU e 1GB de RAM por nó. O Garage é otimizado para rodar em ARM64 (Raspberry Pi) e x86_64.
• Armazenamento: Discos SSD ou HDD dedicados. Cada disco será formatado pelo Garage, portanto, não armazene dados críticos pré-existentes nele.
• Rede: Todos os nós devem conseguir se comunicar na porta TCP 4480 (comunicação interna do cluster) e, opcionalmente, expor a porta 4481 para acesso HTTP/S3 externo.

É fundamental que todos os nós tenham o mesmo horário sincronizado via NTP, pois o protocolo de consistência distribuída depende fortemente da precisão dos timestamps.

Instalação do Garage em Cada Nó

A instalação do Garage é simples e não exige dependências complexas. O binário único contém toda a lógica necessária. Vamos proceder com a instalação no primeiro nó, que atuará como nosso ponto de partida para a configuração inicial.

Acesse o terminal do seu servidor e execute os seguintes comandos para baixar a versão estável mais recente e torná-la executável:

# Baixar o binário do Garage (exemplo para Linux AMD64)
wget https://garagehq.deuxfleurs.fr/gh-release/garage/latest/garage_1.0.0_linux_amd64.tar.gz

# Extrair o arquivo
tar -xzf garage_1.0.0_linux_amd64.tar.gz

# Mover para o diretório de binários
sudo mv garage /usr/local/bin/

# Verificar a instalação
garage --version

Repita este processo exato em todos os demais nós do seu cluster. A consistência da versão é vital para evitar problemas de compatibilidade no protocolo Raft.

Inicialização e Join do Cluster

O Garage opera em um modo descentralizado, mas requer uma configuração inicial para definir a identidade do cluster e os endereços dos nós. Vamos criar o diretório de dados e iniciar o serviço no primeiro nó (Node 1).

Configuração do Nó 1

Crie o diretório onde os dados serão armazenados:

sudo mkdir -p /var/lib/garage/data
sudo chown -R $USER:$USER /var/lib/garage

Agora, inicie o Garage no primeiro nó. Este comando define o endereço do próprio nó e anuncia que este é o primeiro nó a entrar no cluster (flag --announce):

garage --data-dir /var/lib/garage/data \
  --listen 0.0.0.0:4480 \
  --admin-listen 0.0.0.0:4481 \
  --announce :4481 \
  --start-as-first-node

Após executar este comando, o terminal entrará em modo de execução contínua. Em outro terminal ou janela SSH, podemos verificar se o nó está saudável usando a CLI do Garage:

garage node list

Adicionando Nós ao Cluster (Join)

Agora, vamos adicionar os nós 2 e 3. Em cada um desses servidores, crie o diretório de dados e inicie o serviço, desta vez apontando para o endereço do Nó 1 para "juntar-se" ao cluster existente:

# No Node 2
sudo mkdir -p /var/lib/garage/data
garage --data-dir /var/lib/garage/data \
  --listen 0.0.0.0:4480 \
  --admin-listen 0.0.0.0:4481 \
  --announce :4481 \
  --join :4481

Repita para o Node 3:

# No Node 3
sudo mkdir -p /var/lib/garage/data
garage --data-dir /var/lib/garage/data \
  --listen 0.0.0.0:4480 \
  --admin-listen 0.0.0.0:4481 \
  --announce :4481 \
  --join :4481

Volte ao terminal do Node 1 e execute novamente garage node list. Você deverá ver os três nós listados como alive. O cluster está agora formado e a replicação de dados entre os discos dos três servidores foi estabelecida automaticamente.

Configuração de Buckets e Permissões S3

Com o cluster rodando, precisamos criar um bucket (balde) para armazenar nossos objetos. O Garage utiliza uma abordagem simplificada para gerenciamento de permissões, utilizando chaves de acesso globais ou scoped.

No terminal do Node 1, crie um bucket chamado meu-backup:

garage bucket create meu-backup

Para acessar este bucket via ferramentas compatíveis com S3 (como aws-cli, rclone ou aplicações web), precisamos de uma chave de acesso. O Garage gera chaves que podem ser vinculadas a buckets específicos.

# Criar chave de acesso com permissão total no bucket meu-backup
garage access-key create --bucket meu-backup --read-write

O comando retornará uma Access Key ID e uma Secret Access Key. Guarde-os com segurança. Estes são os credenciais que suas aplicações utilizarão para enviar e recuperar dados.

Integração com Clientes S3 (MinIO Compatible)

Uma das maiores vantagens do Garage é sua compatibilidade com o ecossistema S3. Isso significa que você pode usar qualquer ferramenta que suporte o protocolo AWS S3, incluindo ferramentas de backup como Duplicati, Kopia, ou até mesmo servidores web como Caddy para servir arquivos diretamente.

Testando com AWS CLI

Instale a AWS CLI em sua máquina local e configure o endpoint para apontar para seu servidor Garage. Como o Garage não utiliza SSL padrão na instalação básica (para simplicidade inicial), configuraremos o s3api para usar HTTP:

aws configure set default.s3.addressing_style path
aws configure set default.region us-east-1

# Configurar endpoint personalizado
export AWS_ACCESS_KEY_ID='SUA_CHAVE_AQUI'
export AWS_SECRET_ACCESS_KEY='SEU_SEGREDO_AQUI'
export AWS_DEFAULT_REGION='us-east-1'

Agora, teste o upload de um arquivo:

aws s3 cp ./documento.pdf s3://meu-backup/documento.pdf --endpoint-url http://:4481

Se o comando retornar sucesso, seus dados estão sendo replicados entre os três nós. Você pode verificar a integridade dos dados simulando uma falha: desligue o Nó 1 e tente baixar o arquivo através do Nó 2 ou 3. O Garage manterá a disponibilidade.

Gerenciamento com Systemd para Alta Disponibilidade

Para produção, nunca execute o Garage manualmente no terminal. Utilize systemd para garantir que o serviço reinicie automaticamente em caso de falhas ou reboot do servidor.

Crie um arquivo de unidade systemd (/etc/systemd/system/garage.service) com o seguinte conteúdo:

[Unit]
Description=Garage Object Storage Server
After=network.target

[Service]
Type=simple
User=root
ExecStart=/usr/local/bin/garage \
  --data-dir /var/lib/garage/data \
  --listen 0.0.0.0:4480 \
  --admin-listen 0.0.0.0:4481 \
  --announce :4481 \
  --join :4481

Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

Nota: No primeiro nó, substitua a flag --join por --start-as-first-node. Nos demais nós, mantenha o --join.

Ative e inicie o serviço:

sudo systemctl daemon-reload
sudo systemctl enable garage
sudo systemctl start garage
sudo systemctl status garage

Otimizações de Segurança e SSL/TLS

Embora o Garage funcione bem com HTTP interno, a exposição direta via Internet requer criptografia. O Garage suporta TLS nativo através de certificados Let's Encrypt ou certificados próprios.

A maneira mais segura de expor o Garage para a internet é através de um proxy reverso como Caddy ou Nginx. Exemplo de configuração básica no Caddyfile:

garage.seudominio.com {
    reverse_proxy localhost:4481
}

# Ou para a porta de dados, se necessário expor diretamente
api.garage.seudominio.com {
    reverse_proxy localhost:4480
}

O Caddy cuidará automaticamente da renovação dos certificados SSL/TLS, garantindo que sua nuvem privada seja acessada via HTTPS seguro.

Considerações Finais sobre Infraestrutura DevOps

A adoção do Garage S3 self-hosted representa uma mudança de paradigma na gestão de armazenamento distribuído. Ao eliminar a dependência de componentes externos complexos e focar em um binário único e eficiente, ele reduz drasticamente a superfície de ataque e a carga operacional (OpEx) para equipes de infraestrutura DevOps.

Para ambientes que demandam backup self-hosted confiável, o Garage oferece uma durabilidade superior à maioria dos serviços de armazenamento em bloco tradicionais, pois seus dados são fragmentados e replicados geograficamente dentro do cluster. Ao migrar para essa arquitetura, você não apenas economiza custos com licenças de software proprietário, mas também ganha controle total sobre a localização e a integridade de seus ativos digitais.

Lembre-se de monitorar o status do cluster regularmente usando garage node list e garage bucket list. A transparência operacional é a chave para manter uma nuvem privada saudável. Com esta configuração, você possui uma base sólida para escalar seu armazenamento conforme sua aplicação cresce, mantendo a agilidade e a resiliência que o ecossistema cloud moderno exige.