pulumi-gcp-kotlin/com.pulumi.gcp.deploymentmanager.kotlin/Deployment

Deployment

class Deployment : KotlinCustomResource

A collection of resources that are deployed and managed together using a configuration file

Warning: This resource is intended only to manage a Deployment resource, and attempts to manage the Deployment's resources in the provider as well will likely result in errors or unexpected behavior as the two tools fight over ownership. We strongly discourage doing so unless you are an experienced user of both tools. In addition, due to limitations of the API, the provider will treat deployments in preview as recreate-only for any update operation other than actually deploying an in-preview deployment (i.e. preview=true to preview=false).

Example Usage

Deployment Manager Deployment Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as std from "@pulumi/std";
const deployment = new gcp.deploymentmanager.Deployment("deployment", {
    name: "my-deployment",
    target: {
        config: {
            content: std.file({
                input: "path/to/config.yml",
            }).then(invoke => invoke.result),
        },
    },
    labels: [{
        key: "foo",
        value: "bar",
    }],
});

import pulumi
import pulumi_gcp as gcp
import pulumi_std as std
deployment = gcp.deploymentmanager.Deployment("deployment",
    name="my-deployment",
    target={
        "config": {
            "content": std.file(input="path/to/config.yml").result,
        },
    },
    labels=[{
        "key": "foo",
        "value": "bar",
    }])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Std = Pulumi.Std;
return await Deployment.RunAsync(() =>
{
    var deployment = new Gcp.DeploymentManager.Deployment("deployment", new()
    {
        Name = "my-deployment",
        Target = new Gcp.DeploymentManager.Inputs.DeploymentTargetArgs
        {
            Config = new Gcp.DeploymentManager.Inputs.DeploymentTargetConfigArgs
            {
                Content = Std.File.Invoke(new()
                {
                    Input = "path/to/config.yml",
                }).Apply(invoke => invoke.Result),
            },
        },
        Labels = new[]
        {
            new Gcp.DeploymentManager.Inputs.DeploymentLabelArgs
            {
                Key = "foo",
                Value = "bar",
            },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/deploymentmanager"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		invokeFile, err := std.File(ctx, &std.FileArgs{
			Input: "path/to/config.yml",
		}, nil)
		if err != nil {
			return err
		}
		_, err = deploymentmanager.NewDeployment(ctx, "deployment", &deploymentmanager.DeploymentArgs{
			Name: pulumi.String("my-deployment"),
			Target: &deploymentmanager.DeploymentTargetArgs{
				Config: &deploymentmanager.DeploymentTargetConfigArgs{
					Content: pulumi.String(invokeFile.Result),
				},
			},
			Labels: deploymentmanager.DeploymentLabelArray{
				&deploymentmanager.DeploymentLabelArgs{
					Key:   pulumi.String("foo"),
					Value: pulumi.String("bar"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.deploymentmanager.Deployment;
import com.pulumi.gcp.deploymentmanager.DeploymentArgs;
import com.pulumi.gcp.deploymentmanager.inputs.DeploymentTargetArgs;
import com.pulumi.gcp.deploymentmanager.inputs.DeploymentTargetConfigArgs;
import com.pulumi.gcp.deploymentmanager.inputs.DeploymentLabelArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var deployment = new Deployment("deployment", DeploymentArgs.builder()
            .name("my-deployment")
            .target(DeploymentTargetArgs.builder()
                .config(DeploymentTargetConfigArgs.builder()
                    .content(StdFunctions.file(FileArgs.builder()
                        .input("path/to/config.yml")
                        .build()).result())
                    .build())
                .build())
            .labels(DeploymentLabelArgs.builder()
                .key("foo")
                .value("bar")
                .build())
            .build());
    }
}

resources:
  deployment:
    type: gcp:deploymentmanager:Deployment
    properties:
      name: my-deployment
      target:
        config:
          content:
            fn::invoke:
              Function: std:file
              Arguments:
                input: path/to/config.yml
              Return: result
      labels:
        - key: foo
          value: bar

Import

Deployment can be imported using any of these accepted formats:

projects/{{project}}/deployments/{{name}}
{{project}}/{{name}}
{{name}} When using the pulumi import command, Deployment can be imported using one of the formats above. For example:

$ pulumi import gcp:deploymentmanager/deployment:Deployment default projects/{{project}}/deployments/{{name}}

$ pulumi import gcp:deploymentmanager/deployment:Deployment default {{project}}/{{name}}

$ pulumi import gcp:deploymentmanager/deployment:Deployment default {{name}}

Properties

createPolicy

val createPolicy: Output<String>?

Set the policy to use for creating new resources. Only used on create and update. Valid values are 'CREATE_OR_ACQUIRE' (default) or 'ACQUIRE'. If set to 'ACQUIRE' and resources do not already exist, the deployment will fail. Note that updating this field does not actually affect the deployment, just how it is updated. Default value: "CREATE_OR_ACQUIRE" Possible values: "ACQUIRE", "CREATE_OR_ACQUIRE"

deletePolicy

val deletePolicy: Output<String>?

Set the policy to use for deleting new resources on update/delete. Valid values are 'DELETE' (default) or 'ABANDON'. If 'DELETE', resource is deleted after removal from Deployment Manager. If 'ABANDON', the resource is only removed from Deployment Manager and is not actually deleted. Note that updating this field does not actually change the deployment, just how it is updated. Default value: "DELETE" Possible values: "ABANDON", "DELETE"

deploymentId

val deploymentId: Output<String>

Unique identifier for deployment. Output only.

description

val description: Output<String>?

Optional user-provided description of deployment.