Barato y eficaz: cómo organizar la recopilación de logs desde clientes remotos vía HTTP

¿Tienes una aplicación distribuida en cientos de dispositivos cliente? ¿O una flota de sensores IoT que envían telemetrías? Tarde o temprano surge la pregunta: «¿Qué está pasando allí en realidad?» Y justo después — «¿Cómo recopilar los logs sin arruinarse con Splunk o Datadog?»

Si tus clientes pueden enviar peticiones HTTP, ya tienes el noventa por ciento de la solución. HTTP(S) es un protocolo universal y amigable con los firewalls. Todo lo que necesitamos es un “receptor” (endpoint) que acepte esos logs.

En este artículo repasaremos tres maneras económicas de organizar la recolección de logs por HTTP — desde “rápido, simple y funciona” hasta “escalable y casi gratuito”.

Por qué HTTP

• Universalidad — cualquier lenguaje y plataforma tiene un cliente HTTP.
• Simplicidad — el formato de una petición POST con cuerpo JSON es intuitivo.
• Accesibilidad — el puerto 443 (HTTPS) casi nunca está cerrado, a diferencia de puertos específicos para syslog o GELF.

Regla de oro: siempre usa HTTPS. Los certificados gratuitos de Let’s Encrypt se configuran en diez minutos y protegen tus datos de intercepciones.

Opción 1. Script en un VPS (rápido y muy barato)

La forma más simple, “casera”, pero también la más rápida de desplegar. Adecuada para proyectos personales o recolección de logs desde un número reducido de clientes.

Qué necesitarás

• Un VPS económico (Vultr, DigitalOcean, Hetzner u otros) por unos cinco dólares al mes.
• Stack: Nginx + cualquier script backend (Python/Flask, Node.js/Express, PHP).

Cómo funciona

1. Alquilas un servidor virtual.

2. Levantas Nginx como reverse proxy y para la terminación de SSL.

3. Escribes una aplicación web diminuta (veinte líneas de código) que:

   • acepta peticiones POST en /log;
   • si es necesario, verifica la clave secreta en el encabezado X-API-Key;
   • escribe el log JSON en un archivo.

Ejemplo en Python (Flask)

from flask import Flask, request, abort
import os
import json

app = Flask(__name__)

API_KEY = os.environ.get("LOG_API_KEY", "super-secret-key")

@app.route('/log', methods=['POST'])
def receive_log():
    if request.headers.get('X-API-Key') != API_KEY:
        abort(401)

    data = request.get_json(silent=True)
    if not data:
        abort(400)

    try:
        with open("/var/log/my-app/events.log", "a") as f:
            f.write(json.dumps(data) + "\n")
    except Exception as e:
        print(f"Failed to write log: {e}")
        abort(500)

    return "OK", 200

if __name__ == '__main__':
    app.run(host='127.0.0.1', port=5000)

Ventajas

• Costes mínimos (alrededor de cinco dólares al mes).
• Simplicidad y control sobre el almacenamiento.
• Despliegue en media hora.

Desventajas

• Escalabilidad limitada: escribir en un único archivo rápidamente se convierte en un cuello de botella.
• Requiere mantenimiento (rotación de logs, monitorización de disco, seguridad).
• Análisis — manualmente vía SSH y grep.

Opción 2. Recopilador en servidor (fiable y flexible)

Evolución de la primera opción — usamos un stack open-source optimizado listo para producción.

Qué necesitarás

• VPS por 5–10 dólares al mes.
• Stack: Vector, Loki, Grafana.

Cómo funciona

1. Vector — servidor HTTP que recibe los logs.
2. Loki — base de logs de Grafana, indexa solo etiquetas (labels), lo que hace el almacenamiento barato.
3. Grafana — interfaz cómoda para buscar y analizar logs con LogQL.

Ejemplo de configuración de Vector (vector.yaml)

sources:
  http_logs:
    type: "http"
    address: "0.0.0.0:8080"
    decoding:
      codec: "json"
    auth:
      strategy: "header"
      header_key: "X-API-Key"
      api_keys: ["super-secret-key"]

transforms:
  my_transform:
    type: "remap"
    inputs: ["http_logs"]
    source: |
      .app = "my_mobile_app"
      .level = get!(.level, default: "info")

sinks:
  loki:
    type: "loki"
    inputs: ["my_transform"]
    endpoint: "http://localhost:3100"
    labels:
      app: "{{ app }}"
      level: "{{ level }}"
    encoding:
      codec: "json"

Ventajas

• Alto rendimiento (miles de logs por segundo).
• Búsqueda y filtrado cómodo vía Grafana.
• Vector puede enviar logs no solo a Loki, sino también a S3, ClickHouse y otros almacenes.

Desventajas

• Configuración más compleja: tres componentes que requieren Docker o systemd.

Opción 3. Serverless (casi gratis y escalable infinitamente)

La opción más moderna y flexible. Sin servidores — solo pagas por solicitudes y volumen de datos.

Qué necesitarás

• Cuenta en la nube (AWS, Google Cloud o Yandex Cloud).
• Stack (ejemplo en AWS): API Gateway + Lambda + S3 o CloudWatch Logs.

Cómo funciona

1. El cliente envía una petición POST.

2. API Gateway recibe la petición como endpoint HTTP gestionado.

3. Llama a una Lambda.

4. Lambda:

   • guarda el JSON en S3 por fecha;
   • envía el log a CloudWatch Logs.

Ejemplo de Lambda en Python (escritura en S3)

import json
import boto3
import time
import os

s3 = boto3.client('s3')
BUCKET_NAME = os.environ['LOG_BUCKET_NAME']

def lambda_handler(event, context):
    body = event.get('body')
    if not body:
        return {'statusCode': 400, 'body': 'No data'}

    try:
        log_data = json.loads(body)
    except json.JSONDecodeError:
        return {'statusCode': 400, 'body': 'Invalid JSON'}

    now = time.strftime('%Y/%m/%d/%H', time.gmtime())
    file_name = f"{context.aws_request_id}.json"
    s3_key = f"logs/{now}/{file_name}"

    try:
        s3.put_object(
            Bucket=BUCKET_NAME,
            Key=s3_key,
            Body=json.dumps(log_data),
            ContentType='application/json'
        )
        return {'statusCode': 200, 'body': 'OK'}
    except Exception as e:
        print(e)
        return {'statusCode': 500, 'body': 'Error saving log'}

Ventajas

• Los límites gratuitos de AWS/Google/Yandex cubren millones de logs al mes.
• Escalado automático.
• No hay servidores ni actualizaciones — mínimo mantenimiento.

Desventajas

• El análisis requiere configuración (por ejemplo, AWS Athena o BigQuery).
• Vinculación al proveedor de nube (vendor lock-in).

Buenas prácticas en el lado del cliente

1. Envío asíncrono — no bloquees el hilo principal de la aplicación.
2. Envío por lotes — agrupa logs en un array y envíalos por lotes (cada 30 segundos o tras 50 eventos).
3. Reintentos (retry) — guarda logs offline localmente (por ejemplo, en SQLite) y envíalos más tarde.
4. Filtrado — envía solo niveles importantes (INFO, WARN, ERROR).

Conclusión

Recopilar logs desde clientes remotos de forma económica es totalmente factible. Lo principal es elegir la opción que mejor se ajuste a tus necesidades.