kubernetes.yaml/v2.ConfigFile

ConfigFile creates a set of Kubernetes resources from a remote or on-disk Kubernetes YAML file. (If you have in-memory YAML a ConfigGroup may be more appropriate.)

Dependency 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 ConfigFile. Pulumi also waits for each object to be fully reconciled, unless skipAwait is enabled.

Explicit Dependency Ordering

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 ConfigFile 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.

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

Ordering across ConfigFiles

The dependsOn resource option creates a list of explicit dependencies between Pulumi resources. Use it on another resource to make it dependent on the ConfigFile and to wait for the resources within the group to be deployed.

A best practice is to deploy each application using its own ConfigFile, especially when that application installs custom resource definitions.

using Pulumi;
using Pulumi.Kubernetes.Types.Inputs.Yaml.V2;
using Pulumi.Kubernetes.Yaml.V2;
using System.Collections.Generic;

return await Deployment.RunAsync(() =>
{
    var example = new ConfigFile("example", new ConfigFileArgs
    {
        File = "./manifest.yaml"
    });
});

package main

import (
	yamlv2 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/yaml/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := yamlv2.NewConfigFile(ctx, "example", &yamlv2.ConfigFileArgs{
			File: pulumi.String("manifest.yaml"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package myproject;

import com.pulumi.Pulumi;
import com.pulumi.kubernetes.yaml.v2.ConfigFile;
import com.pulumi.kubernetes.yaml.v2.ConfigFileArgs;

public class App {
    public static void main(String[] args) {
        Pulumi.run(ctx -> {
            var example = new ConfigFile("example", ConfigFileArgs.builder()
                    .file("./manifest.yaml")
                    .build());
        });
    }
}

import pulumi
from pulumi_kubernetes.yaml.v2 import ConfigFile

example = ConfigFile(
    "example",
    file="./manifest.yaml"
)

import * as pulumi from "@pulumi/pulumi";
import * as k8s from "@pulumi/kubernetes";

const example = new k8s.yaml.v2.ConfigFile("example", {
    files: ["./manifest.yaml"],
});

name: example
runtime: yaml
resources:
  example:
    type: kubernetes:yaml/v2:ConfigFile
    properties:
      file: ./manifest.yaml

Create ConfigFile Resource

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

Constructor syntax

new ConfigFile(name: string, args: ConfigFileOpts, opts?: ComponentResourceOptions);

@overload
def ConfigFile(resource_name: str,
               args: ConfigFileArgs,
               opts: Optional[ResourceOptions] = None)

@overload
def ConfigFile(resource_name: str,
               opts: Optional[ResourceOptions] = None,
               file: Optional[str] = None,
               resource_prefix: Optional[str] = None,
               skip_await: Optional[bool] = None)

func NewConfigFile(ctx *Context, name string, args ConfigFileArgs, opts ...ResourceOption) (*ConfigFile, error)

public ConfigFile(string name, ConfigFileArgs args, ComponentResourceOptions? opts = null)

public ConfigFile(String name, ConfigFileArgs args)
public ConfigFile(String name, ConfigFileArgs args, ComponentResourceOptions options)

type: kubernetes:yaml/v2:ConfigFile
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

Parameters

ConfigFile 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 ConfigFile resource accepts the following input properties:

Outputs

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

Package Details

Repository

Kubernetes pulumi/pulumi-kubernetes

License

Apache-2.0