Skip to content
Klutch.sh Docs

Deploying a Knime App

Introduction

KNIME is an open-source data analytics platform for building workflows and running them at scale. Deploying KNIME with a Dockerfile on Klutch.sh provides reproducible builds, managed secrets, and persistent storage for workflows and results—all configured from klutch.sh/app. This guide covers installation, repository prep, a production-ready Dockerfile, deployment steps, Nixpacks overrides, and best practices to keep your analytics environment dependable.

Prerequisites

  • A Klutch.sh account (create one)
  • A GitHub repository containing your KNIME server files or custom configuration (GitHub is the only supported git source)
  • Docker familiarity and Java 11+ knowledge
  • Storage for workflows, data, and logs
  • Optional database credentials if you connect KNIME to external data sources

For platform onboarding, see the Quick Start.

Architecture and ports

  • KNIME WebPortal serves HTTP; set the internal container port to 8080.
  • If you use databases or caches, deploy them as separate Klutch.sh TCP apps exposed on port 8000 and connect on their native ports.
  • Persistent storage is required for workflow repositories and recommended for logs/results.

Repository layout

knime/
├── workflows/              # KNIME workflows (mount as volume)
├── config/                 # server configuration files
├── Dockerfile              # Must be at repo root for auto-detection
└── README.md

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

Installation (local) and starter commands

Test locally before pushing to GitHub:

Terminal window
docker run --rm -p 8080:8080 \
  -v $(pwd)/workflows:/opt/knime/workflows \
  -e KNIME_LICENSE_ACCEPT=yes \
  knime/knime-server:latest

Optional helper start.sh for portability and Nixpacks fallback:

#!/usr/bin/env bash
set -euo pipefail
exec /opt/knime/knime-server/knime-server.sh

Make it executable with chmod +x start.sh.

Dockerfile for KNIME (production-ready)

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

FROM knime/knime-server:latest


WORKDIR /opt/knime


# Optional: copy custom configuration and workflows
COPY config /opt/knime/config
COPY workflows /opt/knime/workflows


EXPOSE 8080
CMD ["/opt/knime/knime-server/knime-server.sh"]

Notes:

  • Pin the image tag (e.g., :4.16.2) for reproducible builds.
  • If you use extensions, include them in the image or mount them via volume.

Environment variables (Klutch.sh)

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

  • PORT=8080
  • KNIME_LICENSE_ACCEPT=yes
  • KNIME_WEBPORTAL_CONTEXT_PATH=/
  • KNIME_WEBPORTAL_HOSTNAME=example-app.klutch.sh
  • KNIME_REST_ENABLED=true
  • Database connection env vars as needed for your workflows

If you deploy without the Dockerfile and need Nixpacks overrides:

  • NIXPACKS_BUILD_CMD="echo KNIME uses prebuilt image"
  • NIXPACKS_START_CMD=/opt/knime/knime-server/knime-server.sh
  • NIXPACKS_JDK_VERSION=11

These keep KNIME 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):

  • /opt/knime/workflows — required for workflow repositories.
  • /opt/knime/logs — optional if you want to persist logs.
  • /opt/knime/data — optional for intermediate data or results.

Ensure these paths are writable inside the container.

Deploy KNIME 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.
  1. Connect the GitHub repository; Klutch.sh automatically detects the Dockerfile.
  2. Choose HTTP traffic for KNIME.
  3. Set the internal port to 8080.
  4. Add the environment variables above (license acceptance, hostname, REST toggle, DB settings, and any NIXPACKS_* overrides if you temporarily deploy without the Dockerfile).
  5. Attach persistent volumes for /opt/knime/workflows (and /opt/knime/logs or /opt/knime/data if used), selecting sizes that match your workflows and storage needs.
  6. Deploy. Your KNIME WebPortal will be reachable at https://example-app.klutch.sh; attach a custom domain if desired.

Sample REST call

Trigger a workflow job via REST (example endpoint; adjust for your setup):

Terminal window
curl -X POST "https://example-app.klutch.sh/knime/rest/v4/repository/Examples/01_Intro/01_Workflow" \
  -u admin:change_me

Health checks and production tips

  • Use a reverse proxy health check against / or a simple REST endpoint.
  • Enforce HTTPS at the edge; forward HTTP to port 8080 internally.
  • Pin image tags and extensions; upgrade intentionally.
  • Monitor disk usage on /opt/knime/workflows and /opt/knime/logs; resize volumes before they fill.
  • Back up workflow directories and external databases regularly; do not rely on container filesystems for durability.

KNIME on Klutch.sh combines reproducible Docker builds with managed secrets, persistent storage for workflows, and flexible HTTP/TCP routing. With the Dockerfile at the repo root and port 8080 configured, you can deliver dependable data analytics without extra YAML or workflow overhead.