TL;DR — Resumo Rápido

Vector é um pipeline de observabilidade em Rust da Datadog. Colete logs, métricas e traces de qualquer fonte e envie-os para qualquer destino com VRL.

Vector é um pipeline de dados de observabilidade de alto desempenho escrito em Rust, mantido pela Datadog. Ele coleta logs, métricas e traces de qualquer fonte, transforma-os com VRL (Vector Remap Language) e os roteia para qualquer destino, tudo em um único binário vinculado estaticamente que usa uma fração da memória consumida pelo Logstash ou Fluentd. Este guia cobre o stack completo do Vector: arquitetura, instalação, configuração, transformações VRL, padrões de implantação, garantias de entrega e um pipeline de produção que coleta logs do Nginx e os roteia para Loki e ClickHouse.

Pré-requisitos

  • Servidor Linux (Ubuntu 22.04+, Debian 12+, RHEL 9+) ou macOS para testes locais.
  • Docker ou cluster Kubernetes (opcional, para implantações em contêiner).
  • Familiaridade básica com configuração YAML.
  • Destinos em execução e acessíveis (Loki, Elasticsearch, ClickHouse, S3, etc.).

Arquitetura do Vector

O Vector processa dados de observabilidade como um grafo acíclico dirigido (DAG) de fontes → transformações → destinos.

  • Fontes — ingerem dados de arquivos, journals, sockets, HTTP, Kafka, APIs em nuvem.
  • Transformações — analisam, enriquecem, filtram, roteiam, agregam ou deduplicam eventos.
  • Destinos — entregam dados a sistemas de armazenamento, busca, métricas e alertas.

O Vector alcança seu throughput por meio de várias decisões de design nativas do Rust:

  • Análise sem cópia — as linhas de log são analisadas no lugar sem alocações extras de heap.
  • Concorrência adaptativa — o Vector ajusta automaticamente o número de requisições em voo para cada destino usando um algoritmo AIMD, evitando sobrecarga sem configuração manual.
  • Confirmações de ponta a ponta — uma linha de log não é deletada de sua fonte até que todos os destinos confirmem o recebimento.
  • Buffers em disco — eventos transbordam para disco quando a fila em memória enche, sobrevivendo a reinicializações.

Instalação

apt (Debian/Ubuntu)

curl -1sLf 'https://repositories.timber.io/public/vector/cfg/setup/bash.deb.sh' \
  | sudo -E bash
sudo apt install -y vector
sudo systemctl enable --now vector

yum/dnf (RHEL/Fedora/Rocky)

curl -1sLf 'https://repositories.timber.io/public/vector/cfg/setup/bash.rpm.sh' \
  | sudo -E bash
sudo yum install -y vector
sudo systemctl enable --now vector

Docker

docker run -d \
  --name vector \
  -v /var/log:/var/log:ro \
  -v $(pwd)/vector.yaml:/etc/vector/vector.yaml:ro \
  timberio/vector:latest-alpine

Kubernetes DaemonSet via Helm

helm repo add vector https://helm.vector.dev
helm repo update
helm install vector vector/vector \
  --namespace vector \
  --create-namespace \
  --values vector-values.yaml

Homebrew (macOS)

brew tap vectordotdev/brew
brew install vector

Configuração

O Vector lê vector.yaml (ou vector.toml, vector.json) de /etc/vector/ por padrão:

data_dir: /var/lib/vector

sources:
  minha_fonte:
    type: file
    include: ["/var/log/nginx/*.log"]

transforms:
  minha_transformacao:
    type: remap
    inputs: ["minha_fonte"]
    source: |
      . = parse_json!(string!(.message))

sinks:
  meu_destino:
    type: loki
    inputs: ["minha_transformacao"]
    endpoint: "http://loki:3100"
    labels:
      job: nginx

Cada componente tem uma chave de string única. inputs conecta os componentes entre si.

Referência de Fontes

Fonte Chave type Descrição
Rastreamento de arquivos file Rastreia arquivos de log com padrões glob
Journal systemd journald Lê do journald com filtros de unidade
Contêineres Docker docker_logs Coleta do socket do daemon Docker
Pods do Kubernetes kubernetes_logs Coleta nativa de k8s com metadados de pod
Syslog UDP/TCP syslog Recebe mensagens syslog RFC 3164 / RFC 5424
Servidor HTTP http_server Expõe endpoint HTTP para receber logs
Kafka kafka Consome de um ou mais tópicos Kafka
Métricas do host host_metrics Coleta CPU, memória, disco, rede
Métricas internas internal_metrics Contadores de throughput e erro do próprio Vector

VRL — Vector Remap Language

VRL é a linguagem de transformação no núcleo do Vector. É uma linguagem de expressões tipada estaticamente projetada para ser rápida, segura e legível. Cada programa VRL recebe um evento como . (ponto) e deve retornar o evento mutado.

Analisar JSON

transforms:
  analisar_json:
    type: remap
    inputs: ["nginx_access"]
    source: |
      . = parse_json!(string!(.message))

O sufixo ! em uma chamada de função significa “abortar o evento se isso falhar.” Eventos com falha são roteados para a saída dropped do componente.

Analisar Syslog

transforms:
  analisar_syslog:
    type: remap
    inputs: ["syslog_entrada"]
    source: |
      parsed = parse_syslog!(.message)
      .severity = parsed.severity
      .facility = parsed.facility
      .appname = parsed.appname
      .message = parsed.message

Lógica Condicional e Redação de PII

