Default Helm deployment

Last updated: 10/22/2026

Helm charts allow you to deploy Dynamic Engine with custom namespaces, service names, and storage configurations.

Dynamic Engine Helm charts are available as images under oci://ghcr.io/talend/helm/ and include:

dynamic-engine-crd: Core custom resource definitions for Dynamic Engine services.
dynamic-engine: Helm chart for a Dynamic Engine instance.
dynamic-engine-environment: Helm chart for Dynamic Engine environments.

Before you begin

A Kubernetes cluster without existing Dynamic Engine services. Dynamic Engine Helm charts will be installed in this cluster.
Privileged access to this Kubernetes cluster.
Installed command-line tools: kubectl and helm. The Helm version must be 3.17.2 or later.

About this task

The following procedure describes the default deployment, using only default Helm values files.

Important:

Dynamic Engine versions earlier than 1.6:
Dynamic Engine always requires persistent shared storage.
Dynamic Engine 1.6.x:
Persistent shared storage is enabled by default. You can disable it for Dynamic Engine internal services by adding --set configuration.persistence.enabled=false to both the helm install dynamic-engine and helm install dynamic-engine-environment commands in this procedure.
Dynamic Engine 1.7.0 or later:
Persistence is disabled by default. The default deployment does not create PVCs or PVs and does not require distributed storage.

To persist DI (data integration) Job data, add this configuration to the environment values file:
```
configuration:
   persistence:
   enabled: true
   defaultStorageClassName: <storage-class-name-or-null> 
```
To persist images in the embedded registry (for non-production use only), configure its persistence separately in the engine values file:
```
configuration:
  dockerRegistry:
  persistence:
  enabled: true
  persistence:
  defaultStorageClassName: <storage-class-name-or-null>
```
If the embedded registry pod restarts without persistence, its images are lost. For production use, use an external registry or enable persistence for the embedded registry.

Procedure

Use the dynamic-engine-crd Helm chart to install the Dynamic Engine custom resource definitions of a given Helm version.
1. The chart version to use is the same as your Dynamic Engine version. You can find this version using one of the following methods:
  - Run the following Helm command:
    helm show chart oci://ghcr.io/talend/helm/dynamic-engine --version ${DYNAMIC_ENGINE_VERSION}
  - See the version directly from Talend Management Console or check the Dynamic Engine changelog for the chart version included in your Dynamic Engine version.
  - Use an API call to the Dynamic Engine version endpoint.
2. In the Kubernetes cluster, run the following command to install the Helm chart of a given version:
```
helm install dynamic-engine-crd oci://ghcr.io/talend/helm/dynamic-engine-crd \
  --version ${DYNAMIC_ENGINE_VERSION}
```
  Set ${DYNAMIC_ENGINE_VERSION} to the chart version supported by your Dynamic Engine version.
  Without specifying the version, you install the latest available dynamic-engine-crd chart version.
In the Kubernetes machine, unzip the Helm deployment zip file previously downloaded.

Run this command to deploy the engine instance:

helm install dynamic-engine-$DYNAMIC_ENGINE_ID \
  oci://ghcr.io/talend/helm/dynamic-engine \
  --version ${DYNAMIC_ENGINE_VERSION} -f $DYNAMIC_ENGINE_ID-values.yaml

Replace $DYNAMIC_ENGINE_ID with the Dynamic Engine ID, for example, c-m-sjufu4qy.

Verify Dynamic Engine status by running this command:

kubectl get de -A

You should see information similar to this:

NAME                               VERSION   STATUS    LAST UPDATE
qlik-dynamic-engine-$DYNAMIC_ENGINE_ID   0.22.0    RUNNING   2m

Run this command to deploy the Dynamic Engine environment.

helm install dynamic-engine-environment-$DYNAMIC_ENGINE_ENVIRONMENT_ID \
  oci://ghcr.io/talend/helm/dynamic-engine-environment \
  --version ${DYNAMIC_ENGINE_VERSION} -f $DYNAMIC_ENGINE_ENVIRONMENT_ID-values.yaml

Replace $DYNAMIC_ENGINE_ENVIRONMENT_ID with the Dynamic Engine environment ID, for example, 67f7d562ffd7c3525a902542.

Verify environment resources.
1. Run the following command:
```
kubectl get dee -A
```
  You should see information reading like this:
```
NAME                                           VERSION   STATUS    LAST UPDATE
qlik-processing-env-$DYNAMIC_ENGINE_ENVIRONMENT_ID   0.22.0    RUNNING   3m
```
2. In Talend Management Console, verify the Dynamic Engine environment status.
  The status should show as Ready.

Results

Once done successfully, the Dynamic Engine environment services are installed in your cluster and connect to the Dynamic Engine.

In Talend Management Console, the status of this environment becomes Ready, confirming that it is ready to run tasks or plans.

If the deployment fails or the Dynamic Engine services are disassociated from the Dynamic Engine, the status become Not ready.

What to do next

Since the Dynamic Engine has been successfully deployed in your Kubernetes, connected to Talend Management Console, and associated with a Dynamic Engine environment, it is ready to run tasks or plans as you usually do on the standard engines. For details about how to add the task to the Dynamic Engine environment for a run, see Adding tasks to a Dynamic Engine environment.

Did this page help you?

If you find any issues with this page or its content – a typo, a missing step, or a technical error – please let us know!

Leave your feedback here