Back to Suitenumerique

La Suite Docs – System & Requirements (2025-06)

docs/system-requirements.md

5.0.07.8 KB
Original Source

La Suite Docs – System & Requirements (2025-06)

1. Quick-Reference Matrix (single VM / laptop)

ScenarioRAMvCPUSSDNotes
Solo dev8 GB415 GBHot-reload + one IDE
Team QA16 GB630 GBRuns integration tests
Prod ≤ 100 live users32 GB8 +50 GB +Scale linearly above this

Memory is the first bottleneck; CPU matters only when Celery or the Next.js build is saturated.

Note: Memory consumption varies by operating system. Windows tends to be more memory-hungry than Linux, so consider adding 10-20% extra RAM when running on Windows compared to Linux-based systems.

2. Development Environment Memory Requirements

ServiceTypical useRationale / source
PostgreSQL1 – 2 GBshared_buffers starting point ≈ 25% RAM (postgresql.org)
Keycloak≈ 1.3 GB70% of limit for heap + ~300 MB non-heap (keycloak.org)
Redis≤ 256 MBEmpty instance ≈ 3 MB; budget 256 MB to allow small datasets (stackoverflow.com)
MinIO2 GB (dev) / 32 GB (prod)Pre-allocates 1–2 GiB; docs recommend 32 GB per host for ≤ 100 Ti storage (min.io)
Django API (+ Celery)0.8 – 1.5 GBEmpirical in-house metrics
Next.js frontend0.5 – 1 GBDev build chain
Y-Provider (y-websocket)< 200 MBLarge 40 MB YDoc called “big” in community thread (discuss.yjs.dev)
Nginx< 100 MBStatic reverse-proxy footprint

Rule of thumb: add 2 GB for OS/overhead, then sum only the rows you actually run.

3. Production Environment Memory Requirements

Production deployments differ significantly from development environments. The table below shows typical memory usage for production services:

ServiceTypical useRationale / notes
PostgreSQL2 – 8 GBHigher shared_buffers and connection pooling for concurrent users
OIDC Provider (optional)VariableAny OIDC-compatible provider (Keycloak, Auth0, Azure AD, etc.) - external or self-hosted
Redis256 MB – 2 GBSession storage and caching; scales with active user sessions
Object Storage (optional)External or self-hostedCan use AWS S3, Azure Blob, Google Cloud Storage, or self-hosted MinIO
Django API (+ Celery)1 – 3 GBProduction workloads with background tasks and higher concurrency
Static Files (Nginx)< 200 MBServes Next.js build output and static assets; no development overhead
Y-Provider (y-websocket)200 MB – 1 GBScales with concurrent document editing sessions
Nginx (Load Balancer)< 200 MBReverse proxy, SSL termination, static file serving

Production Architecture Notes

  • Frontend: Uses pre-built Next.js static assets served by Nginx (no Node.js runtime needed)
  • Authentication: Any OIDC-compatible provider can be used instead of self-hosted Keycloak
  • Object Storage: External services (S3, Azure Blob) or self-hosted solutions (MinIO) are both viable
  • Database: Consider PostgreSQL clustering or managed database services for high availability
  • Scaling: Horizontal scaling is recommended for Django API and Y-Provider services

Minimal Production Setup (Core Services Only)

ServiceMemoryNotes
PostgreSQL2 GBCore database
Django API (+ Celery)1.5 GBBackend services
Y-Provider200 MBReal-time collaboration
Nginx100 MBStatic files + reverse proxy
Redis256 MBSession storage
Total (without auth/storage)≈ 4 GBExternal OIDC + object storage assumed
ToolMinimum
Docker Engine / Desktop24.0
Docker Composev2
Git2.40
Node.js22+
Python3.13+
GNU Make4.4
Kind0.22
Helm3.14
kubectl1.29
mkcert1.4

5. Ports (dev defaults)

PortService
3000Next.js
8071Django
4444Y-Provider
8080Keycloak
8083Nginx proxy
9000/9001MinIO
15432PostgreSQL (main)
5433PostgreSQL (Keycloak)
1081MailCatcher

With fulltext search service

PortService
8081Find (Django)
9200Opensearch
9600Opensearch admin
5601Opensearch dashboard
25432PostgreSQL (Find)

6. Sizing Guidelines

RAM – start at 8 GB dev / 16 GB staging / 32 GB prod. Postgres and Keycloak are the first to OOM; scale them first.

OS considerations: Windows systems typically require 10-20% more RAM than Linux due to higher OS overhead. Docker Desktop on Windows also uses additional memory compared to native Linux Docker.

CPU – budget one vCPU per busy container until Celery or Next.js builds saturate.

Disk – SSD; add 10 GB extra for the Docker layer cache.

MinIO – for demos, mount a local folder instead of running MinIO to save 2 GB+ of RAM.