---
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](https://www.parseable.com/) |
| **GitHub** | [parseablehq/parseable](https://github.com/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|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)

```yaml
# 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)

```bash
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)

```bash
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** :
   ```bash
   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](https://github.com/parseablehq/parseable)
- [Documentation officielle](https://www.parseable.com/docs)
- [Démo en ligne](https://demo.parseable.com/)
- [Blog technique](https://www.parseable.com/blog)

## 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é