Run Konduo Community with Docker Compose in 10 Minutes

Konduo is an integrated operations management platform for managing multiple operating targets in one workflow. It connects resources such as Redis, PostgreSQL, Kafka, etcd, MySQL, and MariaDB through plugins, so teams can inspect status, metric evidence, dashboards, and alert response in the same operating context.

The current Community resource and operations plugins cover Konduo self-observability, Host, Redis, Kafka, PostgreSQL, MySQL/MariaDB, etcd, Keycloak, Prometheus, Milvus, OpenSearch, and Synology. Alert delivery plugins include Email, Webhook, and Telegram channels. In other words, Konduo is closer to a common operations surface for registering, observing, and responding to many targets than to a single-system monitoring tool.

Konduo Community Edition is not a mock demo image. It is the product version where the Community feature set actually runs. Even in a local or PoC environment, you can register resources, connect metric sources, inspect dashboards, and configure alert rules and channels. The Community frontend, backend, and manual images are available under the pletorco namespace on Docker Hub, so Docker Compose is enough to start a basic stack with PostgreSQL, Prometheus, and the offline manual.

This quickstart runs five components with Docker Compose:

Konduo frontend
Konduo backend
Konduo manual, optional
PostgreSQL
Prometheus

If you already operate Prometheus, you can connect your existing Prometheus instead. For a first local run, it is usually easier to include Prometheus in the same Compose stack. This post starts from that assumption.

The manual is optional too. This example includes the manual service so first-time users can open product documentation from the same origin as the UI. If you already use an external documentation site or do not want to deploy the manual, remove the manual service and leave KONDUO_MANUAL_URL empty.

Small service modules connected by a soft glow as one local system comes online — A few containers are enough to make the core Konduo Community flow visible on your local machine.

Docker Compose diagram where a browser reaches Konduo frontend, frontend connects to backend and manual, and backend uses PostgreSQL while Prometheus scrapes backend metrics — The quickstart runs frontend, backend, optional manual, PostgreSQL, and Prometheus together in one Compose environment.

The short version

For a local first run, the flow is simple:

Pull pletorco/konduo-frontend, pletorco/konduo-backend, and pletorco/konduo-manual-ce from Docker Hub.
Run PostgreSQL for Konduo system data.
Run Prometheus to scrape backend /metrics and enable the remote write receiver.
Optionally run the manual image and let frontend nginx proxy it under /manual/.
Open http://localhost:5173 in your browser.
Log in with admin / admin123! and immediately change the password.

This setup is suitable for local validation, PoC, and fast product exploration, but it is not just a static demo. The real Community backend and frontend run, the manual can open under the same-origin /manual/ path when included, and you can connect Prometheus metric sources and resources to verify the operating flow. Because the Prometheus remote write receiver is enabled, you can also try plugin flows that use managed metric collect. For production, review TLS, backup, external PostgreSQL, image tag or digest pinning, secret handling, and network exposure separately.

Prerequisites

You need Docker and Docker Compose.

docker version
docker compose version

This post uses the public Docker Hub images:

pletorco/konduo-backend:latest
pletorco/konduo-frontend:latest
pletorco/konduo-manual-ce:latest

As of June 30, 2026, Docker Hub provides latest tags for the Community backend, frontend, and manual CE images. latest is convenient for quick exploration, but version tags or digest pinning are better for repeatable validation and pre-production tests.

Create a working directory

Create a working directory first.

mkdir -p konduo-quickstart/prometheus
cd konduo-quickstart

This directory will contain .env, compose.yml, and prometheus/prometheus.yml.

Prepare secrets

KONDUO_SECRET_KEY is used to encrypt stored secrets such as resource configuration and credentials. Generate it once and keep it stable across container restarts and upgrades.

openssl rand -hex 32

Generate a separate JWT_SECRET too.

openssl rand -hex 32

Write `.env`

Create .env.

