Adiciona scripts de instalação e rollout em massa do agente OpenObserve

This commit is contained in:
Leonardo Biasoli 2026-11-04 11:00:24 -03:00
commit 92c78b6135
3 changed files with 431 additions and 0 deletions

100
README.md Normal file
View file

@ -0,0 +1,100 @@
# install-openserve
Script para instalação e configuração automática do **agente OpenObserve** (OpenTelemetry Collector) em servidores Linux, VMs e containers LXC.
## Compatibilidade
- Qualquer distribuição Linux com `systemd` (Ubuntu, Debian, etc.)
- VMs e containers LXC do Proxmox
## Configuração padrão
| Item | Valor |
|-------------------------------|-------------------------------------------------------------------|
| Endpoint de ingestão | `https://openobserve.ledcloud.com.br/api/<org_id>/` |
| Organização | LED Cloud |
| Autenticação | Token de ingestão (Base64), gerado em **Dados > Fontes de dados > Gerenciar tokens** |
| Serviço instalado | `otel-collector` (binário `otelcol-contrib`) |
| Arquivo de configuração | `/etc/otel-config.yaml` |
| Identificação do host | `host.name` = hostname curto da máquina (detectado automaticamente) |
## Uso
Execute como **root** na máquina que vai enviar dados:
```bash
wget -O openobserve-install.sh https://git.ledcloud.com.br/LED_Cloud/install-openserve/raw/branch/main/openobserve-install.sh
chmod +x openobserve-install.sh
sudo ./openobserve-install.sh
```
Ou, se o repositório já estiver clonado localmente:
```bash
git clone https://git.ledcloud.com.br/LED_Cloud/install-openserve.git
cd install-openserve
chmod +x openobserve-install.sh
sudo ./openobserve-install.sh
```
O script pergunta interativamente pela **URL de ingestão** e pelo **token em Base64** (cole exatamente o valor mostrado na tela "Gerenciar tokens", sem editar). Para rodar sem prompts (automação, rollout em massa), use variáveis de ambiente:
```bash
sudo OO_URL="https://openobserve.ledcloud.com.br/api/<org_id>/" \
OO_AUTH_B64="<token_base64_copiado_da_tela>" \
./openobserve-install.sh
```
Variável opcional:
- `OO_HOSTNAME` — nome que vai aparecer em **Infra > Hosts**. Padrão: hostname curto da máquina (`hostname -s`).
## O que o script faz
1. Confere se está rodando como root.
2. Valida que o token colado em `OO_AUTH_B64` é Base64 válido (evita erros silenciosos de 401 por valor colado errado).
3. Se o coletor ainda não estiver instalado, baixa o instalador oficial do OpenObserve e instala o `otelcol-contrib` com a URL e o token informados.
4. Se já estiver instalado, só reconfigura: faz backup do `/etc/otel-config.yaml` antes de qualquer alteração.
5. Grava o header `Authorization: Basic <token>` em **todos** os exporters do arquivo de configuração, usando o valor exatamente como foi colado (sem recodificar).
6. Fixa `host.name` no processor `resource/hostname`, garantindo que o host apareça com o nome correto em **Infra > Hosts**, mesmo em containers LXC onde as métricas de recurso podem se confundir com as do nó físico.
7. Valida a configuração (`otelcol-contrib validate`) antes de reiniciar o serviço — se a validação falhar, nada é reiniciado.
8. Reinicia e habilita o serviço `otel-collector`.
9. Aguarda alguns segundos e verifica nos logs se não há mais erros `401` (autenticação), avisando se algo ainda estiver incorreto.
## Observações
- O script precisa ser executado como root (`sudo`).
- É seguro executar o script mais de uma vez na mesma máquina: ele detecta se o coletor já está instalado e apenas atualiza a configuração, sem reinstalar o binário.
- **Nunca** recombine o token com e-mail nem gere um novo Base64 em cima do valor copiado da tela "Gerenciar tokens" — o valor já vem pronto para o header `Authorization` e qualquer recodificação quebra a autenticação (erro 401).
- Se aparecerem erros `401` persistentes nos logs (`journalctl -u otel-collector`), confira se o token ainda está ativo em **Gerenciar tokens** e se foi colado sem espaços ou quebras de linha.
- Trate o token de ingestão como uma credencial: não o cole em canais públicos nem o deixe em scripts versionados. Se ele for exposto, revogue-o e gere um novo.
## Rollout em massa (LXCs e VMs de um host Proxmox)
Para instalar em muitos containers LXC de uma vez, use `deploy-openobserve-fleet.sh`, executado **no próprio host Proxmox** como root, na mesma pasta onde está `openobserve-install.sh`:
```bash
wget -O deploy-openobserve-fleet.sh https://git.ledcloud.com.br/LED_Cloud/install-openserve/raw/branch/main/deploy-openobserve-fleet.sh
chmod +x deploy-openobserve-fleet.sh
sudo OO_URL="https://openobserve.ledcloud.com.br/api/<org_id>/" \
OO_AUTH_B64="<token_base64_copiado_da_tela>" \
./deploy-openobserve-fleet.sh
```
Ele lista todos os LXCs (`pct list`), pede confirmação e, para cada container em execução, copia o `openobserve-install.sh` com `pct push`, executa com `pct exec` em modo não interativo e remove o arquivo temporário ao final. Ao término, mostra um resumo de quais hosts tiveram sucesso, foram pulados ou falharam.
Variáveis opcionais:
- `SKIP_LXC_IDS` — IDs de LXC a pular, separados por espaço (ex.: `"105 112"`).
- `VM_SSH_HOSTS` — lista de IPs/hosts de VMs para instalar também via SSH (requer chave SSH configurada para root), separados por espaço.
Exemplo incluindo VMs:
```bash
sudo OO_URL="https://openobserve.ledcloud.com.br/api/<org_id>/" \
OO_AUTH_B64="<token_base64>" \
VM_SSH_HOSTS="10.0.0.11 10.0.0.12" \
SKIP_LXC_IDS="105" \
./deploy-openobserve-fleet.sh
```