source: |
  if .status_code >= 500 {
    .severity = "error"
  } else if .status_code >= 400 {
    .severity = "warn"
  } else {
    .severity = "info"
  }

  .message = redact(.message, filters: [
    { type: "pattern", pattern: r'\b(?:\d[ -]*?){13,16}\b' }
  ])

  del(.trace_id_interno)

Análise com Regex para Nginx

transforms:
  analisar_nginx:
    type: remap
    inputs: ["nginx_access"]
    source: |
      parsed, err = parse_regex(.message, r'^(?P<remote_addr>\S+) - (?P<user>\S+) \[(?P<time>[^\]]+)\] "(?P<method>\S+) (?P<path>\S+) (?P<protocol>[^"]+)" (?P<status>\d+) (?P<bytes>\d+)')
      if err == null {
        . = merge(., parsed)
        .status = to_int!(.status)
        .bytes = to_int!(.bytes)
        del(.message)
      }

Referência de Transformações

Transformação Propósito
remap Transformação VRL completa — analisar, enriquecer, filtrar, mutar
filter Descartar eventos que não correspondam a uma condição VRL
route Dividir o stream em pistas nomeadas por condição
aggregate Combinar múltiplos eventos em um (agrupamento, janelas de tempo)
dedupe Descartar eventos duplicados em uma janela de tempo
sample Manter uma porcentagem configurável de eventos
log_to_metric Derivar contadores/gauges de campos de log

Referência de Destinos

Destino Chave type Caso de uso
Loki loki Armazenamento de logs do Grafana
Elasticsearch / OpenSearch elasticsearch Busca de texto completo e análise
ClickHouse clickhouse Armazenamento analítico de logs de alto volume
S3 / R2 aws_s3 Arquivamento de longo prazo
Kafka kafka Republica para consumidores downstream
Prometheus Exporter prometheus_exporter Expõe métricas em /metrics
Datadog Logs datadog_logs Envia para a ingestão do Datadog
Splunk HEC splunk_hec_logs Envia para o Splunk HTTP Event Collector

Buffers e Garantias de Entrega

Para produção, habilite buffers em disco e confirmações:

sinks:
  clickhouse_destino:
    type: clickhouse
    inputs: ["analisar_nginx"]
    endpoint: "http://clickhouse:8123"
    database: logs
    table: nginx_access
    buffer:
      type: disk
      max_size: 268435456
      when_full: block
    acknowledgements:
      enabled: true

Com acknowledgements.enabled: true, o Vector aguarda a confirmação do destino antes de avançar a posição de leitura na fonte, alcançando entrega durável pelo menos uma vez.

Testes Unitários de Transformações

tests:
  - name: "analisar_nginx processa requisição 200 corretamente"
    inputs:
      - insert_at: analisar_nginx
        type: log
        log_fields:
          message: '127.0.0.1 - - [23/Mar/2026:10:00:00 +0000] "GET /api/health HTTP/1.1" 200 42'
    outputs:
      - extract_from: analisar_nginx
        conditions:
          - type: vrl
            source: |
              assert_eq!(.status, 200)
              assert_eq!(.method, "GET")
vector test /etc/vector/vector.yaml

Monitoramento do Vector

# Throughput por componente em tempo real
vector top

# Validar configuração sem iniciar
vector validate /etc/vector/vector.yaml

Expor as próprias métricas do Vector para o Prometheus:

sources:
  metricas_internas:
    type: internal_metrics
    scrape_interval_secs: 15

sinks:
  prometheus:
    type: prometheus_exporter
    inputs: ["metricas_internas"]
    address: "0.0.0.0:9598"

Vector vs Alternativas

Característica Vector Fluentd Fluent Bit Logstash Filebeat Promtail Grafana Alloy
Linguagem Rust Ruby C JVM Go Go Go
Memória ~20 MB ~200 MB ~1 MB ~512 MB ~50 MB ~30 MB ~60 MB
Throughput Muito alto Médio Alto Médio Alto Médio Alto
Transformações VRL DSL Fluentd Lua Ruby/Grok Mínimo Stages DSL Alloy
Pipeline de métricas Sim Plugin Limitado Plugin Não Não Sim
Buffers em disco Nativo Plugin Sim Nativo Nativo Não Sim
Testes unitários Integrados Não Não Não Não Não Limitado
Kubernetes nativo Sim Sim Sim Não Sim Sim Sim

Casos Extremos e Armadilhas Comuns

  • VRL ! vs ? — parse_json! aborta o evento em caso de erro; parse_json? retorna null. Escolha conscientemente.
  • Rastreamento de posição de arquivos — o Vector armazena offsets em data_dir. Excluir este diretório causa re-ingestão de arquivos existentes.
  • Cardinalidade de labels no Loki — evite usar campos de alta cardinalidade (IDs de usuário) como labels do Loki.
  • Tipos de dados no ClickHouse — predefina o esquema da tabela e defina skip_unknown_fields: true para evitar erros de ingestão.

Resumo

  • Vector é um pipeline de observabilidade baseado em Rust com um modelo DAG de fontes → transformações → destinos.
  • VRL trata toda a análise, enriquecimento, filtragem e roteamento em uma linguagem segura e testável.
  • Modos de implantação: agente (por host), agregador (centralizado), sidecar (pod do Kubernetes).
  • Buffers em disco + confirmações fornecem entrega durável pelo menos uma vez sem perda de dados em falhas.
  • Testes unitários no vector.yaml validam transformações antes da implantação em produção.
  • O Vector gerencia logs e métricas em um único pipeline, substituindo Fluentd, Logstash, Filebeat e Promtail simultaneamente.

Artigos Relacionados