GO_ENV=development

DB_NAME=konduo
DB_USER=konduo
DB_PASSWORD=change-this-db-password
DB_SSLMODE=disable

JWT_SECRET=change-this-jwt-secret
KONDUO_SECRET_KEY=replace-with-openssl-rand-hex-32
KONDUO_ALERT_INSTANCE_LABEL=QUICKSTART CE
KONDUO_PUBLIC_URL=

BACKEND_IMAGE_REF=pletorco/konduo-backend:latest
FRONTEND_IMAGE_REF=pletorco/konduo-frontend:latest
MANUAL_IMAGE_REF=pletorco/konduo-manual-ce:latest

KONDUO_MANUAL_URL=/manual/
MANUAL_UPSTREAM=manual:8080
MANUAL_PORT=8088

Replace DB_PASSWORD, JWT_SECRET, and KONDUO_SECRET_KEY with your own generated values.

Add Prometheus configuration

If you do not already have Prometheus, run it with the Compose stack. Konduo backend exposes /metrics, so Prometheus only needs to scrape the backend service.

Some recently added plugins use managed metric collect flows where Konduo sends collected metrics to Prometheus through the remote write API. To try those features, Prometheus must run as a remote write receiver. The Compose example in this guide includes the --web.enable-remote-write-receiver Prometheus flag.

prometheus/prometheus.yml:

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: konduo-backend
    metrics_path: /metrics
    static_configs:
      - targets:
          - backend:8080

If you already have Prometheus, add the same scrape target to your existing configuration instead. Inside this Compose stack the target is backend:8080; from an external Prometheus, use the reachable host and port. If you plan to use managed metric collect, make sure that existing Prometheus also has the remote write receiver enabled.

Write `compose.yml`

The following compose.yml runs frontend, backend, optional manual, PostgreSQL, and Prometheus together. If you do not need the manual, remove the manual service and the frontend MANUAL_UPSTREAM setting, then leave KONDUO_MANUAL_URL empty in .env.

services:
  backend:
    image: ${BACKEND_IMAGE_REF}
    environment:
      GO_ENV: ${GO_ENV:-development}
      PORT: "8080"
      PLUGIN_PACKAGE_DIR: /app/data/plugins
      AUTO_GENERATE_ENV: "true"
      DB_TYPE: postgres
      DB_HOST: postgres
      DB_PORT: "5432"
      DB_NAME: ${DB_NAME:-konduo}
      DB_USER: ${DB_USER:-konduo}
      DB_PASSWORD: ${DB_PASSWORD}
      DB_SSLMODE: ${DB_SSLMODE:-disable}
      JWT_SECRET: ${JWT_SECRET}
      KONDUO_SECRET_KEY: ${KONDUO_SECRET_KEY}
      KONDUO_ALERT_INSTANCE_LABEL: ${KONDUO_ALERT_INSTANCE_LABEL:-}
      KONDUO_PUBLIC_URL: ${KONDUO_PUBLIC_URL:-}
    ports:
      - "8080:8080"
    volumes:
      - konduo_data:/data
    depends_on:
      postgres:
        condition: service_healthy
    restart: unless-stopped

  frontend:
    image: ${FRONTEND_IMAGE_REF}
    environment:
      BACKEND_UPSTREAM: backend:8080
      KONDUO_MANUAL_URL: ${KONDUO_MANUAL_URL-/manual/}
      MANUAL_UPSTREAM: ${MANUAL_UPSTREAM-manual:8080}
      NGINX_PORT: "8080"
    depends_on:
      - backend
    ports:
      - "5173:8080"
    restart: unless-stopped

  manual:
    image: ${MANUAL_IMAGE_REF}
    ports:
      - "${MANUAL_PORT:-8088}:8080"
    restart: unless-stopped

  postgres:
    image: postgres:16-alpine
    shm_size: "256mb"
    environment:
      POSTGRES_DB: ${DB_NAME:-konduo}
      POSTGRES_USER: ${DB_USER:-konduo}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    ports:
      - "5432:5432"
    volumes:
      - konduo_postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${DB_USER:-konduo} -d ${DB_NAME:-konduo}"]
      interval: 10s
      timeout: 5s
      retries: 10
    restart: unless-stopped

  prometheus:
    image: prom/prometheus:v3.5.4
    command:
      - --config.file=/etc/prometheus/prometheus.yml
      - --storage.tsdb.path=/prometheus
      - --web.enable-remote-write-receiver
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prometheus_data:/prometheus
    ports:
      - "9090:9090"
    depends_on:
      - backend
    restart: unless-stopped

