TL;DR — Resumen Rápido

Vector es un pipeline de observabilidad en Rust de Datadog. Recolecta logs, métricas y trazas desde cualquier fuente y los enruta con transformaciones VRL.

Vector es un pipeline de datos de observabilidad de alto rendimiento escrito en Rust, mantenido por Datadog. Recolecta logs, métricas y trazas desde cualquier fuente, los transforma con VRL (Vector Remap Language) y los enruta hacia cualquier destino, todo en un único binario enlazado estáticamente que usa una fracción de la memoria que consumen Logstash o Fluentd. Esta guía cubre el stack completo de Vector: arquitectura, instalación, configuración, transformaciones VRL, patrones de despliegue, garantías de entrega y un pipeline de producción que recolecta logs de Nginx y los enruta a Loki y ClickHouse.

Requisitos Previos

  • Servidor Linux (Ubuntu 22.04+, Debian 12+, RHEL 9+) o macOS para pruebas locales.
  • Docker o clúster de Kubernetes (opcional, para despliegues en contenedores).
  • Familiaridad básica con configuración YAML.
  • Destinos funcionando y accesibles (Loki, Elasticsearch, ClickHouse, S3, etc.).

Arquitectura de Vector

Vector procesa datos de observabilidad como un grafo dirigido acíclico (DAG) de fuentes → transformaciones → destinos.

  • Fuentes — ingieren datos desde archivos, journals, sockets, HTTP, Kafka, APIs en la nube.
  • Transformaciones — parsean, enriquecen, filtran, enrutan, agregan o deduplicar eventos.
  • Destinos — entregan datos a sistemas de almacenamiento, búsqueda, métricas y alertas.

Bajo el capó, Vector logra su rendimiento mediante varias decisiones de diseño nativas de Rust:

  • Parseo sin copia — las líneas de log se parsean en el lugar sin asignaciones adicionales de heap.
  • Concurrencia adaptativa — Vector ajusta automáticamente el número de peticiones en vuelo hacia cada destino usando un algoritmo AIMD, evitando sobrecarga sin configuración manual.
  • Confirmaciones de extremo a extremo — una línea de log no se elimina de su fuente (o buffer) hasta que todos los destinos configurados confirman su recepción.
  • Buffers en disco — los eventos se desbordan a disco cuando la cola en memoria se llena, sobreviviendo reinicios y evitando pérdidas durante interrupciones del destino.

Instalación

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

Configuración

Vector lee vector.yaml (o vector.toml, vector.json) desde /etc/vector/ por defecto:

data_dir: /var/lib/vector

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

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

sinks:
  mi_destino:
    type: loki
    inputs: ["mi_transformacion"]
    endpoint: "http://loki:3100"
    labels:
      job: nginx

Cada componente tiene una clave de cadena única. inputs conecta los componentes entre sí.

Referencia de Fuentes

Fuente Clave type Descripción
Seguimiento de archivos file Sigue archivos de log con patrones glob
Journal systemd journald Lee de journald con filtros de unidad
Contenedores Docker docker_logs Recolecta del socket del daemon Docker
Pods de Kubernetes kubernetes_logs Recolección nativa de k8s con metadatos de pod
Syslog UDP/TCP syslog Recibe mensajes syslog RFC 3164 / RFC 5424
Servidor HTTP http_server Expone un endpoint HTTP para logs enviados
Kafka kafka Consume de uno o más tópicos de Kafka
Métricas del host host_metrics Recolecta CPU, memoria, disco, red
Métricas internas internal_metrics Contadores de rendimiento y error propios de Vector

VRL — Vector Remap Language

VRL es el lenguaje de transformación en el núcleo de Vector. Es un lenguaje de expresiones de tipo estático diseñado para ser rápido, seguro y legible. Cada programa VRL recibe un evento como . (punto) y debe devolver el evento mutado.

Parsear JSON

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

El sufijo ! en una llamada de función significa “abortar el evento si esto falla.” Los eventos que fallan se enrutan a la salida dropped del componente.

Parsear Syslog

transforms:
  parsear_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 y Redacción 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)

