Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. Kubernetes
  3. API Docs
  4. helm
  5. helm/v4
  6. Chart
Kubernetes v4.22.1 published on Friday, Mar 14, 2025 by Pulumi
pulumi/pulumi-kubernetes

kubernetes.helm.sh/v4.Chart

Explore with Pulumi AI

Kubernetes v4.22.1 published on Friday, Mar 14, 2025 by Pulumi
pulumi/pulumi-kubernetes

Looking for the Release resource? Please use the v3 package for production use cases, and stay tuned for an updated Release resource, coming soon.

See also: New: Helm Chart v4 resource with new features and languages

Chart is a component representing a collection of resources described by a Helm Chart. Helm charts are a popular packaging format for Kubernetes applications, and published to registries such as Artifact Hub.

Chart does not use Tiller or create a Helm Release; the semantics are equivalent to running helm template --dry-run=server and then using Pulumi to deploy the resulting YAML manifests. This allows you to apply Pulumi Transformations and Pulumi Policies to the Kubernetes resources.

You may also want to consider the Release resource as an alternative method for managing helm charts. For more information about the trade-offs between these options, see: Choosing the right Helm resource for your use case.

Chart Resolution

The Helm Chart can be fetched from any source that is accessible to the helm command line. The following variations are supported:

  1. By chart reference with repo prefix: chart: "example/mariadb"
  2. By path to a packaged chart: chart: "./nginx-1.2.3.tgz"
  3. By path to an unpacked chart directory: chart: "./nginx"
  4. By absolute URL: chart: "https://example.com/charts/nginx-1.2.3.tgz"
  5. By chart reference with repo URL: chart: "nginx", repositoryOpts: { repo: "https://example.com/charts/" }
  6. By OCI registry: chart: "oci://example.com/charts/nginx", version: "1.2.3"

A chart reference is a convenient way of referencing a chart in a chart repository.

When you use a chart reference with a repo prefix (example/mariadb), Pulumi will look in Helm’s local configuration for a chart repository named example, and will then look for a chart in that repository whose name is mariadb. It will install the latest stable version of that chart, unless you specify devel to also include development versions (alpha, beta, and release candidate releases), or supply a version number with version.

Use the verify and optional keyring inputs to enable Chart verification. By default, Pulumi uses the keyring at $HOME/.gnupg/pubring.gpg. See: Helm Provenance and Integrity.

Chart Values

Values files (values.yaml) may be supplied with the valueYamlFiles input, accepting Pulumi Assets.

A map of chart values may also be supplied with the values input, with highest precedence. You’re able to use literals, nested maps, Pulumi outputs, and Pulumi assets as values. Assets are automatically opened and converted to a string.

Note that the use of expressions (e.g. --set service.type) is not supported.

Chart Dependency Resolution

For unpacked chart directories, Pulumi automatically rebuilds the dependencies if dependencies are missing and a Chart.lock file is present (see: Helm Dependency Build). Use the dependencyUpdate input to have Pulumi update the dependencies (see: Helm Dependency Update).

Templating

The Chart resource renders the templates from your chart and then manages the resources directly with the Pulumi Kubernetes provider. A default namespace is applied based on the namespace input, the provider’s configured namespace, and the active Kubernetes context. Use the skipCrds option to skip installing the Custom Resource Definition (CRD) objects located in the chart’s crds/ special directory.

Use the postRenderer input to pipe the rendered manifest through a post-rendering command.

Resource Ordering

Sometimes resources must be applied in a specific order. For example, a namespace resource must be created before any namespaced resources, or a Custom Resource Definition (CRD) must be pre-installed.

Pulumi uses heuristics to determine which order to apply and delete objects within the Chart. Pulumi also waits for each object to be fully reconciled, unless skipAwait is enabled.

Pulumi supports the config.kubernetes.io/depends-on annotation to declare an explicit dependency on a given resource. The annotation accepts a list of resource references, delimited by commas.

Note that references to resources outside the Chart aren’t supported.

