Skip to content
KNIME Documentation
Main Navigation Get startedBuildWork with KnimeAccount and adminRelease notesDeveloper tools
Community Hub
DevelopersKnime
Sidebar Navigation

Getting Started

Installation

User Guide

Release Notes

Install Extensions

Building Workflows

Components

Flow Control

Expressions

File Handling

Deployment

Integrated Deployment

Workflow Invocation

Best Practices

Advanced Features

AI Extension

Get Started

Build an Agent

Inject context with RAG

LLM Providers

Tutorials

Summarize product reviews

Product FAQ assistant

Restaurant agent

Your first local agent

Task extractor

Reporting

Kerberos

Extensions

Database

Overview

Tutorials

Read and filter data from a database

Write a transformed dataset to a database

Concepts

Ports and Sessions

Query Generation

Type Mapping

Deprecated Framework

Connecting

Connect: Dedicated Node

Connect: File-Based Database

Connect: Generic DB Connector

Register a JDBC Driver

Install Third-Party Driver Plug-in

Drivers on Hub and Server

Kerberos Constrained Delegation

Reading and Transforming

Read Data

Transform Data Visually

Run a Custom SQL Query

Parameterize a Query

Writing and Modifying

Insert, Update, or Merge

Delete Rows

Bulk Load Data

Create and Remove Tables

Use Transactions

Reference

Connector Node Settings

JDBC Driver Reference

Deprecated Node Mapping

Migrate Deprecated Workflows

Python

Overview

Tutorials

Python Scripting Quickstart

Data App Development Using Plotly

Data Processing

K-AI Scripting Assistant

Data Type Conversion

Batch Processing

Jupyter Integration

Environment Management

Pixi Configuration

Dependency Management

Environment Persistence

Channel Mirrors & Air-Gapped Setups

Conda Migration

Alternative Configurations

Conda and Miniforge Setup

Conda Environment Propagation

Manual Python Configuration

Legacy Node Migration

Concepts

Pixi Backend Architecture

Storage Logic

Python Environments on Executors

Reference

Python Scripting API

Bundled Packages

Executor and Hub Configuration

Troubleshooting Guide

API Reference

Inputs and outputs

Classes

Views

Utility functions

R

Deep Learning

Snowflake

Google Cloud

Azure

AWS

Big Data

Big Data Admin

Big Data Secured Cluster

Databricks

Microsoft Fabric

Power BI

Tableau

Report Designer

H2O

Changelogs

Version 5.12

Version 5.11

Version 5.10

Version 5.9

Version 5.8

Version 5.7

Version 5.6

Version 5.5

Version 5.3

Extensions

Python Environments on Executors ​

When a workflow runs on a KNIME Executor inside KNIME Business Hub, Python nodes need access to a Python environment. There are three types of environments available on executors, each with different characteristics regarding performance, flexibility, governance, and persistence.

Environment types ​

Bundled environment ​

The bundled environment is pre-packaged with KNIME and requires no configuration. It is always available on the executor and does not depend on any external package repositories at runtime. For the list of included packages, see Bundled Packages.

Pre-installed custom environments ​

Python environments can be embedded into the executor image at build time, using the Execution Image Builder or by installing conda environments directly into a custom image. These environments are available immediately when the executor starts and survive executor restarts.

Pre-installed environments are configured for use in Python Script nodes via:

  • executor preferences (globally for all workflows on that executor)
  • the python3_command flow variable (per workflow)
  • the Conda Environment Propagation node in Check name only mode, which matches a pre-installed environment by name without overwriting it

Pre-installed environments are static: updating them requires rebuilding the executor image. They also increase the size of the executor image.

On-the-fly environments ​

On-the-fly environments are created during workflow execution using the Conda Environment Propagation node or the Python Environment Provider node. They are not present in the executor image; instead, they are installed at runtime when the workflow runs.

On-the-fly environments are matched to existing environments on the executor by name. Once created, they persist on the executor until it is restarted. In multi-executor setups, each executor instance creates its own copy of the environment independently.

Because environments are matched by name, naming collisions between workflows are possible. A specific naming format helps avoid this:

knimeenv_<workflowName>_<envName>

On-the-fly environments require the executor to have network access to conda and pip package repositories at runtime. In restricted network environments, this requires configuring channel mirrors or proxy settings (see Channel Mirrors & Air-Gapped Setups).

Security

Installing environments at runtime pulls packages from external sources. These packages may be subject to CVEs and can execute code during installation. Consider using vetted mirrors or internal channels.

Comparison ​

AspectPre-installed environmentsOn-the-fly environments
PerformanceNo install overhead at runtimeSlower on first run; environment must be created
Update flexibilityRequires rebuilding the executor imageChangeable per workflow or per run
GovernanceCentrally defined; easy to auditDecentralized; all workflows can contribute environments
Resilience to restartsSurvive executor restartsLost on restart; recreated on next execution
Multi-executor setupsAvailable on all instances from imageMust be created on each executor instance separately
Runtime network accessNot requiredRequired (conda/pip repositories or configured mirrors)

Related pages ​

  • Hub & Executor Configuration
  • Use the Conda Environment Propagation node
  • Set up Pixi (Python Environment Provider)
Pager
Previous pageStorage Logic
Next pagePython Scripting API