volumes:
  konduo_data:
  konduo_postgres_data:
  prometheus_data:

Start the stack

Pull the images and start the stack.

docker compose --env-file .env -f compose.yml pull
docker compose --env-file .env -f compose.yml up -d
docker compose --env-file .env -f compose.yml ps

Use this command to follow backend logs:

docker compose --env-file .env -f compose.yml logs -f backend

Verify access

Open the frontend in your browser.

http://localhost:5173

Check backend status with:

curl http://localhost:8080/api/v1/system/version
curl http://localhost:8080/metrics

Open Prometheus at:

http://localhost:9090

In Prometheus, go to Status > Targets. If the konduo-backend target is UP, backend metric scraping is working.

When included, the manual is served by frontend nginx under the same-origin /manual/ path.

curl -fsS http://localhost:5173/runtime-config.json
curl -fsS http://localhost:5173/manual/manual-build.json

Open it in a browser:

http://localhost:5173/manual/

You can also check the directly exposed manual service port:

http://localhost:8088

When the UI language is Korean or English, the top-bar Manual link opens the matching language path. If you deploy without the manual service, set an empty value such as KONDUO_MANUAL_URL= in .env to hide the link.

After installation, log in with the default administrator account.

Username: admin
Password: admin123!

Change the administrator password immediately after login. Do not expose a running environment to an external network while the default password is still active.

Recommended first-login flow:

Open http://localhost:5173.
Log in with admin / admin123!.
If the password change screen appears, enter admin123! as the current password.
Enter and confirm the new administrator password.
Save the change and log out.
Confirm that you can log in again with the new password.

Next steps

After the quickstart works, connect the real targets that Konduo will observe and operate.

Register a Prometheus metric source.
Confirm Prometheus remote write receiver if you use plugins with managed metric collect.
Use the manual for installation and operations workflows if you include it.
Add resources such as Redis, Kafka, PostgreSQL, MySQL/MariaDB, etcd, Keycloak, Milvus, OpenSearch, Synology, or Host.
Check dashboards and alert rules.
Connect Email, Webhook, or Telegram alert channels.
Use version tags or digest pinning for operational validation.

The important point is that Konduo is not just a collection of links to different systems. Its product direction is to keep resource status, Prometheus-backed metrics, dashboards, alert rules, alert channels, operating permissions, and history in one workflow. The Docker Compose quickstart is not a limited demo; it is the smallest practical way to see that real flow locally.

Checklist

Before calling the quickstart complete, check:

Are you using pletorco/konduo-backend and pletorco/konduo-frontend?
If you include the manual, are you using pletorco/konduo-manual-ce?
Did you generate and keep a stable KONDUO_SECRET_KEY?
Is the PostgreSQL volume persistent?
Is the Prometheus target konduo-backend UP?
Is Prometheus running with --web.enable-remote-write-receiver?
If you include the manual, does http://localhost:5173/manual/ open it?
Did you change the default administrator password after first login?
Before external exposure, did you review TLS, firewall, backup, and tag pinning?

The goal of the quickstart is not a perfect production topology. It is to make the product flow visible quickly. Once that is clear, strengthen persistence, security, and deployment boundaries for your real environment.