Resource reference

A resource reference is a string that uniquely identifies a resource.

It consists of the group, kind, name, and optionally the namespace, delimited by forward slashes.

Resource ScopeFormat
namespace-scoped<group>/namespaces/<namespace>/<kind>/<name>
cluster-scoped<group>/<kind>/<name>

For resources in the “core” group, the empty string is used instead (for example: /namespaces/test/Pod/pod-a).

Example Usage

Local Chart Directory

using Pulumi;
using Pulumi.Kubernetes.Types.Inputs.Helm.V4;
using System.Collections.Generic;

return await Deployment.RunAsync(() =>
{
    new Pulumi.Kubernetes.Helm.V4.Chart("nginx", new ChartArgs
    {
        Chart = "./nginx"
    });
    return new Dictionary<string, object?>{};
});
Copy
package main

import (
	helmv4 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/helm/v4"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := helmv4.NewChart(ctx, "nginx", &helmv4.ChartArgs{
			Chart: pulumi.String("./nginx"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
package generated_program;

import com.pulumi.Pulumi;
import com.pulumi.kubernetes.helm.v4.Chart;
import com.pulumi.kubernetes.helm.v4.ChartArgs;

public class App {
    public static void main(String[] args) {
        Pulumi.run(ctx -> {
            var nginx = new Chart("nginx", ChartArgs.builder()
                    .chart("./nginx")
                    .build());
        });
    }
}
Copy
import * as k8s from "@pulumi/kubernetes";

const nginx = new k8s.helm.v4.Chart("nginx", {
    chart: "./nginx",
});
Copy
import pulumi
from pulumi_kubernetes.helm.v4 import Chart

nginx = Chart("nginx",
    chart="./nginx"
)
Copy
name: example
runtime: yaml
resources:
  nginx:
    type: kubernetes:helm.sh/v4:Chart
    properties:
      chart: ./nginx
Copy

Repository Chart

using Pulumi;
using Pulumi.Kubernetes.Types.Inputs.Helm.V4;
using System.Collections.Generic;

return await Deployment.RunAsync(() =>
{
    new Pulumi.Kubernetes.Helm.V4.Chart("nginx", new ChartArgs
    {
        Chart = "nginx",
        RepositoryOpts = new RepositoryOptsArgs
        {
            Repo = "https://charts.bitnami.com/bitnami"
        },
    });
    
    return new Dictionary<string, object?>{};
});
Copy
package main

import (
	helmv4 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/helm/v4"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := helmv4.NewChart(ctx, "nginx", &helmv4.ChartArgs{
			Chart: pulumi.String("nginx"),
			RepositoryOpts: &helmv4.RepositoryOptsArgs{
				Repo: pulumi.String("https://charts.bitnami.com/bitnami"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
package generated_program;

import com.pulumi.Pulumi;
import com.pulumi.kubernetes.helm.v4.Chart;
import com.pulumi.kubernetes.helm.v4.ChartArgs;
import com.pulumi.kubernetes.helm.v4.inputs.RepositoryOptsArgs;

public class App {
    public static void main(String[] args) {
        Pulumi.run(ctx -> {
            var nginx = new Chart("nginx", ChartArgs.builder()
                    .chart("nginx")
                    .repositoryOpts(RepositoryOptsArgs.builder()
                            .repo("https://charts.bitnami.com/bitnami")
                            .build())
                    .build());
        });
    }
}
Copy
import * as k8s from "@pulumi/kubernetes";

const nginx = new k8s.helm.v4.Chart("nginx", {
    chart: "nginx",
    repositoryOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
});
Copy
import pulumi
from pulumi_kubernetes.helm.v4 import Chart,RepositoryOptsArgs

nginx = Chart("nginx",
    chart="nginx",
    repository_opts=RepositoryOptsArgs(
        repo="https://charts.bitnami.com/bitnami",
    )
)
Copy
name: example
runtime: yaml
resources:
  nginx:
    type: kubernetes:helm.sh/v4:Chart
    properties:
      chart: nginx
      repositoryOpts:
        repo: https://charts.bitnami.com/bitnami
Copy

OCI Chart

using Pulumi;
using Pulumi.Kubernetes.Types.Inputs.Helm.V4;
using System.Collections.Generic;

return await Deployment.RunAsync(() =>
{
    new Pulumi.Kubernetes.Helm.V4.Chart("nginx", new ChartArgs
    {
        Chart = "oci://registry-1.docker.io/bitnamicharts/nginx",
        Version = "16.0.7",
    });
    
    return new Dictionary<string, object?>{};
});
Copy
package main

import (
	helmv4 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/helm/v4"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := helmv4.NewChart(ctx, "nginx", &helmv4.ChartArgs{
			Chart:   pulumi.String("oci://registry-1.docker.io/bitnamicharts/nginx"),
			Version: pulumi.String("16.0.7"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
package generated_program;

import com.pulumi.Pulumi;
import com.pulumi.kubernetes.helm.v4.Chart;
import com.pulumi.kubernetes.helm.v4.ChartArgs;

public class App {
    public static void main(String[] args) {
        Pulumi.run(ctx -> {
            var nginx = new Chart("nginx", ChartArgs.builder()
                    .chart("oci://registry-1.docker.io/bitnamicharts/nginx")
                    .version("16.0.7")
                    .build());
        });
    }
}
Copy
import * as k8s from "@pulumi/kubernetes";

const nginx = new k8s.helm.v4.Chart("nginx", {
    chart: "oci://registry-1.docker.io/bitnamicharts/nginx",
    version: "16.0.7",
});
Copy
import pulumi
from pulumi_kubernetes.helm.v4 import Chart

nginx = Chart("nginx",
    chart="oci://registry-1.docker.io/bitnamicharts/nginx",
    version="16.0.7",
)
Copy
name: example
runtime: yaml
resources:
  nginx:
    type: kubernetes:helm.sh/v4:Chart
    properties:
      chart: oci://registry-1.docker.io/bitnamicharts/nginx
      version: "16.0.7"
Copy

Chart Values

using Pulumi;
using Pulumi.Kubernetes.Types.Inputs.Helm.V4;
using System.Collections.Generic;

return await Deployment.RunAsync(() =>
{
    new Pulumi.Kubernetes.Helm.V4.Chart("nginx", new ChartArgs
    {
        Chart = "nginx",
        RepositoryOpts = new RepositoryOptsArgs
        {
            Repo = "https://charts.bitnami.com/bitnami"
        },
        ValueYamlFiles = 
        {
            new FileAsset("./values.yaml") 
        },
        Values = new InputMap<object>
        {
            ["service"] = new InputMap<object>
            {
                ["type"] = "ClusterIP",
            },
            ["notes"] = new FileAsset("./notes.txt")
        },
    });
    
    return new Dictionary<string, object?>{};
});
Copy
package main

import (
	helmv4 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/helm/v4"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := helmv4.NewChart(ctx, "nginx", &helmv4.ChartArgs{
			Chart: pulumi.String("nginx"),
			RepositoryOpts: &helmv4.RepositoryOptsArgs{
				Repo: pulumi.String("https://charts.bitnami.com/bitnami"),
			},
			ValueYamlFiles: pulumi.AssetOrArchiveArray{
				pulumi.NewFileAsset("./values.yaml"),
			},
			Values: pulumi.Map{
				"service": pulumi.Map{
					"type": pulumi.String("ClusterIP"),
				},
				"notes": pulumi.NewFileAsset("./notes.txt"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
package generated_program;

import java.util.Map;

import com.pulumi.Pulumi;
import com.pulumi.kubernetes.helm.v4.Chart;
import com.pulumi.kubernetes.helm.v4.ChartArgs;
import com.pulumi.kubernetes.helm.v4.inputs.RepositoryOptsArgs;
import com.pulumi.asset.FileAsset;

public class App {
    public static void main(String[] args) {
        Pulumi.run(ctx -> {
            var nginx = new Chart("nginx", ChartArgs.builder()
                    .chart("nginx")
                    .repositoryOpts(RepositoryOptsArgs.builder()
                            .repo("https://charts.bitnami.com/bitnami")
                            .build())
                    .valueYamlFiles(new FileAsset("./values.yaml"))
                    .values(Map.of(
                            "service", Map.of(
                                    "type", "ClusterIP"),
                            "notes", new FileAsset("./notes.txt")))
                    .build());
        });
    }
}
Copy
import * as pulumi from "@pulumi/pulumi";
import * as k8s from "@pulumi/kubernetes";

const nginx = new k8s.helm.v4.Chart("nginx", {
    chart: "nginx",
    repositoryOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
    valueYamlFiles: [
        new pulumi.asset.FileAsset("./values.yaml")
    ],
    values: {
        service: {
            type: "ClusterIP",
        },
        notes: new pulumi.asset.FileAsset("./notes.txt"),
    },
});
Copy
"""A Kubernetes Python Pulumi program"""

import pulumi
from pulumi_kubernetes.helm.v4 import Chart,RepositoryOptsArgs

nginx = Chart("nginx",
    chart="nginx",
    repository_opts=RepositoryOptsArgs(
        repo="https://charts.bitnami.com/bitnami"
    ),
    value_yaml_files=[
        pulumi.FileAsset("./values.yaml")
    ],
    values={
        "service": {
            "type": "ClusterIP"
        },
        "notes": pulumi.FileAsset("./notes.txt")
    }
)
Copy
name: example
runtime: yaml
resources:
  nginx:
    type: kubernetes:helm.sh/v4:Chart
    properties:
      chart: nginx
      repositoryOpts:
        repo: https://charts.bitnami.com/bitnami
      valueYamlFiles:
      - fn::fileAsset: values.yaml
      values:
        service:
          type: ClusterIP
        notes:
          fn::fileAsset: notes.txt
Copy

Chart Namespace

using Pulumi;
using Pulumi.Kubernetes.Types.Inputs.Core.V1;
using Pulumi.Kubernetes.Types.Inputs.Meta.V1;
using Pulumi.Kubernetes.Types.Inputs.Helm.V4;
using System.Collections.Generic;

return await Deployment.RunAsync(() =>
{
    var ns = new Pulumi.Kubernetes.Core.V1.Namespace("nginx", new NamespaceArgs
    {
        Metadata = new ObjectMetaArgs{Name = "nginx"}
    });
    new Pulumi.Kubernetes.Helm.V4.Chart("nginx", new ChartArgs
    {
        Namespace = ns.Metadata.Apply(m => m.Name),
        Chart = "nginx",
        RepositoryOpts = new RepositoryOptsArgs
        {
            Repo = "https://charts.bitnami.com/bitnami"
        },
    });
    
    return new Dictionary<string, object?>{};
});
Copy
package main

import (
	corev1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/core/v1"
	helmv4 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/helm/v4"
	metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		ns, err := corev1.NewNamespace(ctx, "nginx", &corev1.NamespaceArgs{
			Metadata: &metav1.ObjectMetaArgs{Name: pulumi.String("nginx")},
		})
		if err != nil {
			return err
		}
		_, err = helmv4.NewChart(ctx, "nginx", &helmv4.ChartArgs{
            Namespace: ns.Metadata.Name(),
			Chart:     pulumi.String("nginx"),
			RepositoryOpts: &helmv4.RepositoryOptsArgs{
				Repo: pulumi.String("https://charts.bitnami.com/bitnami"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
package generated_program;

import com.pulumi.Pulumi;
import com.pulumi.kubernetes.core.v1.Namespace;
import com.pulumi.kubernetes.core.v1.NamespaceArgs;
import com.pulumi.kubernetes.helm.v4.Chart;
import com.pulumi.kubernetes.helm.v4.ChartArgs;
import com.pulumi.kubernetes.helm.v4.inputs.RepositoryOptsArgs;
import com.pulumi.kubernetes.meta.v1.inputs.ObjectMetaArgs;
import com.pulumi.core.Output;

public class App {
    public static void main(String[] args) {
        Pulumi.run(ctx -> {
            var ns = new Namespace("nginx", NamespaceArgs.builder()
                    .metadata(ObjectMetaArgs.builder()
                            .name("nginx")
                            .build())
                    .build());
            var nginx = new Chart("nginx", ChartArgs.builder()
                    .namespace(ns.metadata().apply(m -> Output.of(m.name().get())))
                    .chart("nginx")
                    .repositoryOpts(RepositoryOptsArgs.builder()
                            .repo("https://charts.bitnami.com/bitnami")
                            .build())
                    .build());
        });
    }
}
Copy
import * as pulumi from "@pulumi/pulumi";
import * as k8s from "@pulumi/kubernetes";

const ns = new k8s.core.v1.Namespace("nginx", {
    metadata: { name: "nginx" },
});
const nginx = new k8s.helm.v4.Chart("nginx", {
    namespace: ns.metadata.name,
    chart: "nginx",
    repositoryOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    }
});
Copy
import pulumi
from pulumi_kubernetes.meta.v1 import ObjectMetaArgs
from pulumi_kubernetes.core.v1 import Namespace
from pulumi_kubernetes.helm.v4 import Chart,RepositoryOptsArgs

ns = Namespace("nginx",
    metadata=ObjectMetaArgs(
        name="nginx",
    )
)
nginx = Chart("nginx",
    namespace=ns.metadata.name,
    chart="nginx",
    repository_opts=RepositoryOptsArgs(
        repo="https://charts.bitnami.com/bitnami",
    )
)
Copy
name: example
runtime: yaml
resources:
  ns:
    type: kubernetes:core/v1:Namespace
    properties:
      metadata:
        name: nginx
  nginx:
    type: kubernetes:helm.sh/v4:Chart
    properties:
      namespace: ${ns.metadata.name}
      chart: nginx
      repositoryOpts:
        repo: https://charts.bitnami.com/bitnami
Copy

Create Chart Resource

Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

Constructor syntax

new Chart(name: string, args: ChartOpts, opts?: ComponentResourceOptions);
@overload
def Chart(resource_name: str,
          args: ChartArgs,
          opts: Optional[ResourceOptions] = None)

@overload
def Chart(resource_name: str,
          opts: Optional[ResourceOptions] = None,
          chart: Optional[str] = None,
          dependency_update: Optional[bool] = None,
          devel: Optional[bool] = None,
          keyring: Optional[Union[pulumi.Asset, pulumi.Archive]] = None,
          name: Optional[str] = None,
          namespace: Optional[str] = None,
          post_renderer: Optional[_helm_sh.v4.PostRendererArgs] = None,
          repository_opts: Optional[_helm_sh.v4.RepositoryOptsArgs] = None,
          resource_prefix: Optional[str] = None,
          skip_await: Optional[bool] = None,
          skip_crds: Optional[bool] = None,
          value_yaml_files: Optional[Sequence[Union[pulumi.Asset, pulumi.Archive]]] = None,
          values: Optional[Mapping[str, Any]] = None,
          verify: Optional[bool] = None,
          version: Optional[str] = None)
func NewChart(ctx *Context, name string, args ChartArgs, opts ...ResourceOption) (*Chart, error)
public Chart(string name, ChartArgs args, ComponentResourceOptions? opts = null)
public Chart(String name, ChartArgs args)
public Chart(String name, ChartArgs args, ComponentResourceOptions options)

type: kubernetes:helm.sh/v4:Chart
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

Parameters

name This property is required. string
The unique name of the resource.
args This property is required. ChartOpts
The arguments to resource properties.
opts ComponentResourceOptions
Bag of options to control resource's behavior.
resource_name This property is required. str
The unique name of the resource.
args This property is required. ChartArgs
The arguments to resource properties.
opts ResourceOptions
Bag of options to control resource's behavior.
ctx Context
Context object for the current deployment.
name This property is required. string
The unique name of the resource.
args This property is required. ChartArgs
The arguments to resource properties.
opts ResourceOption
Bag of options to control resource's behavior.
name This property is required. string
The unique name of the resource.
args This property is required. ChartArgs
The arguments to resource properties.
opts ComponentResourceOptions
Bag of options to control resource's behavior.
name This property is required. String
The unique name of the resource.
args This property is required. ChartArgs
The arguments to resource properties.
options ComponentResourceOptions
Bag of options to control resource's behavior.

Chart Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

Inputs

In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

The Chart resource accepts the following input properties:

Chart This property is required. string
Chart name to be installed. A path may be used.
DependencyUpdate bool
Run helm dependency update before installing the chart.
Devel bool
Use chart development versions, too. Equivalent to version '>0.0.0-0'. If version is set, this is ignored.
Keyring AssetOrArchive
Location of public keys used for verification. Used only if verify is true
Name string
Release name.
Namespace string
Namespace for the release.
PostRenderer PostRenderer
Specification defining the post-renderer to use.
RepositoryOpts RepositoryOpts
Specification defining the Helm chart repository to use.
ResourcePrefix string
An optional prefix for the auto-generated resource names. Example: A resource created with resourcePrefix="foo" would produce a resource named "foo:resourceName".
SkipAwait bool
By default, the provider waits until all resources are in a ready state before marking the release as successful. Setting this to true will skip such await logic.
SkipCrds bool
If set, no CRDs will be installed. By default, CRDs are installed if not already present.
ValueYamlFiles List<AssetOrArchive>
List of assets (raw yaml files). Content is read and merged with values.
Values Dictionary<string, object>
Custom values set for the release.
Verify bool
Verify the chart's integrity.
Version string
Specify the chart version to install. If this is not specified, the latest version is installed.
Chart This property is required. string
Chart name to be installed. A path may be used.
DependencyUpdate bool
Run helm dependency update before installing the chart.
Devel bool
Use chart development versions, too. Equivalent to version '>0.0.0-0'. If version is set, this is ignored.
Keyring pulumi.AssetOrArchive
Location of public keys used for verification. Used only if verify is true
Name string
Release name.
Namespace string
Namespace for the release.
PostRenderer PostRendererArgs
Specification defining the post-renderer to use.
RepositoryOpts RepositoryOptsArgs
Specification defining the Helm chart repository to use.
ResourcePrefix string
An optional prefix for the auto-generated resource names. Example: A resource created with resourcePrefix="foo" would produce a resource named "foo:resourceName".
SkipAwait bool
By default, the provider waits until all resources are in a ready state before marking the release as successful. Setting this to true will skip such await logic.
SkipCrds bool
If set, no CRDs will be installed. By default, CRDs are installed if not already present.
ValueYamlFiles AssetOrArchive
List of assets (raw yaml files). Content is read and merged with values.
Values map[string]interface{}
Custom values set for the release.
Verify bool
Verify the chart's integrity.
Version string
Specify the chart version to install. If this is not specified, the latest version is installed.
chart This property is required. String
Chart name to be installed. A path may be used.
dependencyUpdate Boolean
Run helm dependency update before installing the chart.
devel Boolean
Use chart development versions, too. Equivalent to version '>0.0.0-0'. If version is set, this is ignored.
keyring AssetOrArchive
Location of public keys used for verification. Used only if verify is true
name String
Release name.
namespace String
Namespace for the release.
postRenderer PostRenderer
Specification defining the post-renderer to use.
repositoryOpts RepositoryOpts
Specification defining the Helm chart repository to use.
resourcePrefix String
An optional prefix for the auto-generated resource names. Example: A resource created with resourcePrefix="foo" would produce a resource named "foo:resourceName".
skipAwait Boolean
By default, the provider waits until all resources are in a ready state before marking the release as successful. Setting this to true will skip such await logic.
skipCrds Boolean
If set, no CRDs will be installed. By default, CRDs are installed if not already present.
valueYamlFiles List<AssetOrArchive>
List of assets (raw yaml files). Content is read and merged with values.
values Map<String,Object>
Custom values set for the release.
verify Boolean
Verify the chart's integrity.
version String
Specify the chart version to install. If this is not specified, the latest version is installed.
chart This property is required. string
Chart name to be installed. A path may be used.
dependencyUpdate boolean
Run helm dependency update before installing the chart.
devel boolean
Use chart development versions, too. Equivalent to version '>0.0.0-0'. If version is set, this is ignored.
keyring pulumi.asset.Asset | pulumi.asset.Archive
Location of public keys used for verification. Used only if verify is true
name string
Release name.
namespace string
Namespace for the release.
postRenderer helm.sh.v4.PostRenderer
Specification defining the post-renderer to use.
repositoryOpts helm.sh.v4.RepositoryOpts
Specification defining the Helm chart repository to use.
resourcePrefix string
An optional prefix for the auto-generated resource names. Example: A resource created with resourcePrefix="foo" would produce a resource named "foo:resourceName".
skipAwait boolean
By default, the provider waits until all resources are in a ready state before marking the release as successful. Setting this to true will skip such await logic.
skipCrds boolean
If set, no CRDs will be installed. By default, CRDs are installed if not already present.
valueYamlFiles (pulumi.asset.Asset | pulumi.asset.Archive)[]
List of assets (raw yaml files). Content is read and merged with values.
values {[key: string]: any}
Custom values set for the release.
verify boolean
Verify the chart's integrity.
version string
Specify the chart version to install. If this is not specified, the latest version is installed.
chart This property is required. str
Chart name to be installed. A path may be used.
dependency_update bool
Run helm dependency update before installing the chart.
devel bool
Use chart development versions, too. Equivalent to version '>0.0.0-0'. If version is set, this is ignored.
keyring Union[pulumi.Asset, pulumi.Archive]
Location of public keys used for verification. Used only if verify is true
name str
Release name.
namespace str
Namespace for the release.
post_renderer helm_sh.v4.PostRendererArgs
Specification defining the post-renderer to use.
repository_opts helm_sh.v4.RepositoryOptsArgs
Specification defining the Helm chart repository to use.
resource_prefix str
An optional prefix for the auto-generated resource names. Example: A resource created with resourcePrefix="foo" would produce a resource named "foo:resourceName".
skip_await bool
By default, the provider waits until all resources are in a ready state before marking the release as successful. Setting this to true will skip such await logic.
skip_crds bool
If set, no CRDs will be installed. By default, CRDs are installed if not already present.
value_yaml_files Sequence[Union[pulumi.Asset, pulumi.Archive]]
List of assets (raw yaml files). Content is read and merged with values.
values Mapping[str, Any]
Custom values set for the release.
verify bool
Verify the chart's integrity.
version str
Specify the chart version to install. If this is not specified, the latest version is installed.
chart This property is required. String
Chart name to be installed. A path may be used.
dependencyUpdate Boolean
Run helm dependency update before installing the chart.
devel Boolean
Use chart development versions, too. Equivalent to version '>0.0.0-0'. If version is set, this is ignored.
keyring Asset
Location of public keys used for verification. Used only if verify is true
name String
Release name.
namespace String
Namespace for the release.
postRenderer Property Map
Specification defining the post-renderer to use.
repositoryOpts Property Map
Specification defining the Helm chart repository to use.
resourcePrefix String
An optional prefix for the auto-generated resource names. Example: A resource created with resourcePrefix="foo" would produce a resource named "foo:resourceName".
skipAwait Boolean
By default, the provider waits until all resources are in a ready state before marking the release as successful. Setting this to true will skip such await logic.
skipCrds Boolean
If set, no CRDs will be installed. By default, CRDs are installed if not already present.
valueYamlFiles List<Asset>
List of assets (raw yaml files). Content is read and merged with values.
values Map<Any>
Custom values set for the release.
verify Boolean
Verify the chart's integrity.
version String
Specify the chart version to install. If this is not specified, the latest version is installed.

Outputs

All input properties are implicitly available as output properties. Additionally, the Chart resource produces the following output properties:

Resources List<object>
Resources created by the Chart.
Resources []interface{}
Resources created by the Chart.
resources List<Object>
Resources created by the Chart.
resources any[]
Resources created by the Chart.
resources Sequence[Any]
Resources created by the Chart.
resources List<Any>
Resources created by the Chart.

Supporting Types

PostRenderer
, PostRendererArgs

Command This property is required. string
Path to an executable to be used for post rendering.
Args List<string>
Arguments to pass to the post-renderer command.
Command This property is required. string
Path to an executable to be used for post rendering.
Args []string
Arguments to pass to the post-renderer command.
command This property is required. String
Path to an executable to be used for post rendering.
args List<String>
Arguments to pass to the post-renderer command.
command This property is required. string
Path to an executable to be used for post rendering.
args string[]
Arguments to pass to the post-renderer command.
command This property is required. str
Path to an executable to be used for post rendering.
args Sequence[str]
Arguments to pass to the post-renderer command.
command This property is required. String
Path to an executable to be used for post rendering.
args List<String>
Arguments to pass to the post-renderer command.

RepositoryOpts
, RepositoryOptsArgs

CaFile AssetOrArchive
The Repository's CA File
CertFile AssetOrArchive
The repository's cert file
KeyFile AssetOrArchive
The repository's cert key file
Password string
Password for HTTP basic authentication
Repo string
Repository where to locate the requested chart. If it's a URL the chart is installed without installing the repository.
Username string
Username for HTTP basic authentication
CaFile pulumi.AssetOrArchive
The Repository's CA File
CertFile pulumi.AssetOrArchive
The repository's cert file
KeyFile pulumi.AssetOrArchive
The repository's cert key file
Password string
Password for HTTP basic authentication
Repo string
Repository where to locate the requested chart. If it's a URL the chart is installed without installing the repository.
Username string
Username for HTTP basic authentication
caFile AssetOrArchive
The Repository's CA File
certFile AssetOrArchive
The repository's cert file
keyFile AssetOrArchive
The repository's cert key file
password String
Password for HTTP basic authentication
repo String
Repository where to locate the requested chart. If it's a URL the chart is installed without installing the repository.
username String
Username for HTTP basic authentication
caFile pulumi.asset.Asset | pulumi.asset.Archive
The Repository's CA File
certFile pulumi.asset.Asset | pulumi.asset.Archive
The repository's cert file
keyFile pulumi.asset.Asset | pulumi.asset.Archive
The repository's cert key file
password string
Password for HTTP basic authentication
repo string
Repository where to locate the requested chart. If it's a URL the chart is installed without installing the repository.
username string
Username for HTTP basic authentication
ca_file Union[pulumi.Asset, pulumi.Archive]
The Repository's CA File
cert_file Union[pulumi.Asset, pulumi.Archive]
The repository's cert file
key_file Union[pulumi.Asset, pulumi.Archive]
The repository's cert key file
password str
Password for HTTP basic authentication
repo str
Repository where to locate the requested chart. If it's a URL the chart is installed without installing the repository.
username str
Username for HTTP basic authentication
caFile Asset
The Repository's CA File
certFile Asset
The repository's cert file
keyFile Asset
The repository's cert key file
password String
Password for HTTP basic authentication
repo String
Repository where to locate the requested chart. If it's a URL the chart is installed without installing the repository.
username String
Username for HTTP basic authentication

Package Details

Repository
Kubernetes pulumi/pulumi-kubernetes
License
Apache-2.0
Kubernetes v4.22.1 published on Friday, Mar 14, 2025 by Pulumi
pulumi/pulumi-kubernetes