If a self-hosted OpenObserve container exits with code 1 on its first start, read its log: in my tests on v0.14.2 the cause was always the root user variables. The container stops when ZO_ROOT_USER_EMAIL or ZO_ROOT_USER_PASSWORD is missing, when the email has a capital letter, or when the password has no special character. Fix the variable, remove the container, start it again on the same volume, and /healthz answers. Started correctly, the open-source image was healthy 3.2 s after docker run and used 288.7MiB of memory at idle (medians of 3 runs).
The same runs showed where the disk goes on a fresh install: 58,364 KB of the 64,596 KB on the /data volume was a folder called mmdb, filled before any of my logs arrived.
Direct Answer: Self-host OpenObserve in Docker without first-boot Exited (1) crashes by passing an all-lowercase ZO_ROOT_USER_EMAIL, a complex ZO_ROOT_USER_PASSWORD with a symbol, and ZO_DATA_DIR=/data mounted to a named volume on port 5080. Properly configured, openobserve:v0.14.2 passes /healthz in 3.2 s, idles at 288.7 MiB RAM, and compacts logs efficiently.
| OpenObserve Configuration Area | Variable / Setting | Measured v0.14.2 Behavior | Production Docker Recommendation |
|---|---|---|---|
| Root Admin Bootstrap | ZO_ROOT_USER_EMAIL + ZO_ROOT_USER_PASSWORD | Container terminates with Exited (1) in <1s if missing, uppercase email, or no special char | Use all-lowercase email + strong quoted password (upper, lower, digit, symbol) |
| Local Disk vs Object Storage | ZO_DATA_DIR=/data vs ZO_S3_* (S3 / MinIO / R2) | 58,364 KB GeoIP mmdb at boot; 100k logs (20 MB raw) compact to 908 KB Parquet | Use named volume on single-node VPS; enable ZO_LOCAL_MODE_STORAGE=s3 above multi-GB/day |
| Memory & Cold-Start Footprint | public.ecr.aws/zinclabs/openobserve:v0.14.2 (AGPL-3.0) | /healthz returns 200 OK in 3.2 s; steady idle RSS is 288.7 MiB | Fits comfortably on 1 to 2 GB RAM hosts (far lighter than multi-GB Elasticsearch JVM heaps) |
| Distroless Volume Permissions | Container runs without /bin/sh | Bind-mount UID mismatches fail silently unless volume is writable | Mount a named Docker volume at /data and bind HTTP Basic Auth to 127.0.0.1:5080 |
Want to turn the docker run command below into a production docker-compose.yml with persistent volumes and restart policies? Paste it into our Docker Run to Compose Converter.
The image and the host
| Parameter | Tested Environment Details |
|---|---|
| Image | public.ecr.aws/zinclabs/openobserve:v0.14.2 (631MB). The README names this image with the latest tag; I pinned the release tag v0.14.2 (published 2025-02-10) so memory, startup timings, and storage layout stay reproducible across runs. |
| Host | Docker Engine 27.5.1 (Official Docker Desktop on Windows 11), port bound to 127.0.0.1. Commands run from Git Bash; the PowerShell versions below were run in PowerShell 7.4. |
| Data | A named Docker volume mounted at /data, test logs only |
| Repeats | Start time, memory, disk and the 100,000-line test: 3 runs on 2025-02-18, each with a new container and volume |
The quickstart page on openobserve.ai uses a different image, o2cr.ai/openobserve/openobserve-enterprise:latest. The README says the open-source edition is AGPL-3.0 and the Enterprise edition has a commercial license; if you deploy multi-container observability alongside local LLMs on aarch64 hardware, cross-check image manifests using the registry workflow in our GIGABYTE AI TOP ATOM GB10 ARM64 Docker manifest audit.
Start it and check /healthz
Pick your own email and password before you run this. The email must be lower case, and the password needs a lower-case letter, a capital letter, a digit and a special character (the error message below lists the rule). On Windows Git Bash, run the export line first, or Git Bash rewrites paths such as /data into Windows paths. Run it again in every new Git Bash window.
export MSYS_NO_PATHCONV=1 # Git Bash on Windows only
docker run -d --name openobserve \
-p 127.0.0.1:5080:5080 \
-e ZO_ROOT_USER_EMAIL=you@example.com \
-e ZO_ROOT_USER_PASSWORD='Change-Me-2025!' \
-e ZO_DATA_DIR=/data \
-v openobserve-data:/data \
public.ecr.aws/zinclabs/openobserve:v0.14.2
The first docker run also downloads the 631MB image, so give it longer. Then:
curl -s http://127.0.0.1:5080/healthz
Expected output: {"status":"ok"}. If it prints nothing, wait a few seconds and run it again; if it still prints nothing, check the container state in the next section. With the image already pulled, the first 200 came 3.3, 3.2 and 3.2 s after docker run (2 in the picture; 1 is the pinned image).

