pulumi-gcp-kotlin/com.pulumi.gcp.clouddeploy.kotlin/DeliveryPipeline

DeliveryPipeline

class DeliveryPipeline : KotlinCustomResource

The Cloud Deploy DeliveryPipeline resource

Example Usage

Canary_delivery_pipeline

Creates a basic Cloud Deploy delivery pipeline

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const primary = new gcp.clouddeploy.DeliveryPipeline("primary", {
    location: "us-west1",
    name: "pipeline",
    description: "basic description",
    project: "my-project-name",
    serialPipeline: {
        stages: [
            {
                deployParameters: [{
                    values: {
                        deployParameterKey: "deployParameterValue",
                    },
                    matchTargetLabels: {},
                }],
                profiles: [
                    "example-profile-one",
                    "example-profile-two",
                ],
                targetId: "example-target-one",
            },
            {
                profiles: [],
                targetId: "example-target-two",
            },
        ],
    },
    annotations: {
        my_first_annotation: "example-annotation-1",
        my_second_annotation: "example-annotation-2",
    },
    labels: {
        my_first_label: "example-label-1",
        my_second_label: "example-label-2",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
primary = gcp.clouddeploy.DeliveryPipeline("primary",
    location="us-west1",
    name="pipeline",
    description="basic description",
    project="my-project-name",
    serial_pipeline={
        "stages": [
            {
                "deploy_parameters": [{
                    "values": {
                        "deployParameterKey": "deployParameterValue",
                    },
                    "match_target_labels": {},
                }],
                "profiles": [
                    "example-profile-one",
                    "example-profile-two",
                ],
                "target_id": "example-target-one",
            },
            {
                "profiles": [],
                "target_id": "example-target-two",
            },
        ],
    },
    annotations={
        "my_first_annotation": "example-annotation-1",
        "my_second_annotation": "example-annotation-2",
    },
    labels={
        "my_first_label": "example-label-1",
        "my_second_label": "example-label-2",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var primary = new Gcp.CloudDeploy.DeliveryPipeline("primary", new()
    {
        Location = "us-west1",
        Name = "pipeline",
        Description = "basic description",
        Project = "my-project-name",
        SerialPipeline = new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineArgs
        {
            Stages = new[]
            {
                new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineStageArgs
                {
                    DeployParameters = new[]
                    {
                        new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineStageDeployParameterArgs
                        {
                            Values =
                            {
                                { "deployParameterKey", "deployParameterValue" },
                            },
                            MatchTargetLabels = null,
                        },
                    },
                    Profiles = new[]
                    {
                        "example-profile-one",
                        "example-profile-two",
                    },
                    TargetId = "example-target-one",
                },
                new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineStageArgs
                {
                    Profiles = new() { },
                    TargetId = "example-target-two",
                },
            },
        },
        Annotations =
        {
            { "my_first_annotation", "example-annotation-1" },
            { "my_second_annotation", "example-annotation-2" },
        },
        Labels =
        {
            { "my_first_label", "example-label-1" },
            { "my_second_label", "example-label-2" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/clouddeploy"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := clouddeploy.NewDeliveryPipeline(ctx, "primary", &clouddeploy.DeliveryPipelineArgs{
			Location:    pulumi.String("us-west1"),
			Name:        pulumi.String("pipeline"),
			Description: pulumi.String("basic description"),
			Project:     pulumi.String("my-project-name"),
			SerialPipeline: &clouddeploy.DeliveryPipelineSerialPipelineArgs{
				Stages: clouddeploy.DeliveryPipelineSerialPipelineStageArray{
					&clouddeploy.DeliveryPipelineSerialPipelineStageArgs{
						DeployParameters: clouddeploy.DeliveryPipelineSerialPipelineStageDeployParameterArray{
							&clouddeploy.DeliveryPipelineSerialPipelineStageDeployParameterArgs{
								Values: pulumi.StringMap{
									"deployParameterKey": pulumi.String("deployParameterValue"),
								},
								MatchTargetLabels: pulumi.StringMap{},
							},
						},
						Profiles: pulumi.StringArray{
							pulumi.String("example-profile-one"),
							pulumi.String("example-profile-two"),
						},
						TargetId: pulumi.String("example-target-one"),
					},
					&clouddeploy.DeliveryPipelineSerialPipelineStageArgs{
						Profiles: pulumi.StringArray{},
						TargetId: pulumi.String("example-target-two"),
					},
				},
			},
			Annotations: pulumi.StringMap{
				"my_first_annotation":  pulumi.String("example-annotation-1"),
				"my_second_annotation": pulumi.String("example-annotation-2"),
			},
			Labels: pulumi.StringMap{
				"my_first_label":  pulumi.String("example-label-1"),
				"my_second_label": pulumi.String("example-label-2"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.clouddeploy.DeliveryPipeline;
import com.pulumi.gcp.clouddeploy.DeliveryPipelineArgs;
import com.pulumi.gcp.clouddeploy.inputs.DeliveryPipelineSerialPipelineArgs;
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 primary = new DeliveryPipeline("primary", DeliveryPipelineArgs.builder()
            .location("us-west1")
            .name("pipeline")
            .description("basic description")
            .project("my-project-name")
            .serialPipeline(DeliveryPipelineSerialPipelineArgs.builder()
                .stages(
                    DeliveryPipelineSerialPipelineStageArgs.builder()
                        .deployParameters(DeliveryPipelineSerialPipelineStageDeployParameterArgs.builder()
                            .values(Map.of("deployParameterKey", "deployParameterValue"))
                            .matchTargetLabels(Map.ofEntries(
                            ))
                            .build())
                        .profiles(
                            "example-profile-one",
                            "example-profile-two")
                        .targetId("example-target-one")
                        .build(),
                    DeliveryPipelineSerialPipelineStageArgs.builder()
                        .profiles()
                        .targetId("example-target-two")
                        .build())
                .build())
            .annotations(Map.ofEntries(
                Map.entry("my_first_annotation", "example-annotation-1"),
                Map.entry("my_second_annotation", "example-annotation-2")
            ))
            .labels(Map.ofEntries(
                Map.entry("my_first_label", "example-label-1"),
                Map.entry("my_second_label", "example-label-2")
            ))
            .build());
    }
}
Content copied to clipboard
resources:
  primary:
    type: gcp:clouddeploy:DeliveryPipeline
    properties:
      location: us-west1
      name: pipeline
      description: basic description
      project: my-project-name
      serialPipeline:
        stages:
          - deployParameters:
              - values:
                  deployParameterKey: deployParameterValue
                matchTargetLabels: {}
            profiles:
              - example-profile-one
              - example-profile-two
            targetId: example-target-one
          - profiles: []
            targetId: example-target-two
      annotations:
        my_first_annotation: example-annotation-1
        my_second_annotation: example-annotation-2
      labels:
        my_first_label: example-label-1
        my_second_label: example-label-2
Content copied to clipboard

Canary_service_networking_delivery_pipeline

Creates a basic Cloud Deploy delivery pipeline

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const primary = new gcp.clouddeploy.DeliveryPipeline("primary", {
    location: "us-west1",
    name: "pipeline",
    description: "basic description",
    project: "my-project-name",
    serialPipeline: {
        stages: [
            {
                deployParameters: [{
                    values: {
                        deployParameterKey: "deployParameterValue",
                    },
                    matchTargetLabels: {},
                }],
                profiles: [
                    "example-profile-one",
                    "example-profile-two",
                ],
                targetId: "example-target-one",
            },
            {
                profiles: [],
                targetId: "example-target-two",
            },
        ],
    },
    annotations: {
        my_first_annotation: "example-annotation-1",
        my_second_annotation: "example-annotation-2",
    },
    labels: {
        my_first_label: "example-label-1",
        my_second_label: "example-label-2",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
primary = gcp.clouddeploy.DeliveryPipeline("primary",
    location="us-west1",
    name="pipeline",
    description="basic description",
    project="my-project-name",
    serial_pipeline={
        "stages": [
            {
                "deploy_parameters": [{
                    "values": {
                        "deployParameterKey": "deployParameterValue",
                    },
                    "match_target_labels": {},
                }],
                "profiles": [
                    "example-profile-one",
                    "example-profile-two",
                ],
                "target_id": "example-target-one",
            },
            {
                "profiles": [],
                "target_id": "example-target-two",
            },
        ],
    },
    annotations={
        "my_first_annotation": "example-annotation-1",
        "my_second_annotation": "example-annotation-2",
    },
    labels={
        "my_first_label": "example-label-1",
        "my_second_label": "example-label-2",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var primary = new Gcp.CloudDeploy.DeliveryPipeline("primary", new()
    {
        Location = "us-west1",
        Name = "pipeline",
        Description = "basic description",
        Project = "my-project-name",
        SerialPipeline = new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineArgs
        {
            Stages = new[]
            {
                new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineStageArgs
                {
                    DeployParameters = new[]
                    {
                        new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineStageDeployParameterArgs
                        {
                            Values =
                            {
                                { "deployParameterKey", "deployParameterValue" },
                            },
                            MatchTargetLabels = null,
                        },
                    },
                    Profiles = new[]
                    {
                        "example-profile-one",
                        "example-profile-two",
                    },
                    TargetId = "example-target-one",
                },
                new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineStageArgs
                {
                    Profiles = new() { },
                    TargetId = "example-target-two",
                },
            },
        },
        Annotations =
        {
            { "my_first_annotation", "example-annotation-1" },
            { "my_second_annotation", "example-annotation-2" },
        },
        Labels =
        {
            { "my_first_label", "example-label-1" },
            { "my_second_label", "example-label-2" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/clouddeploy"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := clouddeploy.NewDeliveryPipeline(ctx, "primary", &clouddeploy.DeliveryPipelineArgs{
			Location:    pulumi.String("us-west1"),
			Name:        pulumi.String("pipeline"),
			Description: pulumi.String("basic description"),
			Project:     pulumi.String("my-project-name"),
			SerialPipeline: &clouddeploy.DeliveryPipelineSerialPipelineArgs{
				Stages: clouddeploy.DeliveryPipelineSerialPipelineStageArray{
					&clouddeploy.DeliveryPipelineSerialPipelineStageArgs{
						DeployParameters: clouddeploy.DeliveryPipelineSerialPipelineStageDeployParameterArray{
							&clouddeploy.DeliveryPipelineSerialPipelineStageDeployParameterArgs{
								Values: pulumi.StringMap{
									"deployParameterKey": pulumi.String("deployParameterValue"),
								},
								MatchTargetLabels: pulumi.StringMap{},
							},
						},
						Profiles: pulumi.StringArray{
							pulumi.String("example-profile-one"),
							pulumi.String("example-profile-two"),
						},
						TargetId: pulumi.String("example-target-one"),
					},
					&clouddeploy.DeliveryPipelineSerialPipelineStageArgs{
						Profiles: pulumi.StringArray{},
						TargetId: pulumi.String("example-target-two"),
					},
				},
			},
			Annotations: pulumi.StringMap{
				"my_first_annotation":  pulumi.String("example-annotation-1"),
				"my_second_annotation": pulumi.String("example-annotation-2"),
			},
			Labels: pulumi.StringMap{
				"my_first_label":  pulumi.String("example-label-1"),
				"my_second_label": pulumi.String("example-label-2"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.clouddeploy.DeliveryPipeline;
import com.pulumi.gcp.clouddeploy.DeliveryPipelineArgs;
import com.pulumi.gcp.clouddeploy.inputs.DeliveryPipelineSerialPipelineArgs;
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 primary = new DeliveryPipeline("primary", DeliveryPipelineArgs.builder()
            .location("us-west1")
            .name("pipeline")
            .description("basic description")
            .project("my-project-name")
            .serialPipeline(DeliveryPipelineSerialPipelineArgs.builder()
                .stages(
                    DeliveryPipelineSerialPipelineStageArgs.builder()
                        .deployParameters(DeliveryPipelineSerialPipelineStageDeployParameterArgs.builder()
                            .values(Map.of("deployParameterKey", "deployParameterValue"))
                            .matchTargetLabels(Map.ofEntries(
                            ))
                            .build())
                        .profiles(
                            "example-profile-one",
                            "example-profile-two")
                        .targetId("example-target-one")
                        .build(),
                    DeliveryPipelineSerialPipelineStageArgs.builder()
                        .profiles()
                        .targetId("example-target-two")
                        .build())
                .build())
            .annotations(Map.ofEntries(
                Map.entry("my_first_annotation", "example-annotation-1"),
                Map.entry("my_second_annotation", "example-annotation-2")
            ))
            .labels(Map.ofEntries(
                Map.entry("my_first_label", "example-label-1"),
                Map.entry("my_second_label", "example-label-2")
            ))
            .build());
    }
}
Content copied to clipboard
resources:
  primary:
    type: gcp:clouddeploy:DeliveryPipeline
    properties:
      location: us-west1
      name: pipeline
      description: basic description
      project: my-project-name
      serialPipeline:
        stages:
          - deployParameters:
              - values:
                  deployParameterKey: deployParameterValue
                matchTargetLabels: {}
            profiles:
              - example-profile-one
              - example-profile-two
            targetId: example-target-one
          - profiles: []
            targetId: example-target-two
      annotations:
        my_first_annotation: example-annotation-1
        my_second_annotation: example-annotation-2
      labels:
        my_first_label: example-label-1
        my_second_label: example-label-2
Content copied to clipboard

Canaryrun_delivery_pipeline

Creates a basic Cloud Deploy delivery pipeline

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const primary = new gcp.clouddeploy.DeliveryPipeline("primary", {
    location: "us-west1",
    name: "pipeline",
    description: "basic description",
    project: "my-project-name",
    serialPipeline: {
        stages: [
            {
                deployParameters: [{
                    values: {
                        deployParameterKey: "deployParameterValue",
                    },
                    matchTargetLabels: {},
                }],
                profiles: [
                    "example-profile-one",
                    "example-profile-two",
                ],
                targetId: "example-target-one",
            },
            {
                profiles: [],
                targetId: "example-target-two",
            },
        ],
    },
    annotations: {
        my_first_annotation: "example-annotation-1",
        my_second_annotation: "example-annotation-2",
    },
    labels: {
        my_first_label: "example-label-1",
        my_second_label: "example-label-2",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
primary = gcp.clouddeploy.DeliveryPipeline("primary",
    location="us-west1",
    name="pipeline",
    description="basic description",
    project="my-project-name",
    serial_pipeline={
        "stages": [
            {
                "deploy_parameters": [{
                    "values": {
                        "deployParameterKey": "deployParameterValue",
                    },
                    "match_target_labels": {},
                }],
                "profiles": [
                    "example-profile-one",
                    "example-profile-two",
                ],
                "target_id": "example-target-one",
            },
            {
                "profiles": [],
                "target_id": "example-target-two",
            },
        ],
    },
    annotations={
        "my_first_annotation": "example-annotation-1",
        "my_second_annotation": "example-annotation-2",
    },
    labels={
        "my_first_label": "example-label-1",
        "my_second_label": "example-label-2",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var primary = new Gcp.CloudDeploy.DeliveryPipeline("primary", new()
    {
        Location = "us-west1",
        Name = "pipeline",
        Description = "basic description",
        Project = "my-project-name",
        SerialPipeline = new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineArgs
        {
            Stages = new[]
            {
                new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineStageArgs
                {
                    DeployParameters = new[]
                    {
                        new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineStageDeployParameterArgs
                        {
                            Values =
                            {
                                { "deployParameterKey", "deployParameterValue" },
                            },
                            MatchTargetLabels = null,
                        },
                    },
                    Profiles = new[]
                    {
                        "example-profile-one",
                        "example-profile-two",
                    },
                    TargetId = "example-target-one",
                },
                new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineStageArgs
                {
                    Profiles = new() { },
                    TargetId = "example-target-two",
                },
            },
        },
        Annotations =
        {
            { "my_first_annotation", "example-annotation-1" },
            { "my_second_annotation", "example-annotation-2" },
        },
        Labels =
        {
            { "my_first_label", "example-label-1" },
            { "my_second_label", "example-label-2" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/clouddeploy"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := clouddeploy.NewDeliveryPipeline(ctx, "primary", &clouddeploy.DeliveryPipelineArgs{
			Location:    pulumi.String("us-west1"),
			Name:        pulumi.String("pipeline"),
			Description: pulumi.String("basic description"),
			Project:     pulumi.String("my-project-name"),
			SerialPipeline: &clouddeploy.DeliveryPipelineSerialPipelineArgs{
				Stages: clouddeploy.DeliveryPipelineSerialPipelineStageArray{
					&clouddeploy.DeliveryPipelineSerialPipelineStageArgs{
						DeployParameters: clouddeploy.DeliveryPipelineSerialPipelineStageDeployParameterArray{
							&clouddeploy.DeliveryPipelineSerialPipelineStageDeployParameterArgs{
								Values: pulumi.StringMap{
									"deployParameterKey": pulumi.String("deployParameterValue"),
								},
								MatchTargetLabels: pulumi.StringMap{},
							},
						},
						Profiles: pulumi.StringArray{
							pulumi.String("example-profile-one"),
							pulumi.String("example-profile-two"),
						},
						TargetId: pulumi.String("example-target-one"),
					},
					&clouddeploy.DeliveryPipelineSerialPipelineStageArgs{
						Profiles: pulumi.StringArray{},
						TargetId: pulumi.String("example-target-two"),
					},
				},
			},
			Annotations: pulumi.StringMap{
				"my_first_annotation":  pulumi.String("example-annotation-1"),
				"my_second_annotation": pulumi.String("example-annotation-2"),
			},
			Labels: pulumi.StringMap{
				"my_first_label":  pulumi.String("example-label-1"),
				"my_second_label": pulumi.String("example-label-2"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.clouddeploy.DeliveryPipeline;
import com.pulumi.gcp.clouddeploy.DeliveryPipelineArgs;
import com.pulumi.gcp.clouddeploy.inputs.DeliveryPipelineSerialPipelineArgs;
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 primary = new DeliveryPipeline("primary", DeliveryPipelineArgs.builder()
            .location("us-west1")
            .name("pipeline")
            .description("basic description")
            .project("my-project-name")
            .serialPipeline(DeliveryPipelineSerialPipelineArgs.builder()
                .stages(
                    DeliveryPipelineSerialPipelineStageArgs.builder()
                        .deployParameters(DeliveryPipelineSerialPipelineStageDeployParameterArgs.builder()
                            .values(Map.of("deployParameterKey", "deployParameterValue"))
                            .matchTargetLabels(Map.ofEntries(
                            ))
                            .build())
                        .profiles(
                            "example-profile-one",
                            "example-profile-two")
                        .targetId("example-target-one")
                        .build(),
                    DeliveryPipelineSerialPipelineStageArgs.builder()
                        .profiles()
                        .targetId("example-target-two")
                        .build())
                .build())
            .annotations(Map.ofEntries(
                Map.entry("my_first_annotation", "example-annotation-1"),
                Map.entry("my_second_annotation", "example-annotation-2")
            ))
            .labels(Map.ofEntries(
                Map.entry("my_first_label", "example-label-1"),
                Map.entry("my_second_label", "example-label-2")
            ))
            .build());
    }
}
Content copied to clipboard
resources:
  primary:
    type: gcp:clouddeploy:DeliveryPipeline
    properties:
      location: us-west1
      name: pipeline
      description: basic description
      project: my-project-name
      serialPipeline:
        stages:
          - deployParameters:
              - values:
                  deployParameterKey: deployParameterValue
                matchTargetLabels: {}
            profiles:
              - example-profile-one
              - example-profile-two
            targetId: example-target-one
          - profiles: []
            targetId: example-target-two
      annotations:
        my_first_annotation: example-annotation-1
        my_second_annotation: example-annotation-2
      labels:
        my_first_label: example-label-1
        my_second_label: example-label-2
Content copied to clipboard

Delivery_pipeline

Creates a basic Cloud Deploy delivery pipeline

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const primary = new gcp.clouddeploy.DeliveryPipeline("primary", {
    location: "us-west1",
    name: "pipeline",
    description: "basic description",
    project: "my-project-name",
    serialPipeline: {
        stages: [
            {
                deployParameters: [{
                    values: {
                        deployParameterKey: "deployParameterValue",
                    },
                    matchTargetLabels: {},
                }],
                profiles: [
                    "example-profile-one",
                    "example-profile-two",
                ],
                targetId: "example-target-one",
            },
            {
                profiles: [],
                targetId: "example-target-two",
            },
        ],
    },
    annotations: {
        my_first_annotation: "example-annotation-1",
        my_second_annotation: "example-annotation-2",
    },
    labels: {
        my_first_label: "example-label-1",
        my_second_label: "example-label-2",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
primary = gcp.clouddeploy.DeliveryPipeline("primary",
    location="us-west1",
    name="pipeline",
    description="basic description",
    project="my-project-name",
    serial_pipeline={
        "stages": [
            {
                "deploy_parameters": [{
                    "values": {
                        "deployParameterKey": "deployParameterValue",
                    },
                    "match_target_labels": {},
                }],
                "profiles": [
                    "example-profile-one",
                    "example-profile-two",
                ],
                "target_id": "example-target-one",
            },
            {
                "profiles": [],
                "target_id": "example-target-two",
            },
        ],
    },
    annotations={
        "my_first_annotation": "example-annotation-1",
        "my_second_annotation": "example-annotation-2",
    },
    labels={
        "my_first_label": "example-label-1",
        "my_second_label": "example-label-2",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var primary = new Gcp.CloudDeploy.DeliveryPipeline("primary", new()
    {
        Location = "us-west1",
        Name = "pipeline",
        Description = "basic description",
        Project = "my-project-name",
        SerialPipeline = new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineArgs
        {
            Stages = new[]
            {
                new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineStageArgs
                {
                    DeployParameters = new[]
                    {
                        new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineStageDeployParameterArgs
                        {
                            Values =
                            {
                                { "deployParameterKey", "deployParameterValue" },
                            },
                            MatchTargetLabels = null,
                        },
                    },
                    Profiles = new[]
                    {
                        "example-profile-one",
                        "example-profile-two",
                    },
                    TargetId = "example-target-one",
                },
                new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineStageArgs
                {
                    Profiles = new() { },
                    TargetId = "example-target-two",
                },
            },
        },
        Annotations =
        {
            { "my_first_annotation", "example-annotation-1" },
            { "my_second_annotation", "example-annotation-2" },
        },
        Labels =
        {
            { "my_first_label", "example-label-1" },
            { "my_second_label", "example-label-2" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/clouddeploy"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := clouddeploy.NewDeliveryPipeline(ctx, "primary", &clouddeploy.DeliveryPipelineArgs{
			Location:    pulumi.String("us-west1"),
			Name:        pulumi.String("pipeline"),
			Description: pulumi.String("basic description"),
			Project:     pulumi.String("my-project-name"),
			SerialPipeline: &clouddeploy.DeliveryPipelineSerialPipelineArgs{
				Stages: clouddeploy.DeliveryPipelineSerialPipelineStageArray{
					&clouddeploy.DeliveryPipelineSerialPipelineStageArgs{
						DeployParameters: clouddeploy.DeliveryPipelineSerialPipelineStageDeployParameterArray{
							&clouddeploy.DeliveryPipelineSerialPipelineStageDeployParameterArgs{
								Values: pulumi.StringMap{
									"deployParameterKey": pulumi.String("deployParameterValue"),
								},
								MatchTargetLabels: pulumi.StringMap{},
							},
						},
						Profiles: pulumi.StringArray{
							pulumi.String("example-profile-one"),
							pulumi.String("example-profile-two"),
						},
						TargetId: pulumi.String("example-target-one"),
					},
					&clouddeploy.DeliveryPipelineSerialPipelineStageArgs{
						Profiles: pulumi.StringArray{},
						TargetId: pulumi.String("example-target-two"),
					},
				},
			},
			Annotations: pulumi.StringMap{
				"my_first_annotation":  pulumi.String("example-annotation-1"),
				"my_second_annotation": pulumi.String("example-annotation-2"),
			},
			Labels: pulumi.StringMap{
				"my_first_label":  pulumi.String("example-label-1"),
				"my_second_label": pulumi.String("example-label-2"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.clouddeploy.DeliveryPipeline;
import com.pulumi.gcp.clouddeploy.DeliveryPipelineArgs;
import com.pulumi.gcp.clouddeploy.inputs.DeliveryPipelineSerialPipelineArgs;
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 primary = new DeliveryPipeline("primary", DeliveryPipelineArgs.builder()
            .location("us-west1")
            .name("pipeline")
            .description("basic description")
            .project("my-project-name")
            .serialPipeline(DeliveryPipelineSerialPipelineArgs.builder()
                .stages(
                    DeliveryPipelineSerialPipelineStageArgs.builder()
                        .deployParameters(DeliveryPipelineSerialPipelineStageDeployParameterArgs.builder()
                            .values(Map.of("deployParameterKey", "deployParameterValue"))
                            .matchTargetLabels(Map.ofEntries(
                            ))
                            .build())
                        .profiles(
                            "example-profile-one",
                            "example-profile-two")
                        .targetId("example-target-one")
                        .build(),
                    DeliveryPipelineSerialPipelineStageArgs.builder()
                        .profiles()
                        .targetId("example-target-two")
                        .build())
                .build())
            .annotations(Map.ofEntries(
                Map.entry("my_first_annotation", "example-annotation-1"),
                Map.entry("my_second_annotation", "example-annotation-2")
            ))
            .labels(Map.ofEntries(
                Map.entry("my_first_label", "example-label-1"),
                Map.entry("my_second_label", "example-label-2")
            ))
            .build());
    }
}
Content copied to clipboard
resources:
  primary:
    type: gcp:clouddeploy:DeliveryPipeline
    properties:
      location: us-west1
      name: pipeline
      description: basic description
      project: my-project-name
      serialPipeline:
        stages:
          - deployParameters:
              - values:
                  deployParameterKey: deployParameterValue
                matchTargetLabels: {}
            profiles:
              - example-profile-one
              - example-profile-two
            targetId: example-target-one
          - profiles: []
            targetId: example-target-two
      annotations:
        my_first_annotation: example-annotation-1
        my_second_annotation: example-annotation-2
      labels:
        my_first_label: example-label-1
        my_second_label: example-label-2
Content copied to clipboard

Verify_delivery_pipeline

tests creating and updating a delivery pipeline with deployment verification strategy

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const primary = new gcp.clouddeploy.DeliveryPipeline("primary", {
    location: "us-west1",
    name: "pipeline",
    description: "basic description",
    project: "my-project-name",
    serialPipeline: {
        stages: [
            {
                deployParameters: [{
                    values: {
                        deployParameterKey: "deployParameterValue",
                    },
                    matchTargetLabels: {},
                }],
                profiles: [
                    "example-profile-one",
                    "example-profile-two",
                ],
                targetId: "example-target-one",
            },
            {
                profiles: [],
                targetId: "example-target-two",
            },
        ],
    },
    annotations: {
        my_first_annotation: "example-annotation-1",
        my_second_annotation: "example-annotation-2",
    },
    labels: {
        my_first_label: "example-label-1",
        my_second_label: "example-label-2",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
primary = gcp.clouddeploy.DeliveryPipeline("primary",
    location="us-west1",
    name="pipeline",
    description="basic description",
    project="my-project-name",
    serial_pipeline={
        "stages": [
            {
                "deploy_parameters": [{
                    "values": {
                        "deployParameterKey": "deployParameterValue",
                    },
                    "match_target_labels": {},
                }],
                "profiles": [
                    "example-profile-one",
                    "example-profile-two",
                ],
                "target_id": "example-target-one",
            },
            {
                "profiles": [],
                "target_id": "example-target-two",
            },
        ],
    },
    annotations={
        "my_first_annotation": "example-annotation-1",
        "my_second_annotation": "example-annotation-2",
    },
    labels={
        "my_first_label": "example-label-1",
        "my_second_label": "example-label-2",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var primary = new Gcp.CloudDeploy.DeliveryPipeline("primary", new()
    {
        Location = "us-west1",
        Name = "pipeline",
        Description = "basic description",
        Project = "my-project-name",
        SerialPipeline = new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineArgs
        {
            Stages = new[]
            {
                new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineStageArgs
                {
                    DeployParameters = new[]
                    {
                        new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineStageDeployParameterArgs
                        {
                            Values =
                            {
                                { "deployParameterKey", "deployParameterValue" },
                            },
                            MatchTargetLabels = null,
                        },
                    },
                    Profiles = new[]
                    {
                        "example-profile-one",
                        "example-profile-two",
                    },
                    TargetId = "example-target-one",
                },
                new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineStageArgs
                {
                    Profiles = new() { },
                    TargetId = "example-target-two",
                },
            },
        },
        Annotations =
        {
            { "my_first_annotation", "example-annotation-1" },
            { "my_second_annotation", "example-annotation-2" },
        },
        Labels =
        {
            { "my_first_label", "example-label-1" },
            { "my_second_label", "example-label-2" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/clouddeploy"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := clouddeploy.NewDeliveryPipeline(ctx, "primary", &clouddeploy.DeliveryPipelineArgs{
			Location:    pulumi.String("us-west1"),
			Name:        pulumi.String("pipeline"),
			Description: pulumi.String("basic description"),
			Project:     pulumi.String("my-project-name"),
			SerialPipeline: &clouddeploy.DeliveryPipelineSerialPipelineArgs{
				Stages: clouddeploy.DeliveryPipelineSerialPipelineStageArray{
					&clouddeploy.DeliveryPipelineSerialPipelineStageArgs{
						DeployParameters: clouddeploy.DeliveryPipelineSerialPipelineStageDeployParameterArray{
							&clouddeploy.DeliveryPipelineSerialPipelineStageDeployParameterArgs{
								Values: pulumi.StringMap{
									"deployParameterKey": pulumi.String("deployParameterValue"),
								},
								MatchTargetLabels: pulumi.StringMap{},
							},
						},
						Profiles: pulumi.StringArray{
							pulumi.String("example-profile-one"),
							pulumi.String("example-profile-two"),
						},
						TargetId: pulumi.String("example-target-one"),
					},
					&clouddeploy.DeliveryPipelineSerialPipelineStageArgs{
						Profiles: pulumi.StringArray{},
						TargetId: pulumi.String("example-target-two"),
					},
				},
			},
			Annotations: pulumi.StringMap{
				"my_first_annotation":  pulumi.String("example-annotation-1"),
				"my_second_annotation": pulumi.String("example-annotation-2"),
			},
			Labels: pulumi.StringMap{
				"my_first_label":  pulumi.String("example-label-1"),
				"my_second_label": pulumi.String("example-label-2"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.clouddeploy.DeliveryPipeline;
import com.pulumi.gcp.clouddeploy.DeliveryPipelineArgs;
import com.pulumi.gcp.clouddeploy.inputs.DeliveryPipelineSerialPipelineArgs;
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 primary = new DeliveryPipeline("primary", DeliveryPipelineArgs.builder()
            .location("us-west1")
            .name("pipeline")
            .description("basic description")
            .project("my-project-name")
            .serialPipeline(DeliveryPipelineSerialPipelineArgs.builder()
                .stages(
                    DeliveryPipelineSerialPipelineStageArgs.builder()
                        .deployParameters(DeliveryPipelineSerialPipelineStageDeployParameterArgs.builder()
                            .values(Map.of("deployParameterKey", "deployParameterValue"))
                            .matchTargetLabels(Map.ofEntries(
                            ))
                            .build())
                        .profiles(
                            "example-profile-one",
                            "example-profile-two")
                        .targetId("example-target-one")
                        .build(),
                    DeliveryPipelineSerialPipelineStageArgs.builder()
                        .profiles()
                        .targetId("example-target-two")
                        .build())
                .build())
            .annotations(Map.ofEntries(
                Map.entry("my_first_annotation", "example-annotation-1"),
                Map.entry("my_second_annotation", "example-annotation-2")
            ))
            .labels(Map.ofEntries(
                Map.entry("my_first_label", "example-label-1"),
                Map.entry("my_second_label", "example-label-2")
            ))
            .build());
    }
}
Content copied to clipboard
resources:
  primary:
    type: gcp:clouddeploy:DeliveryPipeline
    properties:
      location: us-west1
      name: pipeline
      description: basic description
      project: my-project-name
      serialPipeline:
        stages:
          - deployParameters:
              - values:
                  deployParameterKey: deployParameterValue
                matchTargetLabels: {}
            profiles:
              - example-profile-one
              - example-profile-two
            targetId: example-target-one
          - profiles: []
            targetId: example-target-two
      annotations:
        my_first_annotation: example-annotation-1
        my_second_annotation: example-annotation-2
      labels:
        my_first_label: example-label-1
        my_second_label: example-label-2
Content copied to clipboard

Import

DeliveryPipeline can be imported using any of these accepted formats:

  • projects/{{project}}/locations/{{location}}/deliveryPipelines/{{name}}

  • {{project}}/{{location}}/{{name}}

  • {{location}}/{{name}} When using the pulumi import command, DeliveryPipeline can be imported using one of the formats above. For example:

$ pulumi import gcp:clouddeploy/deliveryPipeline:DeliveryPipeline default projects/{{project}}/locations/{{location}}/deliveryPipelines/{{name}}
Content copied to clipboard
$ pulumi import gcp:clouddeploy/deliveryPipeline:DeliveryPipeline default {{project}}/{{location}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:clouddeploy/deliveryPipeline:DeliveryPipeline default {{location}}/{{name}}
Content copied to clipboard

Properties

Link copied to clipboard
val annotations: Output<Map<String, String>>?

User annotations. These attributes can only be set and used by the user, and not by Google Cloud Deploy. See https://google.aip.dev/128#annotations for more details such as format and size limitations. Note: This field is non-authoritative, and will only manage the annotations present in your configuration. Please refer to the field effective_annotations for all of the annotations present on the resource.

Link copied to clipboard
val conditions: Output<List<DeliveryPipelineCondition>>

Output only. Information around the state of the Delivery Pipeline.

Link copied to clipboard
val createTime: Output<String>

Output only. Time at which the pipeline was created.

Link copied to clipboard
val description: Output<String>?

Description of the DeliveryPipeline. Max length is 255 characters.

Link copied to clipboard
Link copied to clipboard
val effectiveLabels: Output<Map<String, String>>

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

Link copied to clipboard
val etag: Output<String>

This checksum is computed by the server based on the value of other fields, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val labels: Output<Map<String, String>>?

Labels are attributes that can be set and used by both the user and by Google Cloud Deploy. Labels must meet the following constraints: * Keys and values can contain only lowercase letters, numeric characters, underscores, and dashes. * All characters must use UTF-8 encoding, and international characters are allowed. * Keys must start with a lowercase letter or international character. * Each resource is limited to a maximum of 64 labels. Both keys and values are additionally constrained to be <= 128 bytes. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.

Link copied to clipboard
val location: Output<String>

The location for the resource

Link copied to clipboard
val name: Output<String>

Name of the DeliveryPipeline. Format is a-z?.

Link copied to clipboard
val project: Output<String>

The project for the resource

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
val pulumiLabels: Output<Map<String, String>>

The combination of labels configured directly on the resource and default labels configured on the provider.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val serialPipeline: Output<DeliveryPipelineSerialPipeline>?

SerialPipeline defines a sequential set of stages for a DeliveryPipeline.

Link copied to clipboard
val suspended: Output<Boolean>?

When suspended, no new releases or rollouts can be created, but in-progress ones will complete.

Link copied to clipboard
val uid: Output<String>

Output only. Unique identifier of the DeliveryPipeline.

Link copied to clipboard
val updateTime: Output<String>

Output only. Most recent time at which the pipeline was updated.

Link copied to clipboard
val urn: Output<String>