1. Packages
  2. Kubernetes
  3. API Docs
  4. helm
  5. helm/v4
  6. Chart
Kubernetes v4.13.1 published on Tuesday, Jun 4, 2024 by Pulumi

kubernetes.helm.sh/v4.Chart

Explore with Pulumi AI

kubernetes logo
Kubernetes v4.13.1 published on Tuesday, Jun 4, 2024 by Pulumi

    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?>{};
    });
    
    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
    	})
    }
    
    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());
            });
        }
    }
    
    import pulumi
    from pulumi_kubernetes.helm.v4 import Chart
    
    nginx = Chart("nginx",
        chart="./nginx"
    )
    
    import * as k8s from "@pulumi/kubernetes";
    
    const nginx = new k8s.helm.v4.Chart("nginx", {
        chart: "./nginx",
    });
    
    name: example
    runtime: yaml
    resources:
      nginx:
        type: kubernetes:helm.sh/v4:Chart
        properties:
          chart: ./nginx
    

    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?>{};
    });
    
    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
    	})
    }
    
    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());
            });
        }
    }
    
    import pulumi
    from pulumi_kubernetes.helm.v4 import Chart,RepositoryOptsArgs
    
    nginx = Chart("nginx",
        chart="nginx",
        repository_opts=RepositoryOptsArgs(
            repo="https://charts.bitnami.com/bitnami",
        )
    )
    
    import * as k8s from "@pulumi/kubernetes";
    
    const nginx = new k8s.helm.v4.Chart("nginx", {
        chart: "nginx",
        repositoryOpts: {
            repo: "https://charts.bitnami.com/bitnami",
        },
    });
    
    name: example
    runtime: yaml
    resources:
      nginx:
        type: kubernetes:helm.sh/v4:Chart
        properties:
          chart: nginx
          repositoryOpts:
            repo: https://charts.bitnami.com/bitnami
    

    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?>{};
    });
    
    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
    	})
    }
    
    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());
            });
        }
    }
    
    import pulumi
    from pulumi_kubernetes.helm.v4 import Chart
    
    nginx = Chart("nginx",
        chart="oci://registry-1.docker.io/bitnamicharts/nginx",
        version="16.0.7",
    )
    
    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",
    });
    
    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"
    

    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?>{};
    });
    
    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
    	})
    }
    
    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());
            });
        }
    }
    
    """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")
        }
    )
    
    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"),
        },
    });
    
    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
    

    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?>{};
    });
    
    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
    	})
    }
    
    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());
            });
        }
    }
    
    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",
        )
    )
    
    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",
        }
    });
    
    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
    

    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 string
    The unique name of the resource.
    args ChartOpts
    The arguments to resource properties.
    opts ComponentResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args 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 string
    The unique name of the resource.
    args ChartArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ChartArgs
    The arguments to resource properties.
    opts ComponentResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ChartArgs
    The arguments to resource properties.
    options ComponentResourceOptions
    Bag of options to control resource's behavior.

    Example

    The following reference example uses placeholder values for all input properties.

    Coming soon!
    
    Coming soon!
    
    Coming soon!
    
    Coming soon!
    
    Coming soon!
    
    Coming soon!
    

    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

    The Chart resource accepts the following input properties:

    Chart 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 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 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 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 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 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 string
    Path to an executable to be used for post rendering.
    Args List<string>
    Arguments to pass to the post-renderer command.
    Command string
    Path to an executable to be used for post rendering.
    Args []string
    Arguments to pass to the post-renderer command.
    command String
    Path to an executable to be used for post rendering.
    args List<String>
    Arguments to pass to the post-renderer command.
    command string
    Path to an executable to be used for post rendering.
    args string[]
    Arguments to pass to the post-renderer command.
    command str
    Path to an executable to be used for post rendering.
    args Sequence[str]
    Arguments to pass to the post-renderer command.
    command 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 is 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 is 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 is 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 is 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 is 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 is 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 logo
    Kubernetes v4.13.1 published on Tuesday, Jun 4, 2024 by Pulumi