OpenObserve no Ubuntu: servidor dedicado, S3, GCS, OCI e MinIO

Depois de conhecer o OpenObserve e sua plataforma unificada de logs, métricas e traces, o próximo passo é operá-lo em um servidor Ubuntu dedicado sem Docker. Este guia instala o binário oficial como serviço systemd, mantém a porta do OpenObserve no loopback, publica a interface por nginx com TLS e mostra quando usar disco local ou S3, Google Cloud Storage, Oracle Cloud Object Storage e MinIO.

Arquitetura e dimensionamento

O modo local é o padrão: usa SQLite para metadados e pode gravar dados de streams no disco ou em armazenamento compatível com S3. Para um bucket em nó único, defina ZO_LOCAL_MODE_STORAGE=s3. Não troque o backend de uma instância com dados sem plano de migração, backup e teste de restauração: apontar para um bucket não transporta automaticamente os Parquet existentes.

Esses perfis são pontos de partida, não promessa de capacidade. Meça a ingestão diária real, execute um piloto por ao menos uma semana e ajuste a retenção. Reserve espaço para WAL, compactação e cache: por padrão, o cache em disco pode usar até 50% do espaço livre. RAID 1 reduz o impacto da falha de um disco, mas não substitui backup contra exclusão, corrupção lógica ou credenciais comprometidas.

1. Preparar o Ubuntu e criar o usuário do serviço

Atualize o sistema e instale apenas os utilitários usados para baixar, validar e descompactar o arquivo. O processo do OpenObserve roda com uma conta de sistema sem login; o binário permanece sob controle do root e os dados ficam em /var/lib/openobserve.

sudo apt update
sudo apt install -y ca-certificates curl openssl tar

sudo adduser --system --group --home /var/lib/openobserve \
  --shell /usr/sbin/nologin openobserve
sudo install -d -o root -g root -m 0755 /usr/local/lib/openobserve
sudo install -d -o openobserve -g openobserve -m 0750 /var/lib/openobserve
sudo install -d -o root -g openobserve -m 0750 /etc/openobserve

Não use uma conta com shell administrativo para o serviço. A separação permite limitar quem lê as credenciais e quem escreve nos dados locais.

2. Baixar e instalar o binário oficial

Consulte primeiro a página oficial de downloads e troque OO_VERSION por uma release estável que você decidiu homologar. O exemplo usa v0.92.2, disponível no repositório oficial de downloads em 11 de setembro de 2026. Ele detecta amd64 ou arm64; para máquinas com glibc antiga, a documentação orienta usar o pacote linux-amd64-musl, com possível custo de desempenho.

export OO_VERSION=v0.92.2
case "$(dpkg --print-architecture)" in
  amd64|arm64) OO_ARCH="$(dpkg --print-architecture)" ;;
  *) echo "Arquitetura não suportada"; exit 1 ;;
esac

OO_TARBALL="openobserve-${OO_VERSION}-linux-${OO_ARCH}.tar.gz"
OO_URL="https://downloads.openobserve.ai/releases/openobserve/${OO_VERSION}/${OO_TARBALL}"

cd /tmp
curl -fL -o "$OO_TARBALL" "$OO_URL"
sha256sum "$OO_TARBALL"  # compare com o SHA-256 exibido na página Downloads

rm -rf /tmp/openobserve-install
mkdir /tmp/openobserve-install
tar -xzf "$OO_TARBALL" -C /tmp/openobserve-install
sudo install -o root -g root -m 0755 \
  /tmp/openobserve-install/openobserve \
  "/usr/local/lib/openobserve/openobserve-${OO_VERSION}"
sudo ln -sfn "/usr/local/lib/openobserve/openobserve-${OO_VERSION}" \
  /usr/local/bin/openobserve

/usr/local/bin/openobserve --version

O checksum é uma etapa obrigatória antes de executar um binário baixado. Guarde a versão instalada: atualizações devem baixar uma nova release, validar o hash, instalar outro arquivo e só então trocar o link simbólico durante uma janela de manutenção.

3. Criar o arquivo de ambiente

O OpenObserve é configurado por variáveis de ambiente. Crie um arquivo que só root e o grupo do serviço possam ler. A senha raiz é usada na primeira inicialização; gere uma senha longa, salve-a em um cofre e substitua os valores de exemplo antes de iniciar o serviço.

sudo tee /etc/openobserve/openobserve.env > /dev/null <<'EOF'
ZO_ROOT_USER_EMAIL=admin@example.com
ZO_ROOT_USER_PASSWORD=TROQUE_POR_UMA_SENHA_LONGA_E_ALEATORIA

# Nó único, dados no disco local
ZO_LOCAL_MODE=true
ZO_LOCAL_MODE_STORAGE=disk
ZO_DATA_DIR=/var/lib/openobserve

