DuckDB Quack: protocolo HTTP para análisis multi-usuario en entornos cloud

Introducción

Hasta ahora, DuckDB funcionaba como un motor SQL embebido en procesos locales o notebooks: rápido, sin servidor dedicado y con soporte nativo para Parquet. Pero en entornos cloud donde múltiples servicios necesitan acceder a los mismos datasets —por ejemplo, un pipeline de ML en Kubernetes y una app de BI en Serverless—, la falta de un protocolo remoto limitaba su adopción en producción. La solución tradicional implicaba migrar a bases de datos pesadas como PostgreSQL o usar soluciones intermedias como Arrow Flight SQL, que añaden complejidad y overhead de red.

Quack cambia el paradigma al exponer un protocolo HTTP nativo sobre el motor de DuckDB. Con esto, cualquier aplicación puede enviar consultas SQL a una instancia remota de DuckDB sin perder rendimiento, manteniendo la compatibilidad con el formato de almacenamiento nativo (Parquet) y evitando conversiones intermedias. La versión 1.5.3 ya incluye el soporte como extensión autoloadable, y la roadmap apunta a integrarlo con DuckLake —el «catálogo distribuido» de DuckDB— para 2026.

Qué ocurrió

El 31 de mayo de 2026, el equipo de DuckDB anunció Quack, un protocolo HTTP para convertir instancias de DuckDB en servidores accesibles por múltiples clientes. A diferencia de soluciones como Arrow Flight SQL —que depende de Apache Arrow y RPC—, Quack usa HTTP puro con payloads en formato nativo de DuckDB (.duckdb/.parquet), lo que reduce el overhead de serialización. Según benchmarks internos, transfiere datasets un 3.5× más rápido que Arrow Flight y supera a PostgreSQL en consultas pequeñas gracias a la optimización de round-trips:

POST /quack/v1/query HTTP/1.1
Host: duckdb-server:8080
Content-Type: application/json

{
  "query": "SELECT * FROM read_parquet('dataset.parquet') WHERE id > 1000",
  "format": "json"
}

El protocolo se activa mediante una extensión en DuckDB 1.5.3+:

-- En el servidor remoto
INSTALL quack;
LOAD quack;
CALL quack_set_port(8080);
CALL quack_start();

Para los clientes, la interacción es transparente:

import duckdb

conn = duckdb.connect("http://duckdb-server:8080/quack/v1")
result = conn.execute("SELECT COUNT(*) FROM my_table").fetchall()

Impacto para DevOps / Infraestructura / Cloud / Seguridad

DevOps y operaciones

Quack permite escalar DuckDB horizontalmente sin cambiar de motor. En entornos como AKS o EKS, una sola instancia de DuckDB puede servir consultas a cientos de pods, reduciendo la complejidad de orquestación. Por ejemplo, un equipo de datos puede:

• Centralizar datasets en S3 (usando DuckLake) y exponerlos vía Quack a microservicios en Kubernetes.
• Eliminar réplicas de PostgreSQL para workloads read-heavy, reemplazándolas por instancias de DuckDB en pods efímeros.
• Reducir costos al no necesitar un RDS PostgreSQL para análisis ad-hoc.

Benchmark interno de DuckDB Labs (marzo 2026) muestra que una consulta sobre 10GB de datos en Parquet:

Quack está diseñado para integrarse con S3-compatible storage a través de DuckLake, el catálogo distribuido de DuckDB. Esto permite:

• Consultas directas sobre objetos en S3 sin necesidad de descargarlos localmente.
• Caching inteligente en el servidor Quack, evitando relecturas de archivos Parquet.
• Transacciones ligeras para workloads de ETL, con soporte de BEGIN/COMMIT limitado a operaciones sobre el mismo archivo.

Ejemplo de despliegue en AWS EKS con Helm:

# values.yaml para el chart de DuckDB
quack:
  enabled: true
  port: 8080
  storage:
    type: s3
    bucket: "analytics-data"
    region: "us-east-1"
    cacheSizeMB: 512

Seguridad

El protocolo HTTP expone nuevos vectores de ataque si no se configura correctamente:

• Autenticación: Quack no incluye autenticación por defecto. Se recomienda frontarlo con un API Gateway (como Kong o AWS ALB) con:

– Rate limiting para prevenir DoS.

• TLS obligatorio: Usar certificados autofirmados o Let’s Encrypt en el puerto 8080.
• Sandboxing: Restringir el servidor Quack a un namespace de Kubernetes con políticas de Pod Security Admission (PSA).

Detalles técnicos

Arquitectura del protocolo

Quack opera sobre HTTP/1.1 con los siguientes endpoints:

1. Valida la consulta contra el parser de DuckDB 1.5.3+.
2. Optimiza el plan de ejecución para minimizar I/O en S3 (usando read_parquet con buffer_size configurable).
3. Serializa el resultado en JSON, CSV o Parquet según el header Accept.

Formato de datos

Quack usa el formato nativo de DuckDB (.duckdb) para transferir datos entre cliente y servidor, evitando conversiones intermedias como Arrow Flight. Esto implica:

• Ventaja: Menor overhead de serialización (benchmarks internos muestran 2–3× menos CPU que Arrow Flight).
• Limitación: Los clientes deben entender el formato .duckdb (o usar el cliente oficial de DuckDB, que lo maneja transparentemente).

Integración con DuckLake

DuckLake es un catálogo distribuido que permite:

• Sincronización de metadatos entre múltiples servidores Quack.
• Caching distribuido de archivos Parquet en memoria (configurable vía ducklake.cache_size).
• Transacciones multi-usuario para operaciones como CREATE TABLE o INSERT.

Ejemplo de configuración en duckdb.conf:

[ducklake]
enable=true
catalog_path='s3://analytics-data/ducklake'
cache_size=1024  # MB

Rendimiento vs. alternativas

Qué deberían hacer los administradores y equipos técnicos

1. Evaluar la migración desde PostgreSQL para workloads read-heavy

Si tu equipo usa PostgreSQL para análisis ad-hoc con datasets en S3, considera:

• Probar Quack en staging con una réplica de tu dataset.
• Comparar latencias con herramientas como pgbench vs. DuckDB + Quack.
• Planificar la transición: Exportar tablas a Parquet y configurar DuckLake.

Ejemplo de migración parcial:

# Exportar tabla de PostgreSQL a Parquet
psql -c "\COPY (SELECT * FROM large_table) TO '/tmp/large_table.parquet' WITH (FORMAT PARQUET)"

# Cargar en DuckDB + Quack
duckdb -c "LOAD quack; CALL quack_set_port(8080); CALL quack_start();"
duckdb -c "CREATE TABLE large_table AS SELECT * FROM read_parquet('/tmp/large_table.parquet');"

2. Desplegar Quack en Kubernetes (AKS/EKS/GKE)

Usa el Helm chart oficial (disponible desde junio 2026):

helm repo add duckdb https://charts.duckdb.com
helm install duckdb-quack duckdb/quack \
  --set quack.storage.type=s3 \
  --set quack.storage.bucket=my-analytics-bucket \
  --set quack.cacheSizeMB=1024 \
  --set service.type=LoadBalancer

Configura Network Policies para restringir el acceso:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: quack-access
spec:
  podSelector:
    matchLabels:
      app: duckdb-quack
  ingress:
  - from:
    - podSelector:
        matchLabels:
          role: data-analyst
    ports:
    - protocol: TCP
      port: 8080

3. Securizar el despliegue

• Autenticación: Usa OAuth2 Proxy o Kong para validar tokens JWT:

  # Configuración de Kong para Quack
  plugins:
  - name: jwt
    config.key_claim_name: "iss"
    config.claims_to_verify:
    - "iss"
  

• TLS: Genera certificados con cert-manager en Kubernetes:

  kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.13.1/cert-manager.yaml
  kubectl apply -f quack-tls-certificate.yaml
  

• Rate Limiting: Configura Envoy para evitar abusos:

  rate_limit:
    requests_per_unit: 100
    unit: minute
  

4. Optimizar para workloads específicos

• Para notebooks: Usa el cliente oficial con caching local:

  import duckdb

  # Caché de 512MB en el cliente
  conn = duckdb.connect(
    database="http://duckdb-server:8080/quack/v1",
    config={"memory_limit": "512MB"}
  )
  

• Para pipelines ETL: Configura ducklake.cache_size en el servidor para evitar relecturas:

  -- En el servidor Quack
  LOAD ducklake;
  CALL ducklake_set_config('cache_size', '2048');
  

5. Monitorear y escalar

• Métricas: Exposición de /quack/v1/status con endpoints Prometheus:

  # Prometheus scrape config
  - job_name: 'duckdb-quack'
    static_configs:
    - targets: ['duckdb-quack.default.svc.cluster.local:8080']
  

• Escalado horizontal: Usa HPA en Kubernetes para escalar pods basados en consumo de CPU:

  apiVersion: autoscaling/v2
  kind: HorizontalPodAutoscaler
  metadata:
    name: duckdb-quack-hpa
  spec:
    scaleTargetRef:
      apiVersion: apps/v1
      kind: Deployment
      name: duckdb-quack
    minReplicas: 2
    maxReplicas: 10
    metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70
  

Conclusión

Quack marca un antes y después para DuckDB en entornos cloud: elimina la fricción de desplegar un motor SQL embebido como servicio multi-usuario, sin sacrificar rendimiento. Para equipos de DevOps e infraestructura, esto significa:

1. Reducir costos al reemplazar PostgreSQL en workloads read-heavy.
2. Simplificar arquitecturas al centralizar datasets en S3/DuckLake y exponerlos vía HTTP.
3. Escalar horizontalmente con Kubernetes y balanceadores de carga.

La integración con DuckLake en 2026 promete cerrar la brecha entre análisis local y distribuido, permitiendo arquitecturas donde DuckDB funcione como un «SQLite cloud-native». La clave está en empezar con pruebas en entornos controlados, securizar el despliegue y monitorear métricas de rendimiento desde el día uno.