Parseo con Expresión Regular para Nginx

transforms:
  parsear_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)
      }

Referencia de Transformaciones

Transformación Propósito
remap Transformación VRL completa — parsear, enriquecer, filtrar, mutar
filter Descartar eventos que no coincidan con una condición VRL
route Dividir el stream en carriles nombrados por condición
aggregate Combinar múltiples eventos en uno (agrupación, ventanas de tiempo)
dedupe Descartar eventos duplicados dentro de una ventana de tiempo
sample Conservar un porcentaje configurable de eventos
log_to_metric Derivar contadores/medidores desde campos de log

Referencia de Destinos

Destino Clave type Caso de uso
Loki loki Almacenamiento de logs de Grafana
Elasticsearch / OpenSearch elasticsearch Búsqueda de texto completo y analítica
ClickHouse clickhouse Almacenamiento analítico de logs de alto volumen
S3 / R2 aws_s3 Archivado a largo plazo
Kafka kafka Republica a consumidores posteriores
Prometheus Exporter prometheus_exporter Expone métricas en /metrics
Datadog Logs datadog_logs Envía a la ingesta de Datadog
Splunk HEC splunk_hec_logs Envía al Splunk HTTP Event Collector

Buffers y Garantías de Entrega

Para producción, habilitar buffers en disco y confirmaciones:

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

Con acknowledgements.enabled: true, Vector espera la confirmación del destino antes de avanzar la posición de lectura en la fuente, logrando entrega duradera al menos una vez.

Pruebas Unitarias de Transformaciones

tests:
  - name: "parsear_nginx procesa solicitud 200 correctamente"
    inputs:
      - insert_at: parsear_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: parsear_nginx
        conditions:
          - type: vrl
            source: |
              assert_eq!(.status, 200)
              assert_eq!(.method, "GET")
vector test /etc/vector/vector.yaml

Monitorización de Vector

# Rendimiento por componente en tiempo real
vector top

# Validar configuración sin arrancar
vector validate /etc/vector/vector.yaml

Exponer las propias métricas de Vector a 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
Lenguaje Rust Ruby C JVM Go Go Go
Memoria ~20 MB ~200 MB ~1 MB ~512 MB ~50 MB ~30 MB ~60 MB
Rendimiento Muy alto Medio Alto Medio Alto Medio Alto
Transformaciones VRL DSL Fluentd Lua Ruby/Grok Mínimo Stages DSL Alloy
Pipeline de métricas Sí Plugin Limitado Plugin No No Sí
Buffers en disco Nativo Plugin Sí Nativo Nativo No Sí
Pruebas unitarias Integradas No No No No No Limitado
Kubernetes nativo Sí Sí Sí No Sí Sí Sí

Casos Límite y Trampas Comunes

  • VRL ! vs ? — parse_json! aborta el evento ante un error; parse_json? devuelve null. Elige conscientemente.
  • Seguimiento de posición de archivos — Vector almacena offsets en data_dir. Borrar este directorio causa re-ingesta de archivos existentes.
  • Cardinalidad de etiquetas en Loki — evita usar campos de alta cardinalidad (IDs de usuario, IDs de solicitud) como etiquetas de Loki.
  • Tipos de datos en ClickHouse — predefine el esquema de la tabla y establece skip_unknown_fields: true para evitar errores de ingesta.

Resumen

  • Vector es un pipeline de observabilidad basado en Rust con un modelo DAG de fuentes → transformaciones → destinos.
  • VRL maneja todo el parseo, enriquecimiento, filtrado y enrutamiento en un lenguaje seguro y testeable.
  • Modos de despliegue: agente (por host), agregador (centralizado), sidecar (pod de Kubernetes).
  • Buffers en disco + confirmaciones proveen entrega duradera al menos una vez sin pérdida de datos ante caídas.
  • Pruebas unitarias en vector.yaml validan las transformaciones antes del despliegue en producción.
  • Vector maneja logs y métricas en un único pipeline, reemplazando Fluentd, Logstash, Filebeat y Promtail simultáneamente.

Artículos Relacionados