# O nginx será a única entrada pública
ZO_HTTP_ADDR=127.0.0.1
ZO_HTTP_PORT=5080
ZO_GRPC_ADDR=127.0.0.1
ZO_WEB_URL=https://o2.exemplo.com
ZO_CORS_ALLOWED_ORIGINS=https://o2.exemplo.com

# Ajuste a retenção ao piloto e ao espaço disponível
ZO_COMPACT_DATA_RETENTION_DAYS=30
EOF
sudo chown root:openobserve /etc/openobserve/openobserve.env
sudo chmod 0640 /etc/openobserve/openobserve.env

# Gere uma senha para copiar ao cofre; depois cole-a no arquivo acima.
openssl rand -base64 36

ZO_HTTP_ADDR=127.0.0.1 evita publicar a porta 5080 diretamente. Definimos também ZO_GRPC_ADDR=127.0.0.1 para que a porta gRPC padrão não fique aberta na rede. Se o OpenObserve for servido em um subcaminho, como https://exemplo.com/logs/, use ZO_BASE_URI=/logs e ajuste o proxy.

4. Rodar como serviço systemd

Crie a unidade. O limite de descritores segue a recomendação do guia oficial; Restart=on-failure faz o processo voltar após uma falha, sem transformar um erro de configuração em loop silencioso.

[Unit]
Description=OpenObserve
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=openobserve
Group=openobserve
WorkingDirectory=/var/lib/openobserve
EnvironmentFile=/etc/openobserve/openobserve.env
ExecStart=/usr/local/bin/openobserve
ExecStop=/bin/kill -s QUIT $MAINPID
Restart=on-failure
RestartSec=5
LimitNOFILE=65535
NoNewPrivileges=true
PrivateTmp=true
ProtectHome=true

[Install]
WantedBy=multi-user.target

sudo tee /etc/systemd/system/openobserve.service > /dev/null <<'EOF'
[Unit]
Description=OpenObserve
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=openobserve
Group=openobserve
WorkingDirectory=/var/lib/openobserve
EnvironmentFile=/etc/openobserve/openobserve.env
ExecStart=/usr/local/bin/openobserve
ExecStop=/bin/kill -s QUIT $MAINPID
Restart=on-failure
RestartSec=5
LimitNOFILE=65535
NoNewPrivileges=true
PrivateTmp=true
ProtectHome=true

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now openobserve
sudo systemctl status openobserve --no-pager
curl -fsS http://127.0.0.1:5080/healthz; echo
sudo journalctl -u openobserve -n 100 --no-pager

A resposta esperada do health check é {"status":"ok"}. Se o serviço não iniciar, confirme permissões em /var/lib/openobserve, a sintaxe do arquivo de ambiente e o log do journalctl. Não altere a senha raiz em uma instância já inicializada esperando recriar o usuário: essas variáveis são necessárias apenas no primeiro start.

5. Instalar nginx e publicar com TLS

Depois de validar o OpenObserve no loopback, publique-o com um nome DNS próprio, por exemplo o2.exemplo.com. Antes de pedir o certificado, crie os registros A (e AAAA, se usar IPv6) apontando para o servidor e confirme que as portas 80 e 443 chegam até ele. O OpenObserve continua em 127.0.0.1:5080; somente o nginx ficará exposto.

Instalar o proxy reverso

sudo apt update
sudo apt install -y nginx certbot python3-certbot-nginx
sudo systemctl enable --now nginx
sudo nginx -t
sudo systemctl status nginx --no-pager

Se o host usa UFW, preserve primeiro o acesso administrativo e libere somente HTTP/HTTPS. Em provedores de nuvem, faça a mesma liberação no firewall ou security group do provedor.

# Execute somente se UFW já faz parte da política deste host.
sudo ufw allow OpenSSH
sudo ufw allow 'Nginx Full'
sudo ufw status verbose

Crie primeiro um virtual host HTTP. Ele permite verificar o proxy e atender ao desafio HTTP-01 do Let’s Encrypt. Não publique a porta 5080 nem a 5081 no firewall.

