You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@streampipes.apache.org by ri...@apache.org on 2026/10/27 21:16:48 UTC

(streampipes) 01/01: feat: Add all-in-one-installer with demo data

This is an automated email from the ASF dual-hosted git repository.

dominikriemer pushed a commit to branch add-all-in-one-installer-with-demo-data
in repository https://gitbox.apache.org/repos/asf/streampipes.git

commit 788d9893bfbb7dc77c92923bbf24a826887da7b4
Author: Dominik Riemer <do...@gmail.com>
AuthorDate: Tue Oct 27 22:16:27 2026 +0100

    feat: Add all-in-one-installer with demo data
---
 .github/workflows/build.yml                  |  12 +
 README.md                                    |  21 +
 installer/all-in-one/Dockerfile              | 108 ++++
 installer/all-in-one/README.md               | 142 ++++++
 installer/all-in-one/bin/entrypoint.sh       |  92 ++++
 installer/all-in-one/bin/seed-demo.py        | 709 +++++++++++++++++++++++++++
 installer/all-in-one/bin/start-backend.sh    |  36 ++
 installer/all-in-one/bin/start-extensions.sh |  31 ++
 installer/all-in-one/bin/start-nats.sh       |  33 ++
 installer/all-in-one/nginx/streampipes.conf  |  87 ++++
 installer/all-in-one/supervisord.conf        | 109 ++++
 installer/upgrade_versions.sh                |   5 +
 12 files changed, 1385 insertions(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 8de4627a5c..a52085de78 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -125,3 +125,15 @@ jobs:
           platforms: linux/amd64,linux/arm64/v8
           push: true
           tags: ${{ env.DOCKERHUB_APACHE_REPO }}/extensions-iiot-minimal:${{ env.MVN_VERSION }}
+
+      # Single-container demo image; copies the images pushed above, so it must run last.
+      - name: Build and Push Docker Image all-in-one
+        uses: docker/build-push-action@c3c9e263c25d99ce0380d002d59b67737d91b0dc
+        with:
+          context: ./installer/all-in-one
+          platforms: linux/amd64,linux/arm64/v8
+          push: true
+          build-args: |
+            SP_VERSION=${{ env.MVN_VERSION }}
+            SP_DOCKER_REGISTRY=${{ env.DOCKERHUB_APACHE_REPO }}
+          tags: ${{ env.DOCKERHUB_APACHE_REPO }}/all-in-one:${{ env.MVN_VERSION }}
diff --git a/README.md b/README.md
index f63e50f4b3..368520afdc 100644
--- a/README.md
+++ b/README.md
@@ -45,6 +45,26 @@
   Apache StreamPipes helps teams connect industrial data sources, build real-time streaming pipelines, explore time-series data, and deliver live operational insights without requiring many different systems or custom code for every use case.
 </p>
 
+## Try it in 60 seconds
+
+No hardware, no setup wizard: one container runs the whole platform with a simulated machine already streaming data.
+
+```bash
+docker run --rm -p 80:80 apachestreampipes/all-in-one:0.99.0-SNAPSHOT
+```
+
+Then open [http://localhost](http://localhost) and sign in with `admin@streampipes.apache.org` / `admin`.
+The container seeds a small water works with simulated machines: click **Dashboards** in the left menu and
+open **Plant Overview** to watch live charts of the intake pumps, the pressure line and the storage tanks
+(they refresh every five seconds). The home page shows the plant's sites on a map, **Assets** holds the
+plant structure with links to everything, **Pipelines** has the persist and analytics pipelines, and the
+simulated machines are listed under **Adapters**. The first start takes about a minute while the services
+boot and the demo is seeded.
+
+The image bundles CouchDB, NATS, InfluxDB, the core, the IIoT extensions and the UI, and is meant for
+trying things out. For a real installation use the Compose installer below. Details, options and how to
+build the image yourself are in [installer/all-in-one](installer/all-in-one).
+
 ## Overview
 
 Apache StreamPipes is an end-to-end industrial IoT data platform that combines a graphical user interface for domain experts with an extensible framework for developers. It enables teams to connect industrial data sources, process real-time data streams, store historical data, and build data-driven applications on top of industrial equipment.
@@ -89,6 +109,7 @@ As a ready-to-use platform, StreamPipes enables users to implement industrial Io
 
 The fastest way to get a full installation with extensions is to use one of the Docker-based installers:
 
+- [StreamPipes all-in-one](installer/all-in-one) for a single-container demo with simulated data (see [Try it in 60 seconds](#try-it-in-60-seconds))
 - [StreamPipes Compose](installer/compose) for container-based deployment
 - [StreamPipes CLI](installer/cli) for developers who want to extend StreamPipes (**deprecated**)
 - [StreamPipes k8s](installer/k8s) for cluster-based operation
diff --git a/installer/all-in-one/Dockerfile b/installer/all-in-one/Dockerfile
new file mode 100644
index 0000000000..0652a5f09e
--- /dev/null
+++ b/installer/all-in-one/Dockerfile
@@ -0,0 +1,108 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Apache StreamPipes all-in-one demo image.
+#
+# Bundles CouchDB, NATS, InfluxDB, the StreamPipes core, the IIoT extensions
+# service and the UI (nginx) into a single container supervised by
+# supervisord. It reuses the published StreamPipes images and the same
+# third-party images as installer/compose/docker-compose.yml; nothing is
+# rebuilt here. Only port 80 is exposed.
+
+ARG SP_VERSION=0.99.0-SNAPSHOT
+ARG SP_DOCKER_REGISTRY=apachestreampipes
+ARG COUCHDB_VERSION=3.4.3
+ARG INFLUXDB_VERSION=2.6
+ARG NATS_VERSION=2.11
+
+FROM ${SP_DOCKER_REGISTRY}/backend:${SP_VERSION} AS backend
+FROM ${SP_DOCKER_REGISTRY}/extensions-all-iiot:${SP_VERSION} AS extensions
+FROM ${SP_DOCKER_REGISTRY}/ui:${SP_VERSION} AS ui
+FROM eclipse-temurin:25-jre-jammy AS jre
+FROM influxdb:${INFLUXDB_VERSION} AS influxdb
+FROM nats:${NATS_VERSION} AS nats
+
+# CouchDB is the only service that cannot be copied as a static binary, so its
+# image (Debian) is the base; everything else is layered on top of it. 3.4.x is
+# the first CouchDB image on a Debian release that still receives updates
+# (the Compose installer's 3.3.1 is built on end-of-life bullseye).
+FROM couchdb:${COUCHDB_VERSION}
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends nginx-light supervisor python3 \
+    && rm -rf /var/lib/apt/lists/* /etc/nginx/sites-enabled/default \
+    && useradd --system --user-group --home-dir /var/lib/influxdb2 --shell /usr/sbin/nologin influxdb \
+    && mkdir -p /var/lib/influxdb2 /etc/influxdb2 /var/lib/streampipes /opt/streampipes/bin \
+    && chown influxdb:influxdb /var/lib/influxdb2 /etc/influxdb2
+
+# Java runtime (Temurin builds run on this base's glibc)
+COPY --from=jre /opt/java/openjdk /opt/java/openjdk
+
+# NATS
+COPY --from=nats /nats-server /usr/local/bin/nats-server
+
+# InfluxDB, including the upstream entrypoint that performs the initial setup
+COPY --from=influxdb /usr/local/bin/influxd /usr/local/bin/influx /usr/local/bin/gosu /usr/local/bin/yq /usr/local/bin/
+COPY --from=influxdb /entrypoint.sh /opt/streampipes/bin/influxdb-entrypoint.sh
+COPY --from=influxdb /etc/defaults/influxdb2/config.yml /etc/defaults/influxdb2/config.yml
+
+# StreamPipes core and extensions (exploded Spring Boot layers)
+COPY --from=backend /BOOT-INF /opt/streampipes/backend/BOOT-INF
+COPY --from=backend /META-INF /opt/streampipes/backend/META-INF
+COPY --from=backend /org /opt/streampipes/backend/org
+COPY --from=extensions /BOOT-INF /opt/streampipes/extensions/BOOT-INF
+COPY --from=extensions /META-INF /opt/streampipes/extensions/META-INF
+COPY --from=extensions /org /opt/streampipes/extensions/org
+
+# StreamPipes UI
+COPY --from=ui /usr/share/nginx/html /usr/share/nginx/html
+
+COPY supervisord.conf /etc/supervisor/supervisord.conf
+COPY nginx/streampipes.conf /etc/nginx/conf.d/streampipes.conf
+COPY bin/ /opt/streampipes/bin/
+RUN chmod 755 /opt/streampipes/bin/*
+
+ENV JAVA_HOME=/opt/java/openjdk \
+    PATH=/opt/java/openjdk/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin \
+    INFLUXD_INIT_PORT=9999 \
+    INFLUXD_INIT_PING_ATTEMPTS=600 \
+    INFLUX_CONFIGS_PATH=/etc/influxdb2/influx-configs \
+    INFLUXD_NATS_PORT=4223 \
+    INFLUXD_REPORTING_DISABLED=true \
+    DOCKER_INFLUXDB_INIT_CLI_CONFIG_NAME=default \
+    DOCKER_INFLUXDB_INIT_MODE=setup \
+    DOCKER_INFLUXDB_INIT_USERNAME=admin \
+    DOCKER_INFLUXDB_INIT_ORG=sp \
+    DOCKER_INFLUXDB_INIT_BUCKET=sp \
+    COUCHDB_USER=admin \
+    SP_HOST=localhost \
+    SP_CORE_HOST=localhost \
+    SP_CORE_PORT=8030 \
+    SP_COUCHDB_HOST=localhost \
+    SP_COUCHDB_USER=admin \
+    SP_TS_STORAGE_HOST=localhost \
+    SP_TS_STORAGE_ORG=sp \
+    SP_TS_STORAGE_BUCKET=sp \
+    SP_NATS_HOST=localhost \
+    SP_NATS_PORT=4222 \
+    SP_PRIORITIZED_PROTOCOL=nats \
+    SP_DEMO_SEED=true
+
+EXPOSE 80
+
+HEALTHCHECK --interval=10s --timeout=5s --start-period=180s --retries=3 \
+    CMD curl -fs http://localhost/streampipes-backend/api/v2/setup/configured | grep -q '"configured":true' || exit 1
+
+ENTRYPOINT ["tini", "--", "/opt/streampipes/bin/entrypoint.sh"]
diff --git a/installer/all-in-one/README.md b/installer/all-in-one/README.md
new file mode 100644
index 0000000000..24bf8ff232
--- /dev/null
+++ b/installer/all-in-one/README.md
@@ -0,0 +1,142 @@
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~    http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  ~
+  -->
+# StreamPipes All-in-One - Try it in 60 seconds
+
+A single Docker image that runs the complete Apache StreamPipes platform in one container and
+seeds a demo scenario on first start, so you see live machine data without connecting any hardware.
+
+**Current version:** 0.99.0-SNAPSHOT
+
+> **NOTE**: This image is made for trying StreamPipes out on a laptop, demos and workshops. It
+> runs every service in one container and keeps its data in the container. For anything you want
+> to keep, use the [Compose installer](../compose) or the [Kubernetes chart](../k8s).
+
+## Run it
+
+```bash
+docker run --rm -p 80:80 apachestreampipes/all-in-one:0.99.0-SNAPSHOT
+```
+
+1. Open [http://localhost](http://localhost). While the services boot (about a minute) the UI shows a
+   progress screen that moves on by itself.
+2. Sign in with **`admin@streampipes.apache.org`** and password **`admin`**.
+3. Click **Dashboards** in the left menu and open **Plant Overview**. The charts refresh every five seconds.
+
+## The demo scenario
+
+The seed builds a small water works with two sites. Every machine is a *machine data simulator*
+adapter that emits one event per second; the simulator alternates between a normal and an alarm
+phase every 30 seconds, which is what the alarm pipelines pick up.
+
+| Site | Asset | Simulated machine (adapter) | Dataset |
+| --- | --- | --- | --- |
+| Riverside Water Works, area Intake | Intake Pump Station with pumps P-101 to P-103 | *Intake Pumps*: flow, temperature, density of three pumps | `intake_pumps` |
+| Riverside Water Works, area Treatment | Main Pressure Line | *Main Line Pressure*: two pressure sensors | `main_line_pressure` |
+| Riverside Water Works, area Storage | Clear Water Tank T-200 | *Clear Water Tank*: level and overflow flag | `clear_water_tank` |
+| Hillside Reservoir, area Reservoir | Hillside Reservoir Basin | *Reservoir Level*: two level sensors | `reservoir_level` |
+
+| Where to click | What you find |
+| --- | --- |
+| **Home** | Counters, the asset table and a map with both sites (toggle *Map*) |
+| **Dashboards** | *Plant Overview*, *Intake Pump Station* and *Water Storage* |
+| **Charts** | 11 charts: time series per machine, a temperature gauge, a tank value card, a fault-flag heatmap and two event tables |
+| **Pipelines** | Four *Persist ...* pipelines plus *Pump Overheating Detection* (numerical filter, temperature > 80), *Pressure Smoothing* (moving average) and *Tank Overflow Events* (boolean filter) |
+| **Datasets** | The four machine datasets and `pump_overheating`, `main_line_pressure_smoothed`, `tank_overflow_events` |
+| **Assets** | The four assets with their site, area, labels (*Demo*, *Critical asset*) and links to adapters, data streams, pipelines, datasets, charts and dashboards |
+| **Adapters** | The four simulated machines, already running |
+
+Everything else works as in a regular installation: add further adapters, build pipelines in the
+editor or explore the data. Stop the container with `Ctrl+C` (or `docker stop`). With `--rm` all
+data is discarded; drop `--rm` to keep the container and start it again later with `docker start`.
+
+## Requirements
+
+- Docker (Docker Desktop on macOS and Windows). The image is built for `linux/amd64` and `linux/arm64`.
+- Roughly 4 GB of memory available to Docker; the container runs two JVMs plus three databases.
+- Port 80 free on the host, or map another one: `-p 8080:80` and open `http://localhost:8080`.
+
+## What is inside
+
+| Process | Origin | Port (inside the container) |
+| --- | --- | --- |
+| CouchDB | `couchdb:3.4.3`, the base image | 5984 |
+| InfluxDB | `influxdb:2.6` binaries and setup entrypoint | 8086 |
+| NATS | `nats` server binary, token authentication enabled | 4222 |
+| StreamPipes core | `apachestreampipes/backend` | 8030 |
+| IIoT extensions | `apachestreampipes/extensions-all-iiot` | 8090 |
+| UI | `apachestreampipes/ui` static files served by nginx | **80** (the only exposed port) |
+| Demo seed | `bin/seed-demo.py`, runs once per start and builds the scenario above | - |
+
+The StreamPipes, InfluxDB and NATS images are the ones `../compose/docker-compose.yml` uses; CouchDB is
+3.4.x because the 3.3.1 image is built on a Debian release that no longer receives packages. `supervisord`
+starts and watches the processes (`supervisord.conf`); the start scripts in `bin/` wait for their
+dependencies. All services talk to each other over `localhost`, which is why the StreamPipes
+environment variables (`SP_COUCHDB_HOST`, `SP_TS_STORAGE_HOST`, `SP_NATS_HOST`, `SP_CORE_HOST`,
+`SP_HOST`) are preset to `localhost` in the `Dockerfile`.
+
+### Credentials
+
+The initial administrator is `admin@streampipes.apache.org` / `admin`. Override it on the first start:
+
+```bash
+docker run --rm -p 80:80 -e SP_INITIAL_ADMIN_PASSWORD=change-me apachestreampipes/all-in-one:0.99.0-SNAPSHOT
+```
+
+The secrets the services share (service account, JWT signing, CouchDB and InfluxDB credentials,
+encryption passcode, NATS token) are generated randomly on the first start of a container and stored in
+`/var/lib/streampipes/secrets.env` inside the container, so a stopped container can be started
+again. The same `SP_*` variables as in the Compose installer (`SP_SERVICE_SECRET`, `SP_JWT_SECRET`,
+`SP_COUCHDB_PASSWORD`, `SP_TS_STORAGE_TOKEN`, `SP_INFLUXDB_ADMIN_PASSWORD`,
+`SP_ENCRYPTION_PASSCODE`, `SP_NATS_TOKEN`) can be passed with `-e` to use your own values; this only has an effect
+on the first start.
+
+### Options
+
+| Variable | Default | Effect |
+| --- | --- | --- |
+| `SP_DEMO_SEED` | `true` | Set to `false` to start a clean platform without the demo scenario |
+| `SP_INITIAL_ADMIN_EMAIL` / `SP_INITIAL_ADMIN_PASSWORD` | `admin@streampipes.apache.org` / `admin` | Initial administrator |
+| `SP_BACKEND_JAVA_OPTS` / `SP_EXTENSIONS_JAVA_OPTS` | `-XX:MaxRAMPercentage=30` | JVM options of the core and the extensions service |
+
+The seed is idempotent: it reuses adapters, pipelines, charts, dashboards, sites, labels and assets
+that already exist (matched by name), so restarting a container does not create duplicates. The
+scenario is defined at the top of `bin/seed-demo.py` and easy to adapt. Its log lines are prefixed with `[demo-seed]`.
+
+## Build the image yourself
+
+The `Dockerfile` copies the published StreamPipes images for the given version, so building it does
+not require a Maven or npm build:
+
+```bash
+docker build -t apachestreampipes/all-in-one:0.99.0-SNAPSHOT installer/all-in-one
+```
+
+Build arguments: `SP_VERSION` (default `0.99.0-SNAPSHOT`), `SP_DOCKER_REGISTRY` (default
+`apachestreampipes`), `COUCHDB_VERSION`, `INFLUXDB_VERSION` and `NATS_VERSION`. To bundle images you
+built locally, tag them as `<registry>/backend:<version>`, `<registry>/extensions-all-iiot:<version>`
+and `<registry>/ui:<version>` and pass matching build arguments.
+
+## Troubleshooting
+
+- `docker logs <container>` shows the output of all processes; `docker exec <container> supervisorctl status`
+  lists their state.
+- The UI stays on the progress screen for longer than two minutes: check the log for the core
+  (`StreamPipesCoreApplication`) and make sure Docker has enough memory.
+- Dashboards are missing: the seed waits for every dataset to receive its first events before it creates
+  the charts, so look for `[demo-seed]` lines in the log. `[demo-seed] Demo is ready` means everything was created.
+- The map on the home page stays grey: it loads tiles from openstreetmap.org, which needs internet access.
diff --git a/installer/all-in-one/bin/entrypoint.sh b/installer/all-in-one/bin/entrypoint.sh
new file mode 100755
index 0000000000..8012fae954
--- /dev/null
+++ b/installer/all-in-one/bin/entrypoint.sh
@@ -0,0 +1,92 @@
+#!/bin/bash
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Entrypoint of the all-in-one image: derives the credentials shared by the
+# bundled services and hands over to supervisord.
+#
+# Secrets are generated once per container and kept in
+# /var/lib/streampipes/secrets.env so that restarts of the same container keep
+# working. Any SP_* variable passed with `docker run -e` wins over the
+# generated value; this only has an effect on the first start.
+
+set -euo pipefail
+
+STATE_DIR=/var/lib/streampipes
+SECRETS_FILE="$STATE_DIR/secrets.env"
+
+random_secret() {
+  python3 -c 'import secrets; print(secrets.token_hex(32))'
+}
+
+mkdir -p "$STATE_DIR"
+if [ ! -f "$SECRETS_FILE" ]; then
+  echo "[entrypoint] Generating service credentials for this container"
+  umask 077
+  cat > "$SECRETS_FILE" <<SECRETS
+SP_GENERATED_SERVICE_SECRET=$(random_secret)
+SP_GENERATED_JWT_SECRET=$(random_secret)
+SP_GENERATED_COUCHDB_PASSWORD=$(random_secret)
+SP_GENERATED_TS_STORAGE_TOKEN=$(random_secret)
+SP_GENERATED_INFLUXDB_ADMIN_PASSWORD=$(random_secret)
+SP_GENERATED_ENCRYPTION_PASSCODE=$(random_secret)
+SP_GENERATED_NATS_TOKEN=$(random_secret)
+SECRETS
+  umask 022
+fi
+
+set -a
+# shellcheck disable=SC1090
+. "$SECRETS_FILE"
+set +a
+
+# Service account shared by core and extensions (SP_SERVICE_SECRET in the Compose installer)
+export SP_INITIAL_SERVICE_USER_SECRET="${SP_INITIAL_SERVICE_USER_SECRET:-${SP_SERVICE_SECRET:-$SP_GENERATED_SERVICE_SECRET}}"
+export SP_CLIENT_SECRET="${SP_CLIENT_SECRET:-$SP_INITIAL_SERVICE_USER_SECRET}"
+export SP_JWT_SECRET="${SP_JWT_SECRET:-$SP_GENERATED_JWT_SECRET}"
+export SP_ENCRYPTION_PASSCODE="${SP_ENCRYPTION_PASSCODE:-$SP_GENERATED_ENCRYPTION_PASSCODE}"
+
+# NATS token authentication (same wiring as the Compose nats-auth override)
+export SP_NATS_TOKEN="${SP_NATS_TOKEN:-$SP_GENERATED_NATS_TOKEN}"
+
+# CouchDB
+export SP_COUCHDB_PASSWORD="${SP_COUCHDB_PASSWORD:-$SP_GENERATED_COUCHDB_PASSWORD}"
+export COUCHDB_PASSWORD="$SP_COUCHDB_PASSWORD"
+
+# InfluxDB
+export SP_TS_STORAGE_TOKEN="${SP_TS_STORAGE_TOKEN:-$SP_GENERATED_TS_STORAGE_TOKEN}"
+export DOCKER_INFLUXDB_INIT_ADMIN_TOKEN="$SP_TS_STORAGE_TOKEN"
+export DOCKER_INFLUXDB_INIT_PASSWORD="${SP_INFLUXDB_ADMIN_PASSWORD:-$SP_GENERATED_INFLUXDB_ADMIN_PASSWORD}"
+
+# Initial StreamPipes administrator (documented demo credentials)
+export SP_INITIAL_ADMIN_EMAIL="${SP_INITIAL_ADMIN_EMAIL:-admin@streampipes.apache.org}"
+export SP_INITIAL_ADMIN_PASSWORD="${SP_INITIAL_ADMIN_PASSWORD:-admin}"
+
+cat <<BANNER
+
+**********************************************************************
+  Apache StreamPipes all-in-one demo
+
+  Starting CouchDB, NATS, InfluxDB, the StreamPipes core, the IIoT
+  extensions and the UI in this container. The first start takes about
+  a minute; the UI shows a progress screen until the core is ready.
+
+  Open:      http://localhost (or the port you mapped to 80)
+  Sign in:   $SP_INITIAL_ADMIN_EMAIL / $SP_INITIAL_ADMIN_PASSWORD
+**********************************************************************
+
+BANNER
+
+exec /usr/bin/supervisord -n -c /etc/supervisor/supervisord.conf
diff --git a/installer/all-in-one/bin/seed-demo.py b/installer/all-in-one/bin/seed-demo.py
new file mode 100755
index 0000000000..db1dc2e0af
--- /dev/null
+++ b/installer/all-in-one/bin/seed-demo.py
@@ -0,0 +1,709 @@
+#!/usr/bin/env python3
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Seeds the all-in-one demo scenario once the StreamPipes core is ready.
+
+The scenario is a small water works with two sites:
+
+* Riverside Water Works: an intake pump station (three pumps), the main
+  pressure line (two sensors) and a clear-water storage tank.
+* Hillside Reservoir: a reservoir with two level sensors.
+
+Every machine is a machine data simulator adapter whose ``persist`` option
+also creates the "Persist ..." pipeline. On top of that, three analytics
+pipelines detect overheating pumps, smooth the pressure signal and record
+tank overflow events. Charts, dashboards, sites, labels and assets tie it
+together. Everything goes through the public REST API of the core.
+
+The script is idempotent: resources that already exist (matched by name) are
+reused, so it runs on every container start. Set SP_DEMO_SEED=false to skip
+it. Only the Python standard library is used.
+"""
+
+import json
+import os
+import secrets
+import sys
+import time
+import urllib.error
+import urllib.request
+
+BACKEND_URL = os.environ.get("SP_SEED_BACKEND_URL", "http://localhost:8030/streampipes-backend")
+ADMIN_EMAIL = os.environ.get("SP_INITIAL_ADMIN_EMAIL", "admin@streampipes.apache.org")
+ADMIN_PASSWORD = os.environ.get("SP_INITIAL_ADMIN_PASSWORD", "admin")
+SEED_ENABLED = os.environ.get("SP_DEMO_SEED", "true").strip().lower() not in ("false", "0", "no")
+
+READY_TIMEOUT_SECONDS = int(os.environ.get("SP_SEED_TIMEOUT_SECONDS", "900"))
+POLL_INTERVAL_SECONDS = 3
+RECOVERY_GRACE_SECONDS = 60
+
+# ---------------------------------------------------------------------------
+# Extension ids
+# ---------------------------------------------------------------------------
+SIMULATOR_APP_ID = "org.apache.streampipes.connect.iiot.adapters.simulator.machine"
+DATASET_SINK_APP_ID = "org.apache.streampipes.sinks.internal.jvm.dataset"
+NUMERICAL_FILTER_APP_ID = "org.apache.streampipes.processors.filters.jvm.numericalfilter"
+BOOLEAN_FILTER_APP_ID = "org.apache.streampipes.processors.filters.jvm.processor.booleanfilter"
+MOVING_AVERAGE_APP_ID = "org.apache.streampipes.processors.filters.jvm.movingaverage"
+REQUIRED_EXTENSIONS = (SIMULATOR_APP_ID, DATASET_SINK_APP_ID, NUMERICAL_FILTER_APP_ID,
+                       BOOLEAN_FILTER_APP_ID, MOVING_AVERAGE_APP_ID)
+
+XSD = "http://www.w3.org/2001/XMLSchema#"
+NUMERIC_TYPES = {XSD + "integer", XSD + "long", XSD + "float", XSD + "double", "http://schema.org/Number"}
+BOOLEAN_TYPE = XSD + "boolean"
+PRESET_COLORS = ["#39B54A", "#1B1464", "#f44336", "#FFEB3B", "#000000", "#433BFF", "#FF00E4", "#FD8B00"]
+TIMESTAMP_FIELD = "timestamp"
+SENSOR_ID_FIELD = "sensorId"
+
+
+def prop(label, scope="measurement", semantic="http://schema.org/Number"):
+    return {"label": label, "description": "", "propertyScope": scope, "semanticType": semantic,
+            "additionalMetadata": {}}
+
+
+# Metadata the sample-data schema guess cannot know: the timestamp (needed by the
+# persist pipeline) and the sensor id as dimension (becomes a tag in the storage).
+COMMON_SCHEMA = {
+    TIMESTAMP_FIELD: prop("Timestamp", "header", "http://schema.org/DateTime"),
+    SENSOR_ID_FIELD: prop("Sensor ID", "dimension", None),
+}
+SIMULATOR_SCHEMAS = {
+    "flowrate": {**COMMON_SCHEMA, "mass_flow": prop("Mass flow"), "volume_flow": prop("Volume flow"),
+                 "temperature": prop("Temperature"), "density": prop("Density")},
+    "pressure": {**COMMON_SCHEMA, "pressure": prop("Pressure")},
+    "waterlevel": {**COMMON_SCHEMA, "level": prop("Level")},
+}
+
+# ---------------------------------------------------------------------------
+# Scenario
+# ---------------------------------------------------------------------------
+SITES = {
+    "riverside": {"label": "Riverside Water Works", "latitude": 49.0134, "longitude": 8.4044, "zoom": 13,
+                  "areas": ["Intake", "Treatment", "Storage"]},
+    "hillside": {"label": "Hillside Reservoir", "latitude": 49.0521, "longitude": 8.4701, "zoom": 13,
+                 "areas": ["Reservoir"]},
+}
+
+LABELS = {
+    "demo": {"label": "Demo", "description": "Created by the all-in-one demo seed", "color": "#1b1464"},
+    "critical": {"label": "Critical asset", "description": "Outage stops water supply", "color": "#f44336"},
+}
+
+# key -> adapter definition; the persist pipeline is named "Persist <name>"
+ADAPTERS = {
+    "intake_pumps": {"name": "Intake Pumps", "mode": "flowrate", "sensors": 3, "dataset": "intake_pumps",
+                     "description": "Three intake pumps reporting flow, temperature and density (simulated)"},
+    "main_line_pressure": {"name": "Main Line Pressure", "mode": "pressure", "sensors": 2,
+                           "dataset": "main_line_pressure",
+                           "description": "Two pressure sensors on the main treatment line (simulated)"},
+    "clear_water_tank": {"name": "Clear Water Tank", "mode": "waterlevel", "sensors": 1,
+                         "dataset": "clear_water_tank",
+                         "description": "Level sensor of the clear-water storage tank (simulated)"},
+    "reservoir_level": {"name": "Reservoir Level", "mode": "waterlevel", "sensors": 2, "dataset": "reservoir_level",
+                        "description": "Two level sensors in the hillside reservoir (simulated)"},
+}
+
+# Analytics pipelines on top of the adapter streams: stream -> processor -> dataset
+PIPELINES = {
+    "pump_overheating": {
+        "name": "Pump Overheating Detection", "adapter": "intake_pumps", "dataset": "pump_overheating",
+        "description": "Keeps pump events whose temperature exceeds 80 degrees",
+        "processor": {"id": NUMERICAL_FILTER_APP_ID, "configuration": [
+            {"number-mapping": "s0::temperature"}, {"operation": ">"}, {"value": 80}]},
+    },
+    "pressure_smoothing": {
+        "name": "Pressure Smoothing", "adapter": "main_line_pressure", "dataset": "main_line_pressure_smoothed",
+        "description": "Adds a moving average over the last 10 pressure readings",
+        "processor": {"id": MOVING_AVERAGE_APP_ID, "configuration": [
+            {"number": "s0::pressure"}, {"n": 10}, {"method": "mean"}]},
+    },
+    "tank_overflow": {
+        "name": "Tank Overflow Events", "adapter": "clear_water_tank", "dataset": "tank_overflow_events",
+        "description": "Records every event in which the tank reports an overflow",
+        "processor": {"id": BOOLEAN_FILTER_APP_ID, "configuration": [
+            {"boolean-mapping": "s0::overflow"}, {"value": "True"}]},
+    },
+}
+
+# Charts: type, title, dataset and type-specific options
+CHARTS = {
+    "pump_flow": {"type": "time-series", "title": "Intake pump flow", "dataset": "intake_pumps",
+                  "fields": ["mass_flow"], "group_by": True},
+    "pump_temperature": {"type": "time-series", "title": "Intake pump temperature", "dataset": "intake_pumps",
+                         "fields": ["temperature"], "group_by": True},
+    "pump_temperature_gauge": {"type": "gauge", "title": "Latest pump temperature", "dataset": "intake_pumps",
+                               "field": "temperature", "min": 0, "max": 120, "low": 60, "high": 80},
+    "pump_faults": {"type": "status-heatmap", "title": "Pump fault flags", "dataset": "intake_pumps",
+                    "field": "sensor_fault_flags"},
+    "pump_overheating": {"type": "table", "title": "Pump overheating events", "dataset": "pump_overheating",
+                         "columns": ["timestamp", "sensorId", "temperature", "mass_flow"]},
+    "pressure": {"type": "time-series", "title": "Main line pressure", "dataset": "main_line_pressure",
+                 "fields": ["pressure"], "group_by": True},
+    "pressure_smoothed": {"type": "time-series", "title": "Main line pressure (smoothed)",
+                          "dataset": "main_line_pressure_smoothed", "fields": ["pressure", "filterResult"],
+                          "group_by": True},
+    "tank_level": {"type": "time-series", "title": "Clear water tank level", "dataset": "clear_water_tank",
+                   "fields": ["level"]},
+    "tank_latest": {"type": "value-card", "title": "Clear water tank (latest)", "dataset": "clear_water_tank",
+                    "fields": ["level", "overflow"]},
+    "tank_overflow": {"type": "table", "title": "Tank overflow events", "dataset": "tank_overflow_events",
+                      "columns": ["timestamp", "sensorId", "level"]},
+    "reservoir_level": {"type": "time-series", "title": "Reservoir level", "dataset": "reservoir_level",
+                        "fields": ["level"], "group_by": True},
+}
+
+# Dashboards: name, description and widgets as (chart key, x, y, cols, rows) on an 8-column grid
+DASHBOARDS = {
+    "overview": {"name": "Plant Overview", "description": "Key figures of both sites at a glance", "widgets": [
+        ("pump_temperature_gauge", 0, 0, 2, 3), ("tank_latest", 2, 0, 2, 3), ("pump_flow", 4, 0, 4, 3),
+        ("pressure", 0, 3, 4, 3), ("reservoir_level", 4, 3, 4, 3), ("pump_overheating", 0, 6, 8, 3)]},
+    "pumps": {"name": "Intake Pump Station", "description": "Flow, temperature and alarms of the three intake pumps",
+              "widgets": [("pump_flow", 0, 0, 4, 3), ("pump_temperature", 4, 0, 4, 3),
+                          ("pump_faults", 0, 3, 4, 3), ("pump_temperature_gauge", 4, 3, 2, 3),
+                          ("pump_overheating", 0, 6, 8, 3)]},
+    "storage": {"name": "Water Storage", "description": "Clear water tank, reservoir and the pressure line",
+                "widgets": [("tank_latest", 0, 0, 2, 3), ("tank_level", 2, 0, 6, 3),
+                            ("reservoir_level", 0, 3, 4, 3), ("pressure_smoothed", 4, 3, 4, 3),
+                            ("tank_overflow", 0, 6, 8, 3)]},
+}
+
+# Assets: top-level assets with their site, links and sub-assets
+ASSETS = [
+    {"name": "Intake Pump Station", "description": "Three centrifugal pumps lifting raw water from the river",
+     "isa95": "PRODUCTION_UNIT", "site": "riverside", "area": "Intake", "labels": ["demo", "critical"],
+     "adapters": ["intake_pumps"], "pipelines": ["pump_overheating"],
+     "charts": ["pump_flow", "pump_temperature", "pump_temperature_gauge", "pump_faults", "pump_overheating"],
+     "dashboards": ["pumps"],
+     "sub_assets": [{"name": f"Pump P-10{i}", "description": f"Intake pump {i} (sensor flowrate0{i})",
+                     "isa95": "UNIT", "labels": ["demo"]} for i in (1, 2, 3)]},
+    {"name": "Main Pressure Line", "description": "Pressurised line from the pump station to the treatment stage",
+     "isa95": "PRODUCTION_LINE", "site": "riverside", "area": "Treatment", "labels": ["demo"],
+     "adapters": ["main_line_pressure"], "pipelines": ["pressure_smoothing"],
+     "charts": ["pressure", "pressure_smoothed"], "dashboards": []},
+    {"name": "Clear Water Tank T-200", "description": "Storage tank for treated water before distribution",
+     "isa95": "STORAGE_UNIT", "site": "riverside", "area": "Storage", "labels": ["demo", "critical"],
+     "adapters": ["clear_water_tank"], "pipelines": ["tank_overflow"],
+     "charts": ["tank_level", "tank_latest", "tank_overflow"], "dashboards": ["storage"]},
+    {"name": "Hillside Reservoir Basin", "description": "Open reservoir feeding the works by gravity",
+     "isa95": "STORAGE_ZONE", "site": "hillside", "area": "Reservoir", "labels": ["demo"],
+     "adapters": ["reservoir_level"], "pipelines": [], "charts": ["reservoir_level"], "dashboards": ["overview"]},
+]
+
+LOCATION_CONFIG = {"locationEnabled": True, "mapLayerType": "TILE",
+                   "tileServerUrl": "https://tile.openstreetmap.org/{z}/{x}/{y}.png",
+                   "attributionText": "&copy; OpenStreetMap contributors"}
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+def log(message):
+    print(f"[demo-seed] {message}", flush=True)
+
+
+def now_ms():
+    return int(time.time() * 1000)
+
+
+class Api:
+    def __init__(self, base_url):
+        self.base_url = base_url
+        self.token = None
+
+    def request(self, method, path, body=None):
+        headers = {"Accept": "application/json"}
+        data = None
+        if body is not None:
+            data = json.dumps(body).encode("utf-8")
+            headers["Content-Type"] = "application/json"
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        request = urllib.request.Request(self.base_url + path, data=data, method=method, headers=headers)
+        with urllib.request.urlopen(request, timeout=60) as response:
+            raw = response.read()
+        return json.loads(raw) if raw else None
+
+    def get(self, path):
+        return self.request("GET", path)
+
+    def post(self, path, body):
+        return self.request("POST", path, body)
+
+    def put(self, path, body):
+        return self.request("PUT", path, body)
+
+
+def wait_until(description, probe, timeout=READY_TIMEOUT_SECONDS):
+    """Calls probe() until it returns a truthy value; failures count as 'not yet'."""
+    deadline = time.monotonic() + timeout
+    last_error = None
+    while time.monotonic() < deadline:
+        try:
+            result = probe()
+            if result:
+                return result
+        except (urllib.error.URLError, OSError, ValueError, KeyError) as error:
+            last_error = error
+        time.sleep(POLL_INTERVAL_SECONDS)
+    raise TimeoutError(f"gave up waiting for {description} (last error: {last_error})")
+
+
+def core_is_configured(api):
+    return api.get("/api/v2/setup/configured").get("configured") is True
+
+
+def login(api):
+    response = api.post("/api/v2/auth/login", {"username": ADMIN_EMAIL, "password": ADMIN_PASSWORD, "rememberMe": False})
+    api.token = response["accessToken"]
+    return True
+
+
+def required_extension_items(api):
+    items = {item["appId"]: item for item in api.get("/api/v2/extension-items")}
+    found = [items[app_id] for app_id in REQUIRED_EXTENSIONS if app_id in items]
+    return found if len(found) == len(REQUIRED_EXTENSIONS) else None
+
+
+def ensure_extensions_installed(api):
+    wait_until("the IIoT extensions service to register", lambda: required_extension_items(api))
+    log("Extensions service is registered")
+    # The core installs all extensions during its initial setup; give it a moment before stepping in.
+    try:
+        wait_until("the initial extension installation",
+                   lambda: all(item["installed"] for item in required_extension_items(api)), timeout=90)
+    except TimeoutError:
+        for item in required_extension_items(api):
+            if not item["installed"]:
+                log(f"Installing extension {item['appId']}")
+                api.post("/api/v2/extension-installation",
+                         {"appId": item["appId"], "serviceTagPrefix": item["serviceTagPrefix"], "publicElement": True})
+        wait_until("the extension installation",
+                   lambda: all(item["installed"] for item in required_extension_items(api)), timeout=120)
+    # "available" means the extensions service that provides them is up, which starting an adapter or pipeline needs.
+    wait_until("the extensions service to become available",
+               lambda: all(item["installed"] and item["available"] for item in required_extension_items(api)))
+    log("Required extensions are installed and available")
+
+
+# ---------------------------------------------------------------------------
+# Adapters and pipelines
+# ---------------------------------------------------------------------------
+def find_by_name(items, name):
+    return next((item for item in items if item.get("name") == name), None)
+
+
+def find_adapter(api, name):
+    return find_by_name(api.get("/api/v2/connect/master/adapters"), name)
+
+
+def find_pipeline(api, name):
+    return find_by_name(api.get("/api/v2/pipelines"), name)
+
+
+def ensure_adapter(api, definition):
+    name = definition["name"]
+    adapter = find_adapter(api, name)
+    if adapter is None:
+        log(f"Creating adapter '{name}' and its persist pipeline")
+        response = api.post("/api/v2/connect/compact-adapters", {
+            "name": name,
+            "description": definition["description"],
+            "appId": SIMULATOR_APP_ID,
+            "configuration": [
+                {"wait-time-ms": "1000"},
+                {"numberOfSensors": str(definition["sensors"])},
+                {"selected-simulator-option": definition["mode"]},
+            ],
+            "schema": SIMULATOR_SCHEMAS[definition["mode"]],
+            "createOptions": {"persist": True, "start": True, "persistDatasetName": definition["dataset"]},
+        })
+        if response and response.get("success") is False:
+            raise RuntimeError(f"adapter creation failed: {response}")
+        adapter = wait_until(f"adapter '{name}' to be stored", lambda: find_adapter(api, name), timeout=60)
+    else:
+        log(f"Adapter '{name}' already exists")
+        if not adapter.get("running"):
+            # After a restart the core recovers adapters and pipelines itself; only step in if it does not.
+            try:
+                wait_until(f"the core to recover adapter '{name}'",
+                           lambda: find_adapter(api, name).get("running"), timeout=RECOVERY_GRACE_SECONDS)
+            except TimeoutError:
+                log(f"Starting adapter '{name}'")
+                api.post(f"/api/v2/connect/master/adapters/{adapter['elementId']}/start", {})
+    return adapter
+
+
+def persist_pipeline_elements(adapter, dataset):
+    return [
+        {"type": "stream", "ref": "stream1", "id": adapter["correspondingDataStreamElementId"]},
+        dataset_sink_element("stream1", dataset),
+    ]
+
+
+def dataset_sink_element(connected_to, dataset):
+    return {"type": "sink", "ref": "lake", "id": DATASET_SINK_APP_ID, "connectedTo": [connected_to],
+            "configuration": [
+                {"schema_update": "Update schema"},
+                {"ignore_duplicates": False},
+                {"db_measurement": dataset},
+                {"timestamp_mapping": f"s0::{TIMESTAMP_FIELD}"},
+                {"dimensions_selection": [SENSOR_ID_FIELD]},
+            ]}
+
+
+def ensure_pipeline(api, pipeline_id, name, description, elements):
+    pipeline = find_pipeline(api, name)
+    if pipeline is None:
+        log(f"Creating pipeline '{name}'")
+        response = api.post("/api/v2/compact-pipelines", {
+            "id": pipeline_id, "name": name, "description": description,
+            "pipelineElements": elements, "createOptions": {"start": True},
+        })
+        if isinstance(response, dict) and response.get("success") is False:
+            raise RuntimeError(f"pipeline '{name}' failed: {response}")
+        pipeline = wait_until(f"pipeline '{name}' to be stored", lambda: find_pipeline(api, name), timeout=60)
+    elif not pipeline.get("running"):
+        try:
+            wait_until(f"the core to restart pipeline '{name}'",
+                       lambda: find_pipeline(api, name).get("running"), timeout=RECOVERY_GRACE_SECONDS)
+            log(f"Pipeline '{name}' was restarted by the core")
+        except TimeoutError:
+            log(f"Starting pipeline '{name}'")
+            api.get(f"/api/v2/pipelines/{pipeline['elementId']}/start")
+    else:
+        log(f"Pipeline '{name}' is running")
+    return pipeline
+
+
+def ensure_machines(api):
+    """Creates adapters, their persist pipelines and the analytics pipelines. Returns the ids by key."""
+    adapters, pipelines = {}, {}
+    for key, definition in ADAPTERS.items():
+        adapters[key] = ensure_adapter(api, definition)
+    for key, definition in ADAPTERS.items():
+        # The persist option normally creates this pipeline; recreate it if it is missing.
+        pipelines[f"persist_{key}"] = ensure_pipeline(
+            api, f"demo-persist-{key.replace('_', '-')}", f"Persist {definition['name']}",
+            f"Stores the events of {definition['name']} in the time-series storage",
+            persist_pipeline_elements(adapters[key], definition["dataset"]))
+    for key, definition in PIPELINES.items():
+        processor = definition["processor"]
+        elements = [
+            {"type": "stream", "ref": "stream1", "id": adapters[definition["adapter"]]["correspondingDataStreamElementId"]},
+            {"type": "processor", "ref": "processor", "id": processor["id"], "connectedTo": ["stream1"],
+             "configuration": processor["configuration"]},
+            dataset_sink_element("processor", definition["dataset"]),
+        ]
+        pipelines[key] = ensure_pipeline(api, f"demo-{key.replace('_', '-')}", definition["name"],
+                                         definition["description"], elements)
+    return adapters, pipelines
+
+
+# ---------------------------------------------------------------------------
+# Datasets and charts
+# ---------------------------------------------------------------------------
+def dataset_metadata(api, name):
+    measure = api.get(f"/api/v4/datalake/measure/byName/{name}")
+    properties = (measure or {}).get("eventSchema", {}).get("eventProperties") or []
+    return measure if properties else None
+
+
+def wait_for_datasets(api):
+    names = [a["dataset"] for a in ADAPTERS.values()] + [p["dataset"] for p in PIPELINES.values()]
+    datasets = {}
+    for name in names:
+        datasets[name] = wait_until(f"dataset '{name}' to receive its schema", lambda: dataset_metadata(api, name),
+                                    timeout=300)
+    log(f"All {len(datasets)} datasets have a schema")
+    return datasets
+
+
+def is_numeric(p):
+    return p.get("runtimeType") in NUMERIC_TYPES
+
+
+def is_boolean(p):
+    return p.get("runtimeType") == BOOLEAN_TYPE
+
+
+def make_field(measure, p):
+    field = {
+        "runtimeName": p["runtimeName"], "measure": measure["measureName"], "fullDbName": p["runtimeName"],
+        "sourceIndex": 0,
+        "fieldCharacteristics": {
+            "dimension": p.get("propertyScope") == "DIMENSION_PROPERTY", "numeric": is_numeric(p),
+            "binary": is_boolean(p), "semanticTypes": [p.get("semanticType")],
+        },
+    }
+    if p.get("measurementUnit"):
+        field["measurementUnitResourceId"] = p["measurementUnit"]
+    return field
+
+
+def properties_of(measure):
+    return sorted(measure["eventSchema"]["eventProperties"], key=lambda p: p["runtimeName"])
+
+
+def fields_of(measure, names=None):
+    return [make_field(measure, p) for p in properties_of(measure) if names is None or p["runtimeName"] in names]
+
+
+def field_key(field):
+    return field["fullDbName"] + str(field["sourceIndex"])
+
+
+def last_15_minutes():
+    now = now_ms()
+    return {"startTime": now - 15 * 60 * 1000, "endTime": now, "dynamicSelection": -1,
+            "timeSelectionId": "last-15-minutes"}
+
+
+def source_config(measure, group_by=False, latest_only=False):
+    query = {
+        "selectedFilters": [], "resultLabelOverrides": {},
+        "fields": [{"runtimeName": p["runtimeName"], "selected": True, "numeric": is_numeric(p),
+                    "aggregations": ["MEAN" if is_numeric(p) else "MODE"]} for p in properties_of(measure)],
+        "groupBy": [{"runtimeName": SENSOR_ID_FIELD, "selected": True, "numeric": False, "aggregations": ["MODE"]}]
+        if group_by else [],
+        "aggregationTimeUnit": "d", "aggregationValue": 1, "fill": "none",
+    }
+    if latest_only:
+        query.update({"order": "DESC", "limit": 1, "page": 1})
+    return {"measureName": measure["measureName"], "measure": measure, "queryType": "raw", "queryConfig": query}
+
+
+def chart_model(definition, measure, visualization, group_by=False, latest_only=False):
+    now = now_ms()
+    visualization.setdefault("configurationValid", True)
+    appearance = {"widgetTitle": definition["title"], "backgroundColor": "var(--color-bg-0)",
+                  "textColor": "var(--color-default-text)"}
+    if definition["type"] in ("gauge", "value-card", "table"):
+        appearance["numberFormat"] = {"decimals": 2}
+    return {
+        "@class": "org.apache.streampipes.model.datalake.DataExplorerWidgetModel",
+        "widgetType": definition["type"] if definition["type"] != "time-series" else "time-series-chart",
+        "baseAppearanceConfig": appearance,
+        "dataConfig": {"ignoreMissingValues": False, "ignoreTooMuchDataWarning": True,
+                       "sourceConfigs": [source_config(measure, group_by, latest_only)]},
+        "visualizationConfig": visualization,
+        "timeSettings": last_15_minutes(),
+        "metadata": {"createdAtEpochMs": now, "lastModifiedEpochMs": now},
+    }
+
+
+def build_chart(definition, measure):
+    kind = definition["type"]
+    if kind == "time-series":
+        plottable = [f for f in fields_of(measure) if f["fieldCharacteristics"]["numeric"] or f["fieldCharacteristics"]["binary"]]
+        visualization = {
+            "selectedTimeSeriesChartProperties": [f for f in plottable if f["runtimeName"] in definition["fields"]],
+            "yKeys": [],
+            "chosenColor": {field_key(f): PRESET_COLORS[i % len(PRESET_COLORS)] for i, f in enumerate(plottable)},
+            "displayName": {field_key(f): f["fullDbName"] for f in plottable},
+            "displayType": {field_key(f): "lines" for f in plottable},
+            "chosenAxis": {field_key(f): "left" for f in plottable},
+            "groupedColorMode": {field_key(f): "stable_palette" for f in plottable},
+            "groupedColorMappings": {field_key(f): [] for f in plottable},
+            "leftAxis": {"autoScaleActive": True, "axisMin": 0, "axisMax": 100},
+            "rightAxis": {"autoScaleActive": True, "axisMin": 0, "axisMax": 100},
+            "showSpike": True,
+        }
+        return chart_model(definition, measure, visualization, group_by=definition.get("group_by", False))
+    if kind == "gauge":
+        field = fields_of(measure, [definition["field"]])[0]
+        visualization = {
+            "selectedProperty": field, "displayName": field["runtimeName"],
+            "min": definition["min"], "max": definition["max"], "startAngle": 225, "endAngle": -45,
+            "splitNumber": 10, "showPointer": True, "enableThresholdColors": True,
+            "thresholdLow": definition["low"], "thresholdHigh": definition["high"],
+            "thresholdColorLow": "#91cc75", "thresholdColorMedium": "#fac858", "thresholdColorHigh": "#ee6666",
+        }
+        return chart_model(definition, measure, visualization, latest_only=True)
+    if kind == "value-card":
+        visualization = {"selectedFields": fields_of(measure, definition["fields"]), "title": "",
+                         "description": "", "showTimestamp": True}
+        return chart_model(definition, measure, visualization, latest_only=True)
+    if kind == "table":
+        visualization = {"selectedColumns": fields_of(measure, definition["columns"]), "highlightedColumns": [],
+                         "highlightedColumnColors": {}, "pageSize": 20, "stickyHeaders": True, "searchValue": ""}
+        return chart_model(definition, measure, visualization)
+    if kind == "status-heatmap":
+        field = fields_of(measure, [definition["field"]])[0]
+        visualization = {"selectedProperty": field, "isSelectedPropertyBoolean": field["fieldCharacteristics"]["binary"],
+                         "showCustomColorMappingStatusHeatmap": False, "colorMappingsStatusHeatmap": []}
+        return chart_model(definition, measure, visualization)
+    raise ValueError(f"unknown chart type {kind}")
+
+
+def ensure_charts(api, datasets):
+    existing = {(c.get("baseAppearanceConfig") or {}).get("widgetTitle"): c["elementId"]
+                for c in api.get("/api/v3/datalake/dashboard/widgets")}
+    charts = {}
+    for key, definition in CHARTS.items():
+        if definition["title"] in existing:
+            charts[key] = existing[definition["title"]]
+            continue
+        log(f"Creating chart '{definition['title']}'")
+        charts[key] = api.post("/api/v3/datalake/dashboard/widgets",
+                               build_chart(definition, datasets[definition["dataset"]]))["elementId"]
+    log(f"{len(charts)} charts available")
+    return charts
+
+
+def ensure_dashboards(api, charts):
+    existing = {d.get("name"): d["elementId"] for d in api.get("/api/v3/datalake/dashboard")}
+    dashboards = {}
+    for key, definition in DASHBOARDS.items():
+        if definition["name"] in existing:
+            dashboards[key] = existing[definition["name"]]
+            continue
+        log(f"Creating dashboard '{definition['name']}'")
+        now = now_ms()
+        response = api.post("/api/v3/datalake/dashboard", {
+            "name": definition["name"], "description": definition["description"],
+            "dashboardGeneralSettings": {"chartOverrides": {"hideToolbox": False, "borderThickness": 0},
+                                         "defaultViewMode": "grid", "globalTimeEnabled": True, "gridRowHeightPx": 90},
+            "dashboardLiveSettings": {"label": "5 sec", "refreshModeActive": True, "refreshIntervalInSeconds": 5},
+            "dashboardTimeSettings": last_15_minutes(),
+            "widgets": [{"id": secrets.token_hex(5), "x": x, "y": y, "cols": cols, "rows": rows, "w": cols, "h": rows,
+                         "dataViewElementId": charts[chart]} for chart, x, y, cols, rows in definition["widgets"]],
+            "metadata": {"createdAtEpochMs": now, "lastModifiedEpochMs": now},
+        })
+        dashboards[key] = response["elementId"]
+    log(f"{len(dashboards)} dashboards available")
+    return dashboards
+
+
+# ---------------------------------------------------------------------------
+# Sites, labels and assets
+# ---------------------------------------------------------------------------
+def ensure_generic_documents(api, app_doc_name, definitions, match_key="label"):
+    existing = {doc.get(match_key): doc["_id"] for doc in api.get(f"/api/v2/storage-generic/{app_doc_name}")}
+    ids = {}
+    for key, definition in definitions.items():
+        if definition[match_key] in existing:
+            ids[key] = existing[definition[match_key]]
+        else:
+            log(f"Creating {app_doc_name} document '{definition[match_key]}'")
+            ids[key] = api.post(f"/api/v2/storage-generic/{app_doc_name}", definition)["_id"]
+    return ids
+
+
+def ensure_sites(api):
+    documents = {key: {"appDocType": "asset-sites", "label": site["label"], "areas": site["areas"],
+                       "location": {"coordinates": {"latitude": site["latitude"], "longitude": site["longitude"]},
+                                    "zoom": site["zoom"]}} for key, site in SITES.items()}
+    return ensure_generic_documents(api, "asset-sites", documents)
+
+
+def ensure_labels(api):
+    documents = {key: {"appDocType": "sp-labels", **label} for key, label in LABELS.items()}
+    return ensure_generic_documents(api, "sp-labels", documents)
+
+
+def ensure_location_config(api):
+    config = api.get("/api/v2/admin/location-config")
+    if not config.get("locationEnabled"):
+        log("Enabling the site map on the home page")
+        api.put("/api/v2/admin/location-config", LOCATION_CONFIG)
+
+
+def asset_link(resource_id, link_type, label, navigation=True):
+    return {"resourceId": resource_id, "linkType": link_type, "linkLabel": label, "queryHint": link_type,
+            "editingDisabled": False, "navigationActive": navigation}
+
+
+def asset_links(definition, ctx):
+    links = []
+    for key in definition.get("adapters", []):
+        adapter = ctx["adapters"][key]
+        links.append(asset_link(adapter["elementId"], "adapter", adapter["name"]))
+        links.append(asset_link(adapter["correspondingDataStreamElementId"], "data-stream", adapter["name"], False))
+        links.append(asset_link(ctx["pipelines"][f"persist_{key}"]["elementId"], "pipeline", f"Persist {adapter['name']}"))
+        dataset = ctx["datasets"][ADAPTERS[key]["dataset"]]
+        links.append(asset_link(dataset["elementId"], "dataset", dataset["measureName"]))
+    for key in definition.get("pipelines", []):
+        links.append(asset_link(ctx["pipelines"][key]["elementId"], "pipeline", PIPELINES[key]["name"]))
+        dataset = ctx["datasets"][PIPELINES[key]["dataset"]]
+        links.append(asset_link(dataset["elementId"], "dataset", dataset["measureName"]))
+    for key in definition.get("charts", []):
+        links.append(asset_link(ctx["charts"][key], "chart", CHARTS[key]["title"]))
+    for key in definition.get("dashboards", []):
+        links.append(asset_link(ctx["dashboards"][key], "dashboard", DASHBOARDS[key]["name"]))
+    return links
+
+
+def asset_node(definition, ctx):
+    site = SITES[definition["site"]] if "site" in definition else None
+    node = {
+        "assetId": secrets.token_hex(4), "assetName": definition["name"],
+        "assetDescription": definition["description"],
+        "assetType": {"isa95AssetType": definition["isa95"]},
+        "assetLinks": asset_links(definition, ctx),
+        "assets": [asset_node(sub, ctx) for sub in definition.get("sub_assets", [])],
+        "labelIds": [ctx["labels"][key] for key in definition.get("labels", [])],
+        "additionalData": {},
+    }
+    if site:
+        node["assetSite"] = {"siteId": ctx["sites"][definition["site"]], "area": definition["area"],
+                             "hasExactLocation": False,
+                             "location": {"coordinates": {"latitude": site["latitude"], "longitude": site["longitude"]},
+                                          "zoom": site["zoom"]}}
+    return node
+
+
+def ensure_assets(api, ctx):
+    existing = {asset.get("assetName") for asset in api.get("/api/v2/assets")}
+    created = 0
+    for definition in ASSETS:
+        if definition["name"] in existing:
+            continue
+        log(f"Creating asset '{definition['name']}'")
+        api.post("/api/v2/assets", {"appDocType": "asset-management", "removable": True, **asset_node(definition, ctx)})
+        created += 1
+    log(f"{len(ASSETS)} assets available ({created} created)")
+
+
+# ---------------------------------------------------------------------------
+def main():
+    if not SEED_ENABLED:
+        log("SP_DEMO_SEED is false, skipping the demo seed")
+        return 0
+    api = Api(BACKEND_URL)
+    log("Waiting for the StreamPipes core to finish its initial setup ...")
+    wait_until("the StreamPipes core", lambda: core_is_configured(api))
+    wait_until("the administrator login", lambda: login(api))
+    log("Core is ready")
+    ensure_extensions_installed(api)
+    adapters, pipelines = ensure_machines(api)
+    datasets = wait_for_datasets(api)
+    charts = ensure_charts(api, datasets)
+    dashboards = ensure_dashboards(api, charts)
+    ctx = {"adapters": adapters, "pipelines": pipelines, "datasets": datasets, "charts": charts,
+           "dashboards": dashboards, "sites": ensure_sites(api), "labels": ensure_labels(api)}
+    ensure_location_config(api)
+    ensure_assets(api, ctx)
+    log("Demo is ready: sign in and open 'Dashboards' (Plant Overview, Intake Pump Station, Water Storage), "
+        "'Assets' for the plant structure or the home page for the site map.")
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception as error:  # noqa: BLE001 - report any failure in the container log
+        log(f"ERROR: demo seed failed: {error}")
+        sys.exit(1)
diff --git a/installer/all-in-one/bin/start-backend.sh b/installer/all-in-one/bin/start-backend.sh
new file mode 100755
index 0000000000..5cc32f2e5d
--- /dev/null
+++ b/installer/all-in-one/bin/start-backend.sh
@@ -0,0 +1,36 @@
+#!/bin/bash
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Starts the StreamPipes core once CouchDB, InfluxDB and NATS answer.
+
+set -euo pipefail
+
+wait_for() {
+  local name=$1 url=$2
+  until curl -fs -o /dev/null "$url"; do
+    echo "[backend] waiting for $name ..."
+    sleep 2
+  done
+}
+
+wait_for CouchDB "http://localhost:5984/_up"
+wait_for InfluxDB "http://localhost:8086/health"
+wait_for NATS "http://localhost:8222/healthz"
+
+echo "[backend] starting StreamPipes core"
+cd /opt/streampipes/backend
+# shellcheck disable=SC2086
+exec java ${SP_BACKEND_JAVA_OPTS:--XX:MaxRAMPercentage=30} org.springframework.boot.loader.launch.JarLauncher
diff --git a/installer/all-in-one/bin/start-extensions.sh b/installer/all-in-one/bin/start-extensions.sh
new file mode 100755
index 0000000000..986b2ea8b2
--- /dev/null
+++ b/installer/all-in-one/bin/start-extensions.sh
@@ -0,0 +1,31 @@
+#!/bin/bash
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Starts the IIoT extensions service once the core accepts HTTP connections.
+# Registration with the core is retried by the service itself, so it does not
+# have to wait for the core to finish its initial setup.
+
+set -euo pipefail
+
+until curl -s -o /dev/null "http://localhost:8030/streampipes-backend/api/v2/setup/configured"; do
+  echo "[extensions] waiting for the StreamPipes core ..."
+  sleep 2
+done
+
+echo "[extensions] starting extensions service"
+cd /opt/streampipes/extensions
+# shellcheck disable=SC2086
+exec java ${SP_EXTENSIONS_JAVA_OPTS:--XX:MaxRAMPercentage=30} org.springframework.boot.loader.launch.JarLauncher
diff --git a/installer/all-in-one/bin/start-nats.sh b/installer/all-in-one/bin/start-nats.sh
new file mode 100755
index 0000000000..7a5274d0b3
--- /dev/null
+++ b/installer/all-in-one/bin/start-nats.sh
@@ -0,0 +1,33 @@
+#!/bin/bash
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Starts NATS with token authentication. The token is generated by the
+# entrypoint (or passed as SP_NATS_TOKEN) and written to a root-only config
+# file so that it does not show up in the process list.
+
+set -euo pipefail
+
+CONFIG=/run/nats-server.conf
+umask 077
+cat > "$CONFIG" <<CONF
+listen: 0.0.0.0:4222
+http_port: 8222
+authorization {
+  token: "$SP_NATS_TOKEN"
+}
+CONF
+
+exec /usr/local/bin/nats-server -c "$CONFIG"
diff --git a/installer/all-in-one/nginx/streampipes.conf b/installer/all-in-one/nginx/streampipes.conf
new file mode 100644
index 0000000000..c5904343e4
--- /dev/null
+++ b/installer/all-in-one/nginx/streampipes.conf
@@ -0,0 +1,87 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Mirrors ui/nginx_config/default.conf, but serves on port 80 and proxies to
+# the core and the extensions service running in the same container.
+
+server {
+  listen       80 default_server;
+  server_name  _;
+
+  root /usr/share/nginx/html;
+  index index.html;
+
+  access_log off;
+  error_log /dev/stderr warn;
+
+  include /etc/nginx/mime.types;
+  # MapLibre's worker and shared ES module must be served as JavaScript.
+  types {
+    application/javascript mjs;
+  }
+
+  client_max_body_size 10240M;
+  proxy_connect_timeout 10000;
+  proxy_send_timeout    10000;
+  proxy_read_timeout    10000;
+  send_timeout          10000;
+
+  # Revalidate the app shell and unversioned assets after deployments.
+  location / {
+    add_header Cache-Control "no-cache" always;
+
+    # Angular production bundles have content hashes in their filenames.
+    location ~ "^/[^/]+(?:-[A-Z0-9]{8}|\.[a-f0-9]{16,64})\.(?:js|css)$" {
+      add_header Cache-Control "public, max-age=31536000, immutable";
+    }
+  }
+
+  location = /version.json {
+    add_header Cache-Control "no-store" always;
+  }
+
+  gzip on;
+  gzip_static on;
+  gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;
+  gzip_proxied any;
+  gzip_vary on;
+  gzip_comp_level 6;
+  gzip_buffers 16 8k;
+  gzip_http_version 1.1;
+
+  proxy_buffers 4 8k;
+  proxy_buffer_size 8k;
+
+  # StreamPipes core
+  location /streampipes-backend {
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-NginX-Proxy true;
+    proxy_pass http://127.0.0.1:8030;
+    proxy_ssl_session_reuse off;
+    proxy_set_header Host $http_host;
+    proxy_redirect off;
+  }
+
+  # HTTP server adapter endpoints of the extensions service
+  location ~/endpoints/(?<endpointName>.*)$ {
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-NginX-Proxy true;
+    proxy_pass http://127.0.0.1:8090/api/v1/worker/live/$endpointName;
+    proxy_ssl_session_reuse off;
+    proxy_set_header Host $http_host;
+  }
+}
diff --git a/installer/all-in-one/supervisord.conf b/installer/all-in-one/supervisord.conf
new file mode 100644
index 0000000000..5dec9fcfb1
--- /dev/null
+++ b/installer/all-in-one/supervisord.conf
@@ -0,0 +1,109 @@
+; Licensed to the Apache Software Foundation (ASF) under one or more
+; contributor license agreements.  See the NOTICE file distributed with
+; this work for additional information regarding copyright ownership.
+; The ASF licenses this file to You under the Apache License, Version 2.0
+; (the "License"); you may not use this file except in compliance with
+; the License.  You may obtain a copy of the License at
+;
+;    http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS,
+; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+; See the License for the specific language governing permissions and
+; limitations under the License.
+
+; Process layout of the all-in-one image. Programs start in ascending and
+; stop in descending priority order, so the StreamPipes core is the last to
+; start and the first to stop (it stops its pipelines on shutdown while the
+; extensions service is still running). Start scripts wait for their
+; dependencies themselves.
+
+[supervisord]
+nodaemon=true
+user=root
+logfile=/dev/null
+logfile_maxbytes=0
+pidfile=/run/supervisord.pid
+
+[unix_http_server]
+file=/run/supervisor.sock
+
+[rpcinterface:supervisor]
+supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
+
+[supervisorctl]
+serverurl=unix:///run/supervisor.sock
+
+[program:couchdb]
+command=/docker-entrypoint.sh /opt/couchdb/bin/couchdb
+priority=10
+autorestart=true
+stopasgroup=true
+killasgroup=true
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+
+[program:influxdb]
+command=/opt/streampipes/bin/influxdb-entrypoint.sh influxd
+priority=15
+autorestart=true
+stopasgroup=true
+killasgroup=true
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+
+[program:nats]
+command=/opt/streampipes/bin/start-nats.sh
+priority=20
+autorestart=true
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+
+[program:nginx]
+command=/usr/sbin/nginx -g "daemon off;"
+priority=30
+autorestart=true
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+
+[program:extensions]
+command=/opt/streampipes/bin/start-extensions.sh
+priority=40
+autorestart=true
+stopwaitsecs=30
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+
+[program:backend]
+command=/opt/streampipes/bin/start-backend.sh
+priority=50
+autorestart=true
+stopwaitsecs=60
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+
+; One-shot: seeds the demo after the core is ready, then exits.
+[program:demo-seed]
+command=/usr/bin/python3 /opt/streampipes/bin/seed-demo.py
+priority=60
+autorestart=false
+startsecs=0
+startretries=0
+exitcodes=0
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
diff --git a/installer/upgrade_versions.sh b/installer/upgrade_versions.sh
index 38b7c11741..d172373e50 100755
--- a/installer/upgrade_versions.sh
+++ b/installer/upgrade_versions.sh
@@ -30,6 +30,11 @@ FILES=(
   "./k8s/Chart.yaml"
   "./k8s/Chart.yaml"
   "./k8s/README.md"
+  # all-in-one
+  "./all-in-one/Dockerfile"
+  "./all-in-one/README.md"
+  # root README (try-it-out command)
+  "../README.md"
 )
 
 if [ "$#" -gt 1 ]; then