Skip to content
Klutch.sh Docs

Deploying an Indico App

Introduction

Indico is an open-source event management platform built with Python and PostgreSQL. Deploying Indico with a Dockerfile on Klutch.sh provides reproducible builds, managed secrets, and persistent storage for uploads and archival files—all accessible from klutch.sh/app. This guide walks through installation, repository prep, a production-ready Dockerfile, deployment steps, Nixpacks overrides, and best practices for reliable conferences and scheduling.

Prerequisites

  • A Klutch.sh account (create one)
  • A GitHub repository with your Indico code/config (GitHub is the only supported git source)
  • Docker familiarity and Python 3.10+ toolchain knowledge
  • PostgreSQL and Redis credentials
  • Adequate persistent storage for uploads and archival exports

For platform onboarding, see the Quick Start.

Architecture and ports

  • Indico serves HTTP via uWSGI/Flask; set the internal container port to 8000.
  • PostgreSQL and Redis should run as separate Klutch.sh TCP apps. Expose them on port 8000 and connect internally on 5432 (Postgres) and 6379 (Redis).
  • Persistent storage is required for uploads, cached files, and optionally logs.

Repository layout

indico/
├── indico/                 # Application source
├── etc/indico.conf         # Main Indico config (template)
├── logs/                   # Optional log directory
├── uploads/                # User uploads and attachments (mount as volume)
├── Dockerfile              # Must be at repo root for auto-detection
├── requirements.txt
├── requirements.dev.txt
└── README.md

Keep secrets out of Git; manage them with Klutch.sh environment variables.

Installation (local) and starter commands

Install dependencies and run Indico locally before pushing to GitHub:

Terminal window
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
export INDICO_CONFIG=/app/etc/indico.conf
indico db upgrade
indico run -h 0.0.0.0 -p 8000

Optional helper start.sh for portability and Nixpacks fallback:

#!/usr/bin/env bash
set -euo pipefail
export INDICO_CONFIG=${INDICO_CONFIG:-/app/etc/indico.conf}
indico db upgrade
exec indico run -h 0.0.0.0 -p 8000

Make it executable with chmod +x start.sh.

Dockerfile for Indico (production-ready)

Place this Dockerfile at the repo root; Klutch.sh auto-detects it (no Docker toggle in the UI):

FROM python:3.11-slim
WORKDIR /app


# System dependencies for Indico and psycopg2
RUN apt-get update && apt-get install -y build-essential libpq-dev curl && \
    rm -rf /var/lib/apt/lists/*


COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt


COPY . .


ENV INDICO_CONFIG=/app/etc/indico.conf \
    PORT=8000


EXPOSE 8000
CMD ["indico", "run", "-h", "0.0.0.0", "-p", "8000"]

Notes:

  • Pin Python and requirements versions to match your Indico release.
  • For uWSGI/Gunicorn deployment, swap the CMD for your preferred WSGI runner while keeping EXPOSE 8000.

Environment variables (Klutch.sh)

Set these in the Klutch.sh app settings (Secrets tab) before deploying:

  • PORT=8000
  • INDICO_CONFIG=/app/etc/indico.conf
  • SQLALCHEMY_DATABASE_URI=postgresql+psycopg2://<user>:<password>@<host>:<port>/<db>
  • REDIS_CACHE_URL=redis://<user>:<password>@<host>:<port>/0
  • INDICO_SECRET_KEY=<secure-random-string>
  • INDICO_SECURITY_PASSWORD_SALT=<secure-random-string>
  • BASE_URL=https://example-app.klutch.sh

If you deploy without the Dockerfile and need Nixpacks overrides:

  • NIXPACKS_BUILD_CMD=pip install -r requirements.txt
  • NIXPACKS_START_CMD=indico run -h 0.0.0.0 -p 8000
  • NIXPACKS_PYTHON_VERSION=3.11

These keep Indico compatible with Nixpacks defaults when a Dockerfile is absent.

Attach persistent volumes

In Klutch.sh storage settings, add mount paths and sizes (no names required):

  • /app/uploads — required for attachments and user-generated files.
  • /app/logs — optional if you store logs on disk.

Ensure these paths are writable inside the container.

Deploy Indico on Klutch.sh (Dockerfile workflow)

  1. Push your repository (with the Dockerfile at the root) to GitHub.
  2. Open klutch.sh/app, create a project, and add an app.
  3. Connect the GitHub repository; Klutch.sh automatically detects the Dockerfile.
  4. Choose HTTP traffic for Indico.
  5. Set the internal port to 8000.
  6. Add the environment variables above (database, Redis, Indico secrets, and any NIXPACKS_* overrides if you temporarily deploy without the Dockerfile).
  7. Attach persistent volumes for /app/uploads (and /app/logs if used), selecting sizes that fit your event storage needs.
  8. Deploy. Your Indico site will be reachable at https://example-app.klutch.sh; attach a custom domain if desired.

For PostgreSQL or Redis on Klutch.sh, create separate TCP apps, expose them on port 8000, and point SQLALCHEMY_DATABASE_URI or REDIS_CACHE_URL to those endpoints (internal ports 5432/6379).

Health checks and production tips

  • Add a /health or /ping endpoint for uptime monitoring.
  • Enable HTTPS at the edge; forward HTTP to port 8000 internally.
  • Keep lockfiles and requirement pins for reproducible builds.
  • Monitor volume usage for /app/uploads and resize before it fills.
  • Back up PostgreSQL and uploads regularly; do not rely on container filesystems for durability.

Indico on Klutch.sh combines reproducible Docker builds with managed secrets, persistent storage for event assets, and flexible HTTP/TCP routing. With the Dockerfile at the repo root and ports set to 8000 for the app (8000 externally for TCP databases or caches), you can deliver reliable event management without extra YAML or workflow overhead.