158
deploy-openobserve-fleet.sh Normal file
View file

@ -0,0 +1,158 @@
#!/usr/bin/env bash
#
# deploy-openobserve-fleet.sh
#
# Roda openobserve-install.sh em TODOS os containers LXC de um host Proxmox
# (e, opcionalmente, numa lista de VMs via SSH), de forma não interativa.
#
# Execute este script NO PROPRIO HOST PROXMOX (como root), na mesma pasta
# onde está o openobserve-install.sh.
#
# Configuração: edite as variáveis abaixo ou exporte-as antes de rodar.
#
# OO_URL URL de ingestão (a mesma para todos os hosts)
# OO_AUTH_B64 Token de ingestão em Base64, colado tal e qual da tela
# Gerenciar tokens (NÃO recodificar)
# SKIP_LXC_IDS IDs de LXC para pular, separados por espaço (opcional)
# VM_SSH_HOSTS lista de hosts/IPs de VMs para instalar via SSH (opcional)
#
# Uso:
# sudo OO_URL="https://openobserve.ledcloud.com.br/api/<org_id>/" \
# OO_AUTH_B64="<token_base64>" \
# ./deploy-openobserve-fleet.sh
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
INSTALL_SCRIPT="${SCRIPT_DIR}/openobserve-install.sh"
OO_URL="${OO_URL:-}"
OO_AUTH_B64="${OO_AUTH_B64:-}"
SKIP_LXC_IDS="${SKIP_LXC_IDS:-}"
VM_SSH_HOSTS="${VM_SSH_HOSTS:-}"
log() { echo "[deploy-fleet] $*"; }
err() { echo "[deploy-fleet] ERRO: $*" >&2; }
if [[ "${EUID}" -ne 0 ]]; then
err "execute como root no host Proxmox."
exit 1
fi
if [[ ! -f "${INSTALL_SCRIPT}" ]]; then
err "não encontrei ${INSTALL_SCRIPT}. Coloque openobserve-install.sh na mesma pasta."
exit 1
fi
if [[ -z "${OO_URL}" ]]; then
read -rp "URL de ingestão do OpenObserve: " OO_URL
fi
[[ "${OO_URL}" != */ ]] && OO_URL="${OO_URL}/"
if [[ -z "${OO_AUTH_B64}" ]]; then
read -rp "Token de ingestão em Base64 (cole como está): " OO_AUTH_B64
fi
if ! command -v pct >/dev/null 2>&1; then
err "comando 'pct' não encontrado — este script deve rodar no host Proxmox."
exit 1
fi
should_skip() {
local vmid="$1"
for skip in ${SKIP_LXC_IDS}; do
[[ "${vmid}" == "${skip}" ]] && return 0
done
return 1
}
FAILED=()
OK=()
SKIPPED=()
log "Containers LXC encontrados:"
pct list
echo
read -rp "Confirma instalação em TODOS os LXCs acima (exceto os pulados)? [s/N] " CONFIRM
if [[ ! "${CONFIRM}" =~ ^[sSyY]$ ]]; then
log "Cancelado pelo usuário."
exit 0
fi
while read -r VMID STATUS NAME; do
[[ "${VMID}" == "VMID" ]] && continue # cabeçalho da tabela
[[ -z "${VMID}" ]] && continue
if should_skip "${VMID}"; then
log "LXC ${VMID} (${NAME}): pulado (SKIP_LXC_IDS)."
SKIPPED+=("${VMID}:${NAME}")
continue
fi
if [[ "${STATUS}" != "running" ]]; then
log "LXC ${VMID} (${NAME}): não está rodando (status=${STATUS}), pulando."
SKIPPED+=("${VMID}:${NAME}")
continue
fi
log "LXC ${VMID} (${NAME}): enviando script..."
if ! pct push "${VMID}" "${INSTALL_SCRIPT}" /tmp/openobserve-install.sh >/dev/null 2>&1; then
err "LXC ${VMID} (${NAME}): falha ao copiar script (pct push)."
FAILED+=("${VMID}:${NAME}")
continue
fi
log "LXC ${VMID} (${NAME}): instalando..."
if pct exec "${VMID}" -- bash -c "
chmod +x /tmp/openobserve-install.sh
OO_URL='${OO_URL}' OO_AUTH_B64='${OO_AUTH_B64}' /tmp/openobserve-install.sh
rm -f /tmp/openobserve-install.sh
"; then
log "LXC ${VMID} (${NAME}): OK."
OK+=("${VMID}:${NAME}")
else
err "LXC ${VMID} (${NAME}): falhou. Veja o log acima."
FAILED+=("${VMID}:${NAME}")
fi
done < <(pct list | tail -n +1)
# --- VMs via SSH (opcional) ----------------------------------------------
if [[ -n "${VM_SSH_HOSTS}" ]]; then
log "Instalando em VMs via SSH: ${VM_SSH_HOSTS}"
for VM_HOST in ${VM_SSH_HOSTS}; do
log "VM ${VM_HOST}: enviando script..."
if ! scp -q "${INSTALL_SCRIPT}" "root@${VM_HOST}:/tmp/openobserve-install.sh"; then
err "VM ${VM_HOST}: falha ao copiar script (scp)."
FAILED+=("vm:${VM_HOST}")
continue
fi
log "VM ${VM_HOST}: instalando..."
if ssh "root@${VM_HOST}" "
chmod +x /tmp/openobserve-install.sh
OO_URL='${OO_URL}' OO_AUTH_B64='${OO_AUTH_B64}' /tmp/openobserve-install.sh
rm -f /tmp/openobserve-install.sh
"; then
log "VM ${VM_HOST}: OK."
OK+=("vm:${VM_HOST}")
else
err "VM ${VM_HOST}: falhou. Veja o log acima."
FAILED+=("vm:${VM_HOST}")
fi
done
fi
# --- Resumo ----------------------------------------------------------------
echo
log "===== Resumo ====="
log "OK (${#OK[@]}): ${OK[*]:-nenhum}"
log "Pulados (${#SKIPPED[@]}): ${SKIPPED[*]:-nenhum}"
log "Falharam (${#FAILED[@]}): ${FAILED[*]:-nenhum}"
if [[ ${#FAILED[@]} -gt 0 ]]; then
exit 1
fi

173
openobserve-install.sh Normal file
View file

@ -0,0 +1,173 @@
#!/usr/bin/env bash
#
# openobserve-install.sh
#
# Instala (se necessário) e configura o agente OpenObserve (otelcol-contrib)
# em qualquer host Linux (VM ou container LXC), usando o TOKEN DE INGESTÃO
# já codificado em Base64, copiado diretamente de:
# Dados > Fontes de dados > Gerenciar tokens (organização LED Cloud)
#
# IMPORTANTE: o valor colado em OO_AUTH_B64 é usado EXATAMENTE como veio da
# tela do OpenObserve (algo como "ZGVmYXVsdDpvMm9pX..."). O script NÃO
# recodifica, NÃO concatena com e-mail e NÃO gera um novo base64 em cima
# dele — fazer isso quebra a autenticação (erro 401).
#
# O script é idempotente: pode ser executado várias vezes no mesmo host
# (por exemplo para trocar o token) sem reinstalar o binário.
#
# Uso interativo:
# sudo ./openobserve-install.sh
#
# Uso não interativo (para automação / rollout em massa):
# sudo OO_URL="https://openobserve.ledcloud.com.br/api/3LdpBskdGjwTW05q6xWAdnwcHUs/" \
# OO_AUTH_B64="ZGVmYXVsdDpvMm9pX1NFVV9UT0tFTl9BUVVJ" \
# ./openobserve-install.sh
#
# Opcional:
# OO_HOSTNAME nome que vai aparecer em Infra > Hosts (padrão: hostname -s)
set -euo pipefail
CONFIG_PATH="/etc/otel-config.yaml"
INSTALL_SH_URL="https://raw.githubusercontent.com/openobserve/agents/main/linux/install.sh"
SERVICE_NAME="otel-collector"
OTELCOL_BIN="/usr/local/bin/otelcol-contrib"
log() { echo "[openobserve-install] $(hostname -s 2>/dev/null || echo '?'): $*"; }
err() { echo "[openobserve-install] $(hostname -s 2>/dev/null || echo '?'): ERRO: $*" >&2; }
if [[ "${EUID}" -ne 0 ]]; then
err "execute como root (ou com sudo)."
exit 1
fi
# --- Coleta de parâmetros -----------------------------------------------
OO_URL="${OO_URL:-}"
if [[ -z "${OO_URL}" ]]; then
read -rp "URL de ingestão do OpenObserve (ex.: https://openobserve.ledcloud.com.br/api/<org_id>/): " OO_URL
fi
[[ "${OO_URL}" != */ ]] && OO_URL="${OO_URL}/"
OO_AUTH_B64="${OO_AUTH_B64:-}"
if [[ -z "${OO_AUTH_B64}" ]]; then
read -rp "Token de ingestão em Base64 (copiado de Gerenciar tokens, cole como está): " OO_AUTH_B64
fi
if [[ -z "${OO_AUTH_B64}" ]]; then
err "token vazio. Gere/copie em Dados > Fontes de dados > Gerenciar tokens e tente de novo."
exit 1
fi
# Sanidade: o valor deve ser base64 válido. Se não for, provavelmente foi
# colado errado (ex.: usuário colou "email:token" em texto puro).
if ! printf '%s' "${OO_AUTH_B64}" | base64 -d >/dev/null 2>&1; then
err "o valor de OO_AUTH_B64 não parece ser base64 válido. Cole exatamente o" \
"texto que a tela 'Gerenciar tokens' mostra, sem modificar."
exit 1
fi
OO_HOSTNAME="${OO_HOSTNAME:-$(hostname -s)}"
log "Host a configurar: ${OO_HOSTNAME}"
log "Endpoint: ${OO_URL}"
# --- Instala o coletor, se ainda não existir -----------------------------
if [[ ! -x "${OTELCOL_BIN}" ]] || [[ ! -f "${CONFIG_PATH}" ]]; then
log "Coletor não encontrado, instalando..."
TMP_INSTALL="$(mktemp -d)"
trap 'rm -rf "${TMP_INSTALL}"' EXIT
curl -fsSL -o "${TMP_INSTALL}/install.sh" "${INSTALL_SH_URL}"
chmod +x "${TMP_INSTALL}/install.sh"
# install.sh grava o 2º argumento tal e qual no header Authorization.
"${TMP_INSTALL}/install.sh" "${OO_URL}" "${OO_AUTH_B64}"
else
log "Coletor já instalado, apenas reconfigurando."
fi
if [[ ! -f "${CONFIG_PATH}" ]]; then
err "instalação não gerou ${CONFIG_PATH}. Abortando."
exit 1
fi
cp -a "${CONFIG_PATH}" "${CONFIG_PATH}.bak.$(date +%s)"
# --- Garante credencial e host.name corretos no arquivo final -----------
# (cobre tanto o caso de reconfiguração quanto qualquer drift da instalação)
OO_AUTH_B64="${OO_AUTH_B64}" OO_HOSTNAME="${OO_HOSTNAME}" python3 - "${CONFIG_PATH}" <<'PY'
import os
import re
import sys
path = sys.argv[1]
auth = os.environ["OO_AUTH_B64"]
hostname = os.environ["OO_HOSTNAME"]
with open(path, "r") as f:
config = f.read()
# 1) Usa o valor de auth EXATAMENTE como veio — sem recombinar com e-mail.
config, auth_count = re.subn(
r'Authorization:\s*"Basic [^"]*"',
f'Authorization: "Basic {auth}"',
config,
)
if auth_count == 0:
raise SystemExit("ERRO: nenhuma linha 'Authorization: \"Basic ...\"' encontrada.")
# 2) Força host.name=<hostname> no processor resource/hostname, sem
# duplicar entradas em execuções repetidas.
config = re.sub(
r' - key: host\.name\n value: [^\n]*\n action: upsert\n',
'',
config,
)
marker = f' - key: host.name\n value: {hostname}\n action: upsert\n'
anchor = (
" resource/hostname:\n"
" attributes:\n"
" - key: host.name\n"
" from_attribute: ec2.tag.Name\n"
" action: upsert\n"
)
if anchor in config:
config = config.replace(anchor, anchor + marker, 1)
else:
raise SystemExit(
"ERRO: bloco 'resource/hostname' não encontrado no formato esperado; "
"edite manualmente."
)
with open(path, "w") as f:
f.write(config)
print(f"Autenticação atualizada em {auth_count} exporter(es). host.name fixado em '{hostname}'.")
PY
# --- Valida e reinicia ----------------------------------------------------
log "Validando configuração..."
"${OTELCOL_BIN}" validate --config="${CONFIG_PATH}"
log "Reiniciando serviço ${SERVICE_NAME}..."
systemctl restart "${SERVICE_NAME}"
systemctl enable "${SERVICE_NAME}" >/dev/null 2>&1 || true
sleep 3
if ! systemctl is-active --quiet "${SERVICE_NAME}"; then
err "serviço não está ativo após o restart. Verifique: journalctl -u ${SERVICE_NAME} -n 50 --no-pager"
exit 1
fi
log "Aguardando alguns segundos para checar autenticação..."
sleep 10
if journalctl -u "${SERVICE_NAME}" --since "9 seconds ago" --no-pager | grep -q ' 401'; then
err "ainda há erros 401. Confira se OO_AUTH_B64 foi colado sem alterações."
err "Veja: journalctl -u ${SERVICE_NAME} -n 30 --no-pager"
exit 1
fi
log "OK: serviço ativo, sem erros 401 recentes."
log "Confira em Infra > Hosts no OpenObserve (pode levar ~1 min para aparecer como '${OO_HOSTNAME}')."