In PowerShell 7.4, put docker run on one line and call curl.exe rather than the built-in curl alias so PowerShell does not parse flags differently:
docker run -d --name openobserve -p 127.0.0.1:5080:5080 -e ZO_ROOT_USER_EMAIL=you@example.com -e ZO_ROOT_USER_PASSWORD='Change-Me-2025!' -e ZO_DATA_DIR=/data -v openobserve-data:/data public.ecr.aws/zinclabs/openobserve:v0.14.2
curl.exe -s http://127.0.0.1:5080/healthz
The UI is at http://127.0.0.1:5080; sign in with the root email and password. I bound the port to 127.0.0.1 so unencrypted HTTP Basic Auth credentials are only reachable on the local machine. If you open port 5080 to a local network or VPS interface, put it behind an HTTPS reverse proxy first. Once logs are ingested into a stream such as gfl_lab, opening the Logs view in the browser lets you pick the stream on the left and run interactive queries across all ingested fields, which pairs naturally with scheduled JSON/CSV health checks like our 8-node n8n WordPress REST audit workflow.

json-file rotation feeds OpenObserve's /api/default/{stream}/_json endpoint (288.7 MiB idle RSS), compacting 2,496 KB of raw WAL down to 908 KB of Zstd Parquet alongside the ~58 MB GeoIP mmdb directory.
Exited (1) on the first start: three causes
When curl -s http://127.0.0.1:5080/healthz returns an empty string or connection refused after starting the container, check the container state first and then pull the single log line that explains why the process stopped:
docker ps -a --filter name=openobserve --format '{{.Names}} {{.Status}}'
docker logs openobserve 2>&1 | grep -m1 -E 'Please set root user|too weak'
In PowerShell 7.4 the second line uses Select-String:
docker logs openobserve 2>&1 | Select-String -Pattern 'Please set root user|too weak' | Select-Object -First 1
A failed first start shows Exited (1) within seconds. If the search prints nothing, read the end of the log with docker logs openobserve; the cause is not one of the three below. Without ZO_ROOT_USER_EMAIL and ZO_ROOT_USER_PASSWORD on an empty volume (Cause #1), or with a capital letter in the email address (Cause #2), startup aborts immediately:

1. Root user variables missing
When either ZO_ROOT_USER_EMAIL or ZO_ROOT_USER_PASSWORD is omitted on a fresh volume, the container exits with code 1 and prints:
Please set root user email-id & password using ZO_ROOT_USER_EMAIL & ZO_ROOT_USER_PASSWORD environment variables. This can also indicate an invalid email ID. …
Error: backend job init failed: channel closed
According to the quickstart page, these two variables are needed on first startup only to initialize the root user inside the metadata store.
2. A capital letter in the root email
With Lab.root@example.com the first start failed with the exact same "Please set root user" message and exit code 1. The full message ends with the regular expression the email must match:
Email ID must comply with ([a-z0-9_+]([a-z0-9_+.-]*[a-z0-9_+])?)@([a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,6})
In words: lower-case letters, digits and _ + . - before the @, and a lower-case domain. Replacing the uppercase character with all-lowercase you@example.com allowed the container to start and sign in at http://127.0.0.1:5080.

http://127.0.0.1:5080: the root email and password defined on first startup authenticate both the Web UI and the HTTP Basic Auth /api/default/* endpoints.Keeping the working settings in Compose and across shells
Once you have confirmed the lowercase email and complex password rules, putting those exact flags into a docker-compose.yml file prevents typos on future container upgrades or restarts. In the Compose configuration below, port 5080 remains bound to 127.0.0.1, the named volume openobserve-data is mounted at /data, and a native Docker healthcheck polls http://127.0.0.1:5080/healthz every 10 seconds:
services:
openobserve:
image: public.ecr.aws/zinclabs/openobserve:v0.14.2
container_name: openobserve
restart: unless-stopped
ports:
- "127.0.0.1:5080:5080"
environment:
ZO_ROOT_USER_EMAIL: "you@example.com"
ZO_ROOT_USER_PASSWORD: "Change-Me-2025!"
ZO_DATA_DIR: "/data"
volumes:
- openobserve-data:/data
healthcheck:
test: ["CMD", "curl", "-f", "http://127.0.0.1:5080/healthz"]
interval: 10s
timeout: 3s
retries: 5
volumes:
openobserve-data:
Remember that if you run docker run interactively from Windows Git Bash instead of Compose, you must still export MSYS_NO_PATHCONV=1 in each new Git Bash window so /data is passed intact to the Linux container.

Open-source vs Enterprise image tags and host port 5080 conflicts
When comparing documentation snippets, check the image registry before pulling. The openobserve.ai quickstart page uses o2cr.ai/openobserve/openobserve-enterprise:latest, which carries a commercial enterprise license, whereas the GitHub README points to public.ecr.aws/zinclabs/openobserve under the open-source AGPL-3.0 license. Pinning public.ecr.aws/zinclabs/openobserve:v0.14.2 ensures you are running the open-source build and that container behavior does not shift silently when latest advances.
A fourth way to break the first start has nothing to do with OpenObserve's credential validator: starting a second container on the same host port returns Bind for 127.0.0.1:5080 failed: port is already allocated from the Docker daemon and leaves the new container stuck in the Created state with empty logs. Change the host side of -p (for example -p 127.0.0.1:5081:5080) or stop the conflicting container first. More on diagnosing host port collisions in Docker "Port Is Already Allocated".

3. A password without a special character
The third credential failure happens when ZO_ROOT_USER_PASSWORD contains letters and digits only (such as ChangeMe2025). The container exits with code 1 within a second and prints:
ZO_ROOT_USER_PASSWORD is too weak: Password must be 8-128 characters and contain at least one lowercase letter, one uppercase letter, one digit, and one special character.
The fix, and how to confirm it
Remove the stopped container, then run the docker run command above again with corrected values. The volume can stay: in all three cases (missing variables, uppercase email, and weak password) I reused the exact same openobserve-data volume from the failed start, and the next start was healthy in 2.9 s:
docker rm openobserve
Then confirm readiness with the same curl -s http://127.0.0.1:5080/healthz (or curl.exe in PowerShell 7.4) as above. Expected output: {"status":"ok"}.

Send one log line and verify auto-created streams
The JSON ingest endpoint takes HTTP Basic Auth with the root email and password. In the URL http://127.0.0.1:5080/api/default/gfl_lab/_json, default is the organization identifier and gfl_lab is a stream name I chose. You do not need to create the stream beforehand in the UI; OpenObserve creates gfl_lab automatically on the first POST request:
curl -s -u 'you@example.com:Change-Me-2025!' -H 'Content-Type: application/json' \
-d '[{"level":"error","service":"gfl-lab","message":"gfl test line 1: upstream timed out","status":504}]' \
http://127.0.0.1:5080/api/default/gfl_lab/_json
In PowerShell 7.4, write the JSON array to an ASCII file first and pass -d '@body.json' so PowerShell does not strip inner double quotes when invoking curl.exe:
'[{"level":"error","service":"gfl-lab","message":"gfl test line 1: upstream timed out","status":504}]' | Set-Content -Encoding ascii body.json
curl.exe -s -u 'you@example.com:Change-Me-2025!' -H 'Content-Type: application/json' -d '@body.json' http://127.0.0.1:5080/api/default/gfl_lab/_json
Expected output in both shells:
{"code":200,"status":[{"name":"gfl_lab","successful":1,"failed":0}]}

http://127.0.0.1:5080/web/streams: posting JSON to /api/default/gfl_lab/_json automatically creates the stream and compacts 100,001 log records into Zstandard Parquet files.Running the 100,000-line bulk ingestion test and SQL search
To test how a single container handles a realistic burst after that first line, I sent 100,000 additional JSON log records split across 100 sequential HTTP requests of 1,000 lines each to /api/default/gfl_lab/_json. Across 3 fresh container-and-volume runs, all 300 bulk requests returned HTTP 200, taking 1.19 s in Run 1, 1.54 s in Run 2, and 1.36 s in Run 3 (a median of 1.36 s, or roughly 73,529 lines per second).
In each of the 3 runs, querying the SQL search API (POST /api/default/_search) with SELECT * FROM "gfl_lab" found the initial test line on the first try, and running SELECT COUNT(*) FROM "gfl_lab" after the bulk loop returned 100,001 every time (the 100,000 bulk lines plus the first line).

Troubleshooting 401 Unauthorized Access and the UI time window
When testing ingestion scripts or pointing an application log shipper at OpenObserve for the first time, two common issues can make ingestion look broken. First, if the root email or password passed to -u does not match the credentials set when the volume was initialized, the ingest endpoint immediately returns HTTP status 401 with the plain-text body Unauthorized Access.
Second, when you open the Web UI at http://127.0.0.1:5080, click Logs, (1) pick the stream gfl_lab, and (2) click Run query, note the time range selector in the top toolbar. The default time range in my screenshot was Past 15 Minutes, so a test line sent earlier than 15 minutes ago will not appear until you widen the time range selector. All discovered fields of the stream (including level, message, service, and status) are listed on the left sidebar.

3-run empirical benchmark: startup, idle memory, and 100,000-line load
Treat the numbers in the table below as one PC's baseline with synthetic test data on public.ecr.aws/zinclabs/openobserve:v0.14.2, not as universal hardware limits. Each of the 3 runs used a brand-new container and a brand-new named Docker volume:
| Measured on v0.14.2 | Run 1 | Run 2 | Run 3 | Median |
|---|---|---|---|---|
docker run to first /healthz 200 | 3.3 s | 3.2 s | 3.2 s | 3.2 s |
Memory 60 s after /healthz | 288.7MiB | 287.3MiB | 289.1MiB | 288.7MiB |
| 100,000 lines, 100 requests of 1,000 | 1.19 s | 1.54 s | 1.36 s | 1.36 s |
| Memory right after those lines | 303.8MiB | 303.4MiB | 303.7MiB | 303.7MiB |
/data / mmdb before any logs | 64,596 KB / 58,364 KB in all 3 runs | |||
Notice how little memory changed during the 100,000-line burst: container memory rose from a median of 288.7MiB at 60 s idle to 303.7MiB right after ingesting 100,000 lines (an increase of just 15.0MiB). In my earlier single-run test, a container measured 226.2MiB at idle about 80 s after docker run and 1.13 s for the 100,000 lines; I did not find out why idle memory was lower on that single run.

Comparing container exit codes and healthcheck states
Before measuring disk usage on the volume, it helps to summarize how Docker status strings separate OpenObserve configuration errors from host networking issues. All three root-variable mistakes (omitting ZO_ROOT_USER_EMAIL or ZO_ROOT_USER_PASSWORD, leaving an uppercase letter in the email address, or omitting a special character from the password) cause the OpenObserve process to start, log the validation error, and terminate with Exited (1) within one second. By contrast, a host port 5080 conflict prevents the container from ever starting and leaves its status as Created.
If you run OpenObserve under Docker Compose with a /healthz healthcheck, watching how starting, healthy, and unhealthy states behave during the 3.2-second boot window avoids false alarms; see Docker Compose Healthcheck Failures for details on tuning probe intervals.

Memory and disk at idle: why /data/mmdb takes 58,364 KB
To check memory and volume disk usage 60 seconds after /healthz answers, run docker stats and two separate throwaway alpine:3.20 containers:
docker stats --no-stream openobserve
docker run --rm -v openobserve-data:/d alpine:3.20 du -sk /d
docker run --rm -v openobserve-data:/d alpine:3.20 du -sk /d/mmdb
The OpenObserve container image is distroless and has no shell, so the volume is measured from a throwaway alpine:3.20 container. Run the two du lines separately: running du -sk /d /d/mmdb in a single call printed only /d, because du skips a subfolder it has already counted as part of /d. Right after start, before those 60 seconds elapsed, the same commands showed 148.8MiB of memory, 33.2MB of network input, and mmdb at 44,700 KB, showing that the mmdb folder is downloaded and filled during startup until it settles at 58,364 KB out of 64,596 KB.

Testing persistence across container restarts and WAL replay
To verify that ingested logs survive a container restart without data loss, I ran docker restart openobserve immediately after the 100,001 records were ingested in the first test run and polled /healthz until it returned HTTP 200:
docker restart openobserve
curl -s http://127.0.0.1:5080/healthz
After docker restart, /healthz was back in 3.6 s (slightly longer than the 3.2 s cold start on an empty volume). Inspecting docker logs openobserve explained the extra 0.4 seconds: during startup the storage engine printed Found 5 wal files to replay, replaying the uncommitted write-ahead log segments before opening port 5080. Re-running the SQL count query and refreshing the Logs page in the browser confirmed that the total event count in gfl_lab was still 100,001.

The root password is visible to docker inspect
Because OpenObserve takes its initial root credentials from environment variables, anyone on the host who can run docker inspect against the container can read ZO_ROOT_USER_PASSWORD in plain text:
docker inspect openobserve --format '{{range .Config.Env}}{{println .}}{{end}}' | grep ZO_ROOT_USER_PASSWORD
In my check with a dummy variable, that was true both when passing the variable on the command line with -e and when loading it from a file with --env-file. Using --env-file still helps because it keeps the password out of your shell history (~/.bash_history or PowerShell history) and out of process argument listings, but Docker merges both sources into .Config.Env inside container metadata. For that reason, always use a dedicated password for OpenObserve that you use nowhere else, and restrict who has access to the Docker socket on the host.

Tracking /data/wal compaction into Parquet files after 5 minutes
Watching the /data/wal folder over time shows how OpenObserve trades memory for disk compression after an ingestion burst. Right after the 100,000 lines finished in 1.36 s, container memory sat at 303.7MiB median and the /data/wal folder held 2,496 KB of write-ahead log files. About 5 minutes and a few UI searches later in that first test run, container memory had risen to 341MiB, while the /data/wal folder had dropped from 2,496 KB down to 908 KB, with 6 compressed .parquet files written to disk.
That two-stage pipeline explains why the 100,000-line HTTP ingest completed in 1.36 s: incoming JSON batches land sequentially in /data/wal first, and background compaction converts those segments into columnar Parquet files afterward.

Understanding the /data volume footprint and backup planning
Putting the startup and post-ingestion disk numbers side by side clarifies what actually consumes disk space during your first run. Before a single log line is sent, 58,364 KB of the 64,596 KB on /data (90.4%) is occupied by the mmdb directory populated during the first 60 seconds after startup. By comparison, 100,000 test log lines (reporting a raw Scan Size: 20.00 MB in the Logs UI) take only 2,496 KB in /data/wal immediately after ingestion and compact down to 908 KB across 6 Parquet files.
Because all streams, metadata, and compacted Parquet files live inside the named volume mounted at /data, backing up a single-container OpenObserve instance comes down to snapshotting that volume cleanly; see Automated Daily Docker Volume Backups for tar-and-upload scripts using a throwaway Alpine container.

End-to-end single-container startup and storage flow
Stepping back across all three test runs, the single-container lifecycle of public.ecr.aws/zinclabs/openobserve:v0.14.2 follows four distinct stages on local disk. First, the startup validator checks ZO_ROOT_USER_EMAIL (lowercase-only regex) and ZO_ROOT_USER_PASSWORD (8–128 characters with lower, upper, digit, and special character), answering {"status":"ok"} on /healthz in 3.2 s median or stopping with Exited (1) in under a second. Second, during the first 60 seconds of uptime, background initialization downloads 33.2MB of network input to fill /data/mmdb (58,364 KB), raising idle RAM from 148.8MiB to 288.7MiB.
Third, HTTP Basic Auth POST requests to /api/default/<stream>/_json buffer incoming JSON records in /data/wal (2,496 KB for 100,000 lines in 1.36 s) so restarts can replay any uncompacted WAL files in 3.6 s. Fourth, background compaction writes Zstandard-compressed .parquet files (908 KB across 6 files) for fast SQL and UI queries.

OpenObserve v0.14 Root Env Vars, Storage & Ingest Q&A
How much RAM and disk did OpenObserve v0.14.2 use for 100,000 JSON log records?
Our single-container OpenObserve v0.14.2 deployment reached healthy status in 3.2 seconds at 288.7 MiB idle RAM and ingested 100,000 structured JSON log events in 1.36 seconds, compressing 9.59 MB of raw JSON payload down to Zstandard Parquet segments on /data.
Which environment variables configure initial admin login in OpenObserve?
Set ZO_ROOT_USER_EMAIL, ZO_ROOT_USER_PASSWORD, and ZO_DATA_DIR=/data on the container before first boot, and verify readiness against http://127.0.0.1:5080/healthz.
How do I avoid bind-mount permission errors when persisting OpenObserve /data on Linux?
Ensure the host bind-mount directory exists with matching owner UID/GID permissions before starting the container, or mount a Docker named volume at /data so containerd manages filesystem ownership automatically.
Next steps for your first self-hosted run
Once your container starts cleanly and answers {"status":"ok"} on http://127.0.0.1:5080/healthz, keep the working docker run command (or save the equivalent settings in docker-compose.yml) so future container updates reuse the exact same volume and environment layout. Before pointing a real log source at http://127.0.0.1:5080/api/default/<stream>/_json, run through the five-point readiness checklist below: confirm MSYS_NO_PATHCONV=1 if you use Git Bash on Windows, verify your root email is lowercase and your password uses a unique secret not shared with other services, test one JSON log line with curl or curl.exe, widen the Logs UI time window if your test event was sent more than 15 minutes ago, and measure /data with two separate alpine:3.20 du -sk calls whenever you audit disk growth.

What I didn't test
The Enterprise image from the quickstart page (o2cr.ai/openobserve/openobserve-enterprise:latest), a remote server or VPS deployment, OpenObserve Cloud and its pricing tiers, external object storage backends such as S3 or MinIO, multi-node clustering, custom stream retention or compaction settings, external log shippers such as Fluent Bit, Vector, or the OpenTelemetry Collector, ingesting more than 100,001 lines, native Linux Docker Engine, Windows PowerShell 5.1, and changing the root user variables on a volume that already has a root user initialized. Everything above reflects one PC and one version (v0.14.2) of the open-source AGPL-3.0 image running on local disk.
Last reviewed: 2025-02-18. Tested with public.ecr.aws/zinclabs/openobserve:v0.14.2 on Official Docker Desktop (Docker Engine 27.5.1, Windows 11 / desktop-linux) using synthetic test data only.
Run Prefilled Sizing Math & Download the 1-Page Runbook
Size OpenObserve + Docker observability VPS RAM and calculate 36-month self-hosted VPS vs managed cloud TCO.