wiki/Catalogue-Self-Hosted/apps/app-parseable.md

---

title: Parseable created: 2026-06-07 updated: 2026-06-07 type: app tags: [catalogue, logs, observability, analytics, columnar, parquet, s3, rust, kubernetes, docker] confidence: high contested: false sources: [https://selfh.st/apps/?tag=Logs, https://github.com/parseablehq/parseable]

📋 Parseable

L'alternative moderne à Loki : stockage columnar Parquet sur S3, requêtes SQL standard, performances de classe analytique. Conçu pour l'ingestion haut débit et l'analyse long-terme.

📋 Informations Générales

Champ	Valeur
Site web	parseable.com
GitHub	parseablehq/parseable
License	Apache-2.0 (édition communauté) / EE pour features avancées
Langage	Rust
Étoiles GitHub	2.4k ⭐
Dernière MAJ	2026-06-04
Catégorie	[[cat-logs

📝 Description

Parseable est un système d'analytics de logs moderne écrit en Rust qui stocke les événements au format Parquet (columnar) directement sur du stockage objet (S3, MinIO, filesystem). C'est la même approche que les data warehouses modernes (Snowflake, ClickHouse, DuckDB) appliquée aux logs : compression excellente, scan rapide de colonnes spécifiques, et requêtes SQL standard au lieu d'un DSL propriétaire.

L'architecture est volontairement simple : un seul binaire Rust (serveur + UI + storage engine). Pas de cluster state, pas de JVM, pas de ZooKeeper. La stack minimale est : Parseable + (optionnel) Postgres pour les métadonnées + bucket S3/MinIO. Pour démarrer, on peut même tourner sans S3 en mode filesystem local.

Parseable se distingue de app-loki par son approche SQL-native : on interroge les logs avec du vrai SQL (SELECT * FROM logs WHERE level = 'error'), pas avec LogQL. C'est un atout énorme pour les devs data, les analystes, et tous ceux qui maîtrisent SQL mais pas les DSL obscurs.

Public cible : équipes data/analytics, devs qui veulent requêter les logs en SQL, organisations qui ingèrent des millions d'événements/jour, fans de la stack Rust+Parquet+S3.

• ✅ Format Parquet : compression 10-50× vs JSON brut
• ✅ Requêtes SQL standard : pas de DSL propriétaire
• ✅ Stockage S3 natif : scale-to-zero, coûts réduits
• ✅ Écrit en Rust : rapide, faible empreinte
• ✅ Single binary : déploiement trivial
• ✅ Ingestion haut débit : conçu pour des millions d'événements/sec
• ✅ Compatible OpenTelemetry : ingestion OTLP
• ✅ UI web intégrée : exploration SQL, dashboards
• ✅ PostgreSQL optionnel pour métadonnées
• ✅ Prometheus metrics : exposition native
• ⚠️ Communauté jeune (2.4k ⭐) vs app-loki (28k ⭐)
• ⚠️ Versioning : l'API peut évoluer (breaking changes)

🚀 Installation

Option 1 : Docker Compose (single node + MinIO)

# docker-compose.yml
version: '3.8'
services:
  parseable:
    image: parseable/parseable:latest
    container_name: parseable
    restart: unless-stopped
    environment:
      P_ADDR: 0.0.0.0:8000
      P_DATABASE_DRIVER: postgres
      P_DATABASE_URL: postgres://parseable:parseable@postgres:5432/parseable
      P_STAGE_TYPE: s3
      P_STAGE_S3_URL: http://minio:9000
      P_STAGE_S3_BUCKET: parseable-data
      P_STAGE_S3_ACCESS_KEY_ID: parseable
      P_STAGE_S3_SECRET_ACCESS_KEY: parseable-secret-CHANGEME
      P_STAGE_S3_REGION: us-east-1
    depends_on:
      - postgres
      - minio
    ports:
      - "8000:8000"
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.parseable.rule=Host(`logs.example.com`)"
      - "traefik.http.routers.parseable.entrypoints=websecure"
      - "traefik.http.routers.parseable.tls.certresolver=letsencrypt"

  postgres:
    image: postgres:16-alpine
    container_name: parseable-postgres
    restart: unless-stopped
    environment:
      POSTGRES_USER: parseable
      POSTGRES_PASSWORD: parseable
      POSTGRES_DB: parseable
    volumes:
      - postgres-data:/var/lib/postgresql/data

  minio:
    image: minio/minio:latest
    container_name: parseable-minio
    restart: unless-stopped
    command: server /data --console-address ":9001"
    environment:
      MINIO_ROOT_USER: parseable
      MINIO_ROOT_PASSWORD: parseable-secret-CHANGEME
    volumes:
      - minio-data:/data
    ports:
      - "9000:9000"
      - "9001:9001"

volumes:
  postgres-data:
  minio-data:

Option 2 : Single binary (filesystem mode)

curl -L https://github.com/parseablehq/parseable/releases/latest/download/parseable-linux-amd64 -o parseable
chmod +x parseable
P_ADDR=0.0.0.0:8000 ./parseable

Option 3 : Helm (Kubernetes)

helm repo add parseable https://parseablehq.github.io/parseable-helm
helm install parseable parseable/parseable \
  --namespace logging --create-namespace

⚙️ Configuration Initiale

1. Démarrer la stack : docker compose up -d
2. Accéder à l'UI : http://IP:8000 (créer compte admin au premier login)
3. Créer un log stream : UI > Streams > New Stream
4. Ingérer un premier événement :

   curl -X POST http://localhost:8000/api/v1/ingest \
     -H "X-P-Stream: my-app" \
     -H "Authorization: Basic <base64(user:pass)>" \
     -H "Content-Type: application/json" \
     -d '{"timestamp":"2026-06-07T12:00:00Z","level":"info","message":"hello"}'
   

5. Requêter en SQL : UI > Query > SELECT * FROM my-app WHERE level = 'error' LIMIT 100
6. Connecter Grafana : Data Source > PostgreSQL > URL Parseable
7. Configurer la rétention : P_STAGE_OBJECT_STORE_DATA_RETENTION_DAYS=90
8. Activer l'auth : créer plusieurs utilisateurs (RBAC)

🔄 Alternatives

Open Source

• app-loki — Label-based, plus mature
• app-quickwit — Full-text search, Rust aussi
• app-graylog — SIEM complet, plus lourd
• ClickHouse — OLAP columnar (Parseable s'en inspire)
• DuckDB — SQLite-like columnar (parfois utilisé en local)
• SigNoz — APM + logs + traces, OTLP-native

Comparaison Parseable vs autres

Critère	Parseable	Loki	Quickwit	ClickHouse
Langage	Rust	Go	Rust	C++
Format stockage	Parquet (columnar)	Chunks compressés	Tantivy	Native columnar
Langage requête	SQL	LogQL	Lucene-like	SQL
Stockage	S3	S3	S3	Disque
Compression	Excellente	Bonne	Bonne	Excellente
Analytics SQL	✅ Natif	❌	❌	✅ Natif
UI web	✅	❌ (Grafana)	✅	❌ (Grafana)
Maturité	🆕 Jeune	✅ Stable	✅ Stable	✅ Très stable
RAM	~200 Mo	~1 Go	~500 Mo	~2-4 Go
License	Apache-2.0	AGPL-3.0	Apache-2.0	Apache-2.0

Verdict : Parseable est le choix idéal si vous voulez des requêtes SQL standard sur des logs. Plus jeune que app-loki mais l'approche Parquet+SQL est rafraîchissante. Pour Grafana-first, Loki reste imbattable.

Propriétaires (ce que Parseable remplace)

• Datadog Log Management (cher)
• Snowflake (data warehouse) pour l'analyse de logs
• Amazon Athena + S3 (logs ad-hoc)
• ClickHouse Cloud
• Honeycomb (events analytics)

🔐 Sécurité

• ⚠️ Logs = données sensibles : SQL queries = grep puissant = accès large
• ✅ Chiffrement at-rest : LUKS/ZFS + chiffrement S3 (SSE-S3/KMS)
• ✅ Chiffrement in-transit : TLS obligatoire (Traefik en reverse proxy)
• ✅ Authentification : basic auth, JWT, OAuth (Enterprise)
• ✅ RBAC : users, rôles, scopes (read/write/admin par stream)
• ⚠️ Rétention : GDPR/RGPD — P_STAGE_OBJECT_STORE_DATA_RETENTION_DAYS=90
• ✅ PII filtering : ingestion pipeline avec regex/anonymisation
• ✅ Audit log : logs d'accès API, métadonnées dans PostgreSQL
• ✅ Backups chiffrés : app-restic sur bucket S3 + dump PostgreSQL
• ⚠️ SQL injection : limiter les requêtes via RBAC strict

📚 Ressources

• GitHub parseablehq/parseable
• Documentation officielle
• Démo en ligne
• Blog technique

Pages Liées

• cat-logs — Catégorie Logs
• app-loki — Alternative principale
• app-prometheus — Métriques (souvent couplé)
• app-grafana — Visualisation
• app-tempo — Traces
• app-uptime-kuma — Monitoring uptime
• securisation-home-lab — Bonnes pratiques sécurité