Kaneo Supported Platforms: 3 Ways to Deploy the Open-Source Project Management Tool

TL;DR: Kaneo supports deployment via drim (one-click CLI), Docker Compose, and Kubernetes with Helm, making it deployable anywhere Docker containers can run.

Kaneo is a self-hostable project management platform designed for Docker-native environments. The usekaneo/kaneo repository provides first-class support for three distinct deployment platforms, ranging from quick local setups to production-grade orchestrated clusters.

One-Click Deployment with drim

drim is Kaneo's official CLI tool for zero-configuration deployment. It provisions the complete stack—including Docker, HTTPS, database, and all required services—with a single command.

curl -fsSL https://assets.kaneo.app/install.sh | sh
drim setup

The installation script detects your operating system, installs Docker if absent, generates the necessary .env file, and launches all containers automatically. This method is documented in [README.md](https://github.com/usekaneo/kaneo/blob/main/README.md#57) lines 57–70.

Docker Compose for Local and Simple Production Use

The fastest way to run Kaneo locally or on a single server is the official compose.yml file shipped in the repository root.

Complete Compose Configuration

# compose.yml — sourced from github.com/usekaneo/kaneo

services:
  postgres:
    image: postgres:16-alpine
    env_file: .env
    ports: ["5432:5432"]
    volumes: ["postgres_data:/var/lib/postgresql/data"]
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U kaneo -d kaneo"]
      interval: 10s
      timeout: 5s
      retries: 5

  kaneo:
    image: ghcr.io/usekaneo/kaneo:latest
    ports: ["5173:5173"]
    env_file: .env
    depends_on:
      postgres:
        condition: service_healthy
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider",
             "http://127.0.0.1:5173/api/health"]
      interval: 30s
      timeout: 5s
      start_period: 60s
      retries: 3

volumes:
  postgres_data:

Start the stack:

docker compose up -d

The compose file defines health checks for both PostgreSQL and the Kaneo application container, ensuring reliable startup ordering via depends_on with condition: service_healthy.

Kubernetes Deployment with Helm

For scalable, high-availability production environments, Kaneo provides an official Helm chart in charts/kaneo/.

Installation Commands

helm upgrade --install kaneo ./charts/kaneo \
  --set api.replicaCount=2 \
  --set web.replicaCount=2 \
  --set postgresql.auth.password=$(openssl rand -hex 16)

The chart deploys three components:

• API service — configurable replica count and resource limits
• Web frontend — separately scalable from the API
• PostgreSQL — with persistent volume claims and authentication options

Optional configurations include Ingress resources or Gateway API for external traffic management. Supported Kubernetes versions and detailed parameters are documented in [charts/kaneo/README.md](https://github.com/usekaneo/kaneo/blob/main/charts/kaneo/README.md).

Key Configuration Files by Platform

Platform	Primary File	Purpose
drim	README.md lines 57–70	Installation and CLI usage
Docker Compose	compose.yml (root)	Full-stack container orchestration
Kubernetes	charts/kaneo/	Helm chart with templates and values.yaml
All platforms	ENVIRONMENT_SETUP.md	Environment variable reference

Platform Selection Guide

• Choose drim when you want the fastest path to a working instance with automatic HTTPS and minimal manual steps.

• Choose Docker Compose for local development, testing, or simple single-server deployments where you need direct control over compose.yml.

• Choose Kubernetes/Helm when you require horizontal scaling, rolling updates, or integration with existing cluster infrastructure.

Summary

• Kaneo runs anywhere Docker containers are supported—no platform-specific binaries required.

• drim provides true one-command deployment with automatic provisioning.

• Docker Compose offers transparency and control through the repository's compose.yml.

• Helm chart in charts/kaneo/ enables enterprise-grade Kubernetes deployments with configurable replicas and ingress.

• All platforms share the same environment variable configuration documented in ENVIRONMENT_SETUP.md.

Frequently Asked Questions

What is the easiest way to deploy Kaneo for the first time?

The drim CLI is the easiest method. Run the install script and drim setup to get a fully configured instance with HTTPS, database, and health checks—no manual Docker configuration required.

Can I run Kaneo without Kubernetes?

Yes. Docker Compose is fully supported for production and development use. The compose.yml in the repository root includes health checks and proper service dependencies for reliable operation without Kubernetes complexity.

Does Kaneo support ARM architectures?

The official images at ghcr.io/usekaneo/kaneo:latest and postgres:16-alpine used in compose.yml support multi-architecture builds. The drim installer detects your OS architecture automatically during setup.

Where are environment variables documented?

All platform-specific and shared environment variables are detailed in [ENVIRONMENT_SETUP.md](https://github.com/usekaneo/kaneo/blob/main/ENVIRONMENT_SETUP.md), including database connection strings, API keys, and optional feature toggles.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}