sudo tee /etc/nginx/sites-available/openobserve >/dev/null <<'EOF'
server {
    listen 80;
    listen [::]:80;
    server_name o2.exemplo.com;

    location / {
        proxy_pass http://127.0.0.1:5080;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}
EOF

sudo ln -s /etc/nginx/sites-available/openobserve /etc/nginx/sites-enabled/openobserve
sudo rm -f /etc/nginx/sites-enabled/default
sudo nginx -t
sudo systemctl reload nginx
curl -fsSI http://o2.exemplo.com/

Use um subdomínio, como no exemplo. Se optar por publicar sob um caminho, como https://exemplo.com/logs/, siga a documentação do OpenObserve e defina ZO_BASE_URI=/logs; apenas acrescentar location /logs/ no nginx não é suficiente.

Emitir e renovar o certificado

Com o DNS propagado e a porta 80 acessível publicamente, o plugin nginx do Certbot pode obter o certificado e instalar o bloco HTTPS. Faça cópia da configuração antes de permitir que o Certbot a altere.

sudo cp -a /etc/nginx /etc/nginx.backup.$(date +%F)
sudo certbot --nginx --redirect -d o2.exemplo.com
sudo nginx -t
sudo systemctl reload nginx
sudo certbot renew --dry-run
curl -fsSI https://o2.exemplo.com/

O --redirect redireciona HTTP para HTTPS. O teste renew --dry-run confirma a renovação antes da data de expiração. Para certificados corporativos ou validação DNS-01, não rode o comando acima: instale o certificado conforme a política da organização e mantenha o mesmo proxy para 127.0.0.1:5080.

ss -lntp | grep -E ':(80|443|5080|5081)\b'

O resultado deve mostrar nginx em 80/443 e as portas 5080 e 5081 do OpenObserve apenas em loopback, nunca em 0.0.0.0. Não exponha a interface, APIs de ingestão ou o endpoint MCP em HTTP simples.

6. Usar S3, GCS, Oracle Cloud ou MinIO

Com object storage, SQLite e WAL continuam no disco local. Edite o mesmo arquivo /etc/openobserve/openobserve.env, mude ZO_LOCAL_MODE_STORAGE para s3, acrescente um bloco do provedor e reinicie o serviço. Crie o bucket antes, use um prefixo exclusivo por ambiente e teste escrita, leitura e retenção em ambiente de homologação.

AWS S3

Em EC2, prefira uma IAM Role com acesso mínimo ao bucket e ao prefixo em vez de credenciais estáticas. Para S3 padrão, não defina ZO_S3_SERVER_URL; o SDK busca a identidade da instância. Fora da AWS, injete as chaves por um gerenciador de segredos ou pelo arquivo de ambiente com permissão 0640; nunca as inclua em Git.

# Em EC2 com IAM Role: não defina AWS_ACCESS_KEY_ID nem AWS_SECRET_ACCESS_KEY
ZO_LOCAL_MODE_STORAGE=s3
ZO_S3_PROVIDER=s3
ZO_S3_REGION_NAME=us-east-1
ZO_S3_BUCKET_NAME=openobserve-producao
ZO_S3_BUCKET_PREFIX=openobserve/producao/

# Fora da AWS: entregue estes valores por cofre de segredos
AWS_ACCESS_KEY_ID=CHAVE_DE_ACESSO
AWS_SECRET_ACCESS_KEY=SEGREDO_DE_ACESSO
ZO_LOCAL_MODE_STORAGE=s3
ZO_S3_PROVIDER=s3
ZO_S3_REGION_NAME=us-east-1
ZO_S3_BUCKET_NAME=openobserve-producao
ZO_S3_BUCKET_PREFIX=openobserve/producao/

Google Cloud Storage

O GCS pode usar a API compatível com S3. Crie uma chave HMAC com acesso restrito ao bucket e use HTTP/1, exigido pela configuração documentada:

ZO_LOCAL_MODE_STORAGE=s3
ZO_S3_SERVER_URL=https://storage.googleapis.com
ZO_S3_REGION_NAME=auto
ZO_S3_ACCESS_KEY=CHAVE_HMAC_GCS
ZO_S3_SECRET_KEY=SEGREDO_HMAC_GCS
ZO_S3_BUCKET_NAME=openobserve-producao
ZO_S3_BUCKET_PREFIX=openobserve/producao/
ZO_S3_FEATURE_HTTP1_ONLY=true
ZO_S3_PROVIDER=s3

Também existe integração direta: use ZO_S3_PROVIDER=gcs e, quando não houver identidade da instância, forneça em ZO_S3_ACCESS_KEY o caminho para a chave JSON da conta de serviço, com permissão de leitura apenas para o usuário openobserve.

Oracle Cloud Object Storage

O Object Storage da Oracle oferece API S3-compatible. Use uma Customer Secret Key, mantenha a URL no formato da sua tenancy e região e valide a configuração em um bucket de teste antes de gravar dados de produção.

ZO_LOCAL_MODE_STORAGE=s3
ZO_S3_SERVER_URL=https://SEU_NAMESPACE.compat.objectstorage.SUA_REGIAO.oci.customer-oci.com
ZO_S3_REGION_NAME=SUA_REGIAO
ZO_S3_ACCESS_KEY=OCI_ACCESS_KEY
ZO_S3_SECRET_KEY=OCI_CUSTOMER_SECRET_KEY
ZO_S3_BUCKET_NAME=openobserve-producao
ZO_S3_BUCKET_PREFIX=openobserve/producao/
ZO_S3_PROVIDER=s3
ZO_S3_FEATURE_FORCE_HOSTED_STYLE=false

MinIO

MinIO é uma opção S3-compatible para datacenter, outra VM ou Kubernetes. Crie o bucket antes do start e use TLS entre o OpenObserve e o endpoint. Um MinIO no mesmo host não cria redundância: uma falha da máquina pode derrubar aplicação e dados ao mesmo tempo.

ZO_LOCAL_MODE_STORAGE=s3
ZO_S3_SERVER_URL=https://minio.exemplo.com
ZO_S3_REGION_NAME=us-east-1
ZO_S3_ACCESS_KEY=MINIO_ACCESS_KEY
ZO_S3_SECRET_KEY=MINIO_SECRET_KEY
ZO_S3_BUCKET_NAME=openobserve-producao
ZO_S3_BUCKET_PREFIX=openobserve/producao/
ZO_S3_PROVIDER=minio

sudoedit /etc/openobserve/openobserve.env
sudo systemctl restart openobserve
sudo journalctl -u openobserve -f

7. Integrar agentes de IA e aplicações LLM

Sim: o OpenObserve pode participar de um fluxo com LLM de duas formas. A primeira é observar a aplicação de IA via OpenTelemetry — tokens, latência, modelo, erros e chamadas de ferramentas viram traces e métricas. A segunda é conectar um cliente MCP para consultar logs, métricas e traces em linguagem natural.

O endpoint MCP segue o formato https://o2.exemplo.com/api/ID_DA_ORGANIZACAO/mcp. A documentação informa suporte em Open Source, Enterprise e Cloud. Em uma instância HTTPS, um teste com Claude Code pode seguir este padrão; gere o token somente na máquina do operador e não o registre em repositórios, chat ou arquivos compartilhados.

read -r -p "E-mail do usuário MCP: " O2_EMAIL
read -r -s -p "Senha do usuário MCP: " O2_PASSWORD; echo
O2_TOKEN=$(printf '%s' "$O2_EMAIL:$O2_PASSWORD" | base64 -w0)

claude mcp add --scope user openobserve \
  https://o2.exemplo.com/api/default/mcp \
  -t http \
  --header "Authorization: Basic $O2_TOKEN"

unset O2_PASSWORD O2_TOKEN
claude mcp list

Telemetria de IA pode conter prompts, respostas, identificadores e documentos recuperados. Defina antes quais atributos podem sair da aplicação, faça redaction quando necessário e alinhe retenção, LGPD e acesso. Não envie segredos ou chaves de API em logs ou spans.

Operação, backup e atualização

• Monitore o próprio serviço: CPU, RAM, I/O, espaço livre, erros de ingestão, tempo de consulta e crescimento do bucket.
• Proteja os metadados: em nó único, o SQLite local contém configurações, usuários, dashboards e alertas; faça backup consistente de /var/lib/openobserve e do arquivo de ambiente, mantendo segredos protegidos.
• Teste restauração: recuperar apenas Parquet no bucket não recria automaticamente usuários, dashboards ou regras.
• Atualize com rollback: instale uma nova versão lado a lado em /usr/local/lib/openobserve, valide o SHA-256, troque o link /usr/local/bin/openobserve e reinicie. Mantenha a versão anterior até homologar.
• Revise retenção: ZO_COMPACT_DATA_RETENTION_DAYS tem padrão de 3650 dias; defina uma política explícita e compatível com as regras de lifecycle do bucket.

Checklist final

• Binário oficial instalado e SHA-256 conferido antes da execução.
• Serviço openobserve ativo, com dados graváveis apenas pela conta dedicada.
• Portas 5080 e 5081 ligadas ao loopback; interface disponível somente em HTTPS pelo nginx.
• Senha raiz e credenciais de bucket armazenadas fora de Git, chat e backups sem criptografia.
• Retenção calculada com a ingestão real, não com uma taxa de compressão presumida.
• Teste de escrita/leitura no bucket e restauração de metadados concluídos antes da produção.

Fontes oficiais

• OpenObserve: downloads de binários
• OpenObserve: instalação self-hosted
• OpenObserve: serviço systemd
• OpenObserve: referência de variáveis de ambiente
• OpenObserve: storage local, S3, GCS e MinIO
• OpenObserve: nginx como proxy reverso
• Certbot: plugin nginx e renovação de certificados
• OpenObserve: servidor MCP
• OpenObserve: integrações de IA e LLM
• Oracle Cloud: API compatível com Amazon S3