All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.pulumi.gcp.clouddeploy.kotlin.Automation.kt Maven / Gradle / Ivy

Go to download

Build cloud applications and infrastructure by combining the safety and reliability of infrastructure as code with the power of the Kotlin programming language.

There is a newer version: 8.10.0.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.gcp.clouddeploy.kotlin

import com.pulumi.core.Output
import com.pulumi.gcp.clouddeploy.kotlin.outputs.AutomationRule
import com.pulumi.gcp.clouddeploy.kotlin.outputs.AutomationSelector
import com.pulumi.kotlin.KotlinCustomResource
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.ResourceMapper
import com.pulumi.kotlin.options.CustomResourceOptions
import com.pulumi.kotlin.options.CustomResourceOptionsBuilder
import com.pulumi.resources.Resource
import kotlin.Boolean
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.Map
import com.pulumi.gcp.clouddeploy.kotlin.outputs.AutomationRule.Companion.toKotlin as automationRuleToKotlin
import com.pulumi.gcp.clouddeploy.kotlin.outputs.AutomationSelector.Companion.toKotlin as automationSelectorToKotlin

/**
 * Builder for [Automation].
 */
@PulumiTagMarker
public class AutomationResourceBuilder internal constructor() {
    public var name: String? = null

    public var args: AutomationArgs = AutomationArgs()

    public var opts: CustomResourceOptions = CustomResourceOptions()

    /**
     * @param name The _unique_ name of the resulting resource.
     */
    public fun name(`value`: String) {
        this.name = value
    }

    /**
     * @param block The arguments to use to populate this resource's properties.
     */
    public suspend fun args(block: suspend AutomationArgsBuilder.() -> Unit) {
        val builder = AutomationArgsBuilder()
        block(builder)
        this.args = builder.build()
    }

    /**
     * @param block A bag of options that control this resource's behavior.
     */
    public suspend fun opts(block: suspend CustomResourceOptionsBuilder.() -> Unit) {
        this.opts = com.pulumi.kotlin.options.CustomResourceOptions.opts(block)
    }

    internal fun build(): Automation {
        val builtJavaResource = com.pulumi.gcp.clouddeploy.Automation(
            this.name,
            this.args.toJava(),
            this.opts.toJava(),
        )
        return Automation(builtJavaResource)
    }
}

/**
 * An `Automation` enables the automation of manually driven actions for a Delivery Pipeline, which includes Release promotion amongst Targets, Rollout repair and Rollout deployment strategy advancement.
 * To get more information about Automation, see:
 * * [API documentation](https://cloud.google.com/deploy/docs/api/reference/rest/v1/projects.locations.deliveryPipelines.automations)
 * * How-to Guides
 *     * [Automate your deployment](https://cloud.google.com/deploy/docs/automation)
 * ## Example Usage
 * ### Clouddeploy Automation Basic
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const pipeline = new gcp.clouddeploy.DeliveryPipeline("pipeline", {
 *     name: "cd-pipeline",
 *     location: "us-central1",
 *     serialPipeline: {
 *         stages: [{
 *             targetId: "test",
 *             profiles: [],
 *         }],
 *     },
 * });
 * const b_automation = new gcp.clouddeploy.Automation("b-automation", {
 *     name: "cd-automation",
 *     project: pipeline.project,
 *     location: pipeline.location,
 *     deliveryPipeline: pipeline.name,
 *     serviceAccount: "[email protected]",
 *     selector: {
 *         targets: [{
 *             id: "*",
 *         }],
 *     },
 *     suspended: false,
 *     rules: [{
 *         promoteReleaseRule: {
 *             id: "promote-release",
 *         },
 *     }],
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * pipeline = gcp.clouddeploy.DeliveryPipeline("pipeline",
 *     name="cd-pipeline",
 *     location="us-central1",
 *     serial_pipeline=gcp.clouddeploy.DeliveryPipelineSerialPipelineArgs(
 *         stages=[gcp.clouddeploy.DeliveryPipelineSerialPipelineStageArgs(
 *             target_id="test",
 *             profiles=[],
 *         )],
 *     ))
 * b_automation = gcp.clouddeploy.Automation("b-automation",
 *     name="cd-automation",
 *     project=pipeline.project,
 *     location=pipeline.location,
 *     delivery_pipeline=pipeline.name,
 *     service_account="[email protected]",
 *     selector=gcp.clouddeploy.AutomationSelectorArgs(
 *         targets=[gcp.clouddeploy.AutomationSelectorTargetArgs(
 *             id="*",
 *         )],
 *     ),
 *     suspended=False,
 *     rules=[gcp.clouddeploy.AutomationRuleArgs(
 *         promote_release_rule=gcp.clouddeploy.AutomationRulePromoteReleaseRuleArgs(
 *             id="promote-release",
 *         ),
 *     )])
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var pipeline = new Gcp.CloudDeploy.DeliveryPipeline("pipeline", new()
 *     {
 *         Name = "cd-pipeline",
 *         Location = "us-central1",
 *         SerialPipeline = new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineArgs
 *         {
 *             Stages = new[]
 *             {
 *                 new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineStageArgs
 *                 {
 *                     TargetId = "test",
 *                     Profiles = new() { },
 *                 },
 *             },
 *         },
 *     });
 *     var b_automation = new Gcp.CloudDeploy.Automation("b-automation", new()
 *     {
 *         Name = "cd-automation",
 *         Project = pipeline.Project,
 *         Location = pipeline.Location,
 *         DeliveryPipeline = pipeline.Name,
 *         ServiceAccount = "[email protected]",
 *         Selector = new Gcp.CloudDeploy.Inputs.AutomationSelectorArgs
 *         {
 *             Targets = new[]
 *             {
 *                 new Gcp.CloudDeploy.Inputs.AutomationSelectorTargetArgs
 *                 {
 *                     Id = "*",
 *                 },
 *             },
 *         },
 *         Suspended = false,
 *         Rules = new[]
 *         {
 *             new Gcp.CloudDeploy.Inputs.AutomationRuleArgs
 *             {
 *                 PromoteReleaseRule = new Gcp.CloudDeploy.Inputs.AutomationRulePromoteReleaseRuleArgs
 *                 {
 *                     Id = "promote-release",
 *                 },
 *             },
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/clouddeploy"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		pipeline, err := clouddeploy.NewDeliveryPipeline(ctx, "pipeline", &clouddeploy.DeliveryPipelineArgs{
 * 			Name:     pulumi.String("cd-pipeline"),
 * 			Location: pulumi.String("us-central1"),
 * 			SerialPipeline: &clouddeploy.DeliveryPipelineSerialPipelineArgs{
 * 				Stages: clouddeploy.DeliveryPipelineSerialPipelineStageArray{
 * 					&clouddeploy.DeliveryPipelineSerialPipelineStageArgs{
 * 						TargetId: pulumi.String("test"),
 * 						Profiles: pulumi.StringArray{},
 * 					},
 * 				},
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = clouddeploy.NewAutomation(ctx, "b-automation", &clouddeploy.AutomationArgs{
 * 			Name:             pulumi.String("cd-automation"),
 * 			Project:          pipeline.Project,
 * 			Location:         pipeline.Location,
 * 			DeliveryPipeline: pipeline.Name,
 * 			ServiceAccount:   pulumi.String("[email protected]"),
 * 			Selector: &clouddeploy.AutomationSelectorArgs{
 * 				Targets: clouddeploy.AutomationSelectorTargetArray{
 * 					&clouddeploy.AutomationSelectorTargetArgs{
 * 						Id: pulumi.String("*"),
 * 					},
 * 				},
 * 			},
 * 			Suspended: pulumi.Bool(false),
 * 			Rules: clouddeploy.AutomationRuleArray{
 * 				&clouddeploy.AutomationRuleArgs{
 * 					PromoteReleaseRule: &clouddeploy.AutomationRulePromoteReleaseRuleArgs{
 * 						Id: pulumi.String("promote-release"),
 * 					},
 * 				},
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		return nil
 * 	})
 * }
 * ```
 * ```java
 * 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 com.pulumi.gcp.clouddeploy.Automation;
 * import com.pulumi.gcp.clouddeploy.AutomationArgs;
 * import com.pulumi.gcp.clouddeploy.inputs.AutomationSelectorArgs;
 * import com.pulumi.gcp.clouddeploy.inputs.AutomationRuleArgs;
 * import com.pulumi.gcp.clouddeploy.inputs.AutomationRulePromoteReleaseRuleArgs;
 * 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 pipeline = new DeliveryPipeline("pipeline", DeliveryPipelineArgs.builder()
 *             .name("cd-pipeline")
 *             .location("us-central1")
 *             .serialPipeline(DeliveryPipelineSerialPipelineArgs.builder()
 *                 .stages(DeliveryPipelineSerialPipelineStageArgs.builder()
 *                     .targetId("test")
 *                     .profiles()
 *                     .build())
 *                 .build())
 *             .build());
 *         var b_automation = new Automation("b-automation", AutomationArgs.builder()
 *             .name("cd-automation")
 *             .project(pipeline.project())
 *             .location(pipeline.location())
 *             .deliveryPipeline(pipeline.name())
 *             .serviceAccount("[email protected]")
 *             .selector(AutomationSelectorArgs.builder()
 *                 .targets(AutomationSelectorTargetArgs.builder()
 *                     .id("*")
 *                     .build())
 *                 .build())
 *             .suspended(false)
 *             .rules(AutomationRuleArgs.builder()
 *                 .promoteReleaseRule(AutomationRulePromoteReleaseRuleArgs.builder()
 *                     .id("promote-release")
 *                     .build())
 *                 .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   b-automation:
 *     type: gcp:clouddeploy:Automation
 *     properties:
 *       name: cd-automation
 *       project: ${pipeline.project}
 *       location: ${pipeline.location}
 *       deliveryPipeline: ${pipeline.name}
 *       serviceAccount: [email protected]
 *       selector:
 *         targets:
 *           - id: '*'
 *       suspended: false
 *       rules:
 *         - promoteReleaseRule:
 *             id: promote-release
 *   pipeline:
 *     type: gcp:clouddeploy:DeliveryPipeline
 *     properties:
 *       name: cd-pipeline
 *       location: us-central1
 *       serialPipeline:
 *         stages:
 *           - targetId: test
 *             profiles: []
 * ```
 * 
 * ### Clouddeploy Automation Full
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const pipeline = new gcp.clouddeploy.DeliveryPipeline("pipeline", {
 *     name: "cd-pipeline",
 *     location: "us-central1",
 *     serialPipeline: {
 *         stages: [{
 *             targetId: "test",
 *             profiles: ["test-profile"],
 *         }],
 *     },
 * });
 * const f_automation = new gcp.clouddeploy.Automation("f-automation", {
 *     name: "cd-automation",
 *     location: "us-central1",
 *     deliveryPipeline: pipeline.name,
 *     serviceAccount: "[email protected]",
 *     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",
 *     },
 *     description: "automation resource",
 *     selector: {
 *         targets: [{
 *             id: "test",
 *             labels: {
 *                 foo: "bar",
 *             },
 *         }],
 *     },
 *     suspended: true,
 *     rules: [
 *         {
 *             promoteReleaseRule: {
 *                 id: "promote-release",
 *                 wait: "200s",
 *                 destinationTargetId: "@next",
 *                 destinationPhase: "stable",
 *             },
 *         },
 *         {
 *             advanceRolloutRule: {
 *                 id: "advance-rollout",
 *                 sourcePhases: ["deploy"],
 *                 wait: "200s",
 *             },
 *         },
 *     ],
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * pipeline = gcp.clouddeploy.DeliveryPipeline("pipeline",
 *     name="cd-pipeline",
 *     location="us-central1",
 *     serial_pipeline=gcp.clouddeploy.DeliveryPipelineSerialPipelineArgs(
 *         stages=[gcp.clouddeploy.DeliveryPipelineSerialPipelineStageArgs(
 *             target_id="test",
 *             profiles=["test-profile"],
 *         )],
 *     ))
 * f_automation = gcp.clouddeploy.Automation("f-automation",
 *     name="cd-automation",
 *     location="us-central1",
 *     delivery_pipeline=pipeline.name,
 *     service_account="[email protected]",
 *     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",
 *     },
 *     description="automation resource",
 *     selector=gcp.clouddeploy.AutomationSelectorArgs(
 *         targets=[gcp.clouddeploy.AutomationSelectorTargetArgs(
 *             id="test",
 *             labels={
 *                 "foo": "bar",
 *             },
 *         )],
 *     ),
 *     suspended=True,
 *     rules=[
 *         gcp.clouddeploy.AutomationRuleArgs(
 *             promote_release_rule=gcp.clouddeploy.AutomationRulePromoteReleaseRuleArgs(
 *                 id="promote-release",
 *                 wait="200s",
 *                 destination_target_id="@next",
 *                 destination_phase="stable",
 *             ),
 *         ),
 *         gcp.clouddeploy.AutomationRuleArgs(
 *             advance_rollout_rule=gcp.clouddeploy.AutomationRuleAdvanceRolloutRuleArgs(
 *                 id="advance-rollout",
 *                 source_phases=["deploy"],
 *                 wait="200s",
 *             ),
 *         ),
 *     ])
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var pipeline = new Gcp.CloudDeploy.DeliveryPipeline("pipeline", new()
 *     {
 *         Name = "cd-pipeline",
 *         Location = "us-central1",
 *         SerialPipeline = new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineArgs
 *         {
 *             Stages = new[]
 *             {
 *                 new Gcp.CloudDeploy.Inputs.DeliveryPipelineSerialPipelineStageArgs
 *                 {
 *                     TargetId = "test",
 *                     Profiles = new[]
 *                     {
 *                         "test-profile",
 *                     },
 *                 },
 *             },
 *         },
 *     });
 *     var f_automation = new Gcp.CloudDeploy.Automation("f-automation", new()
 *     {
 *         Name = "cd-automation",
 *         Location = "us-central1",
 *         DeliveryPipeline = pipeline.Name,
 *         ServiceAccount = "[email protected]",
 *         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" },
 *         },
 *         Description = "automation resource",
 *         Selector = new Gcp.CloudDeploy.Inputs.AutomationSelectorArgs
 *         {
 *             Targets = new[]
 *             {
 *                 new Gcp.CloudDeploy.Inputs.AutomationSelectorTargetArgs
 *                 {
 *                     Id = "test",
 *                     Labels =
 *                     {
 *                         { "foo", "bar" },
 *                     },
 *                 },
 *             },
 *         },
 *         Suspended = true,
 *         Rules = new[]
 *         {
 *             new Gcp.CloudDeploy.Inputs.AutomationRuleArgs
 *             {
 *                 PromoteReleaseRule = new Gcp.CloudDeploy.Inputs.AutomationRulePromoteReleaseRuleArgs
 *                 {
 *                     Id = "promote-release",
 *                     Wait = "200s",
 *                     DestinationTargetId = "@next",
 *                     DestinationPhase = "stable",
 *                 },
 *             },
 *             new Gcp.CloudDeploy.Inputs.AutomationRuleArgs
 *             {
 *                 AdvanceRolloutRule = new Gcp.CloudDeploy.Inputs.AutomationRuleAdvanceRolloutRuleArgs
 *                 {
 *                     Id = "advance-rollout",
 *                     SourcePhases = new[]
 *                     {
 *                         "deploy",
 *                     },
 *                     Wait = "200s",
 *                 },
 *             },
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/clouddeploy"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		pipeline, err := clouddeploy.NewDeliveryPipeline(ctx, "pipeline", &clouddeploy.DeliveryPipelineArgs{
 * 			Name:     pulumi.String("cd-pipeline"),
 * 			Location: pulumi.String("us-central1"),
 * 			SerialPipeline: &clouddeploy.DeliveryPipelineSerialPipelineArgs{
 * 				Stages: clouddeploy.DeliveryPipelineSerialPipelineStageArray{
 * 					&clouddeploy.DeliveryPipelineSerialPipelineStageArgs{
 * 						TargetId: pulumi.String("test"),
 * 						Profiles: pulumi.StringArray{
 * 							pulumi.String("test-profile"),
 * 						},
 * 					},
 * 				},
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = clouddeploy.NewAutomation(ctx, "f-automation", &clouddeploy.AutomationArgs{
 * 			Name:             pulumi.String("cd-automation"),
 * 			Location:         pulumi.String("us-central1"),
 * 			DeliveryPipeline: pipeline.Name,
 * 			ServiceAccount:   pulumi.String("[email protected]"),
 * 			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"),
 * 			},
 * 			Description: pulumi.String("automation resource"),
 * 			Selector: &clouddeploy.AutomationSelectorArgs{
 * 				Targets: clouddeploy.AutomationSelectorTargetArray{
 * 					&clouddeploy.AutomationSelectorTargetArgs{
 * 						Id: pulumi.String("test"),
 * 						Labels: pulumi.StringMap{
 * 							"foo": pulumi.String("bar"),
 * 						},
 * 					},
 * 				},
 * 			},
 * 			Suspended: pulumi.Bool(true),
 * 			Rules: clouddeploy.AutomationRuleArray{
 * 				&clouddeploy.AutomationRuleArgs{
 * 					PromoteReleaseRule: &clouddeploy.AutomationRulePromoteReleaseRuleArgs{
 * 						Id:                  pulumi.String("promote-release"),
 * 						Wait:                pulumi.String("200s"),
 * 						DestinationTargetId: pulumi.String("@next"),
 * 						DestinationPhase:    pulumi.String("stable"),
 * 					},
 * 				},
 * 				&clouddeploy.AutomationRuleArgs{
 * 					AdvanceRolloutRule: &clouddeploy.AutomationRuleAdvanceRolloutRuleArgs{
 * 						Id: pulumi.String("advance-rollout"),
 * 						SourcePhases: pulumi.StringArray{
 * 							pulumi.String("deploy"),
 * 						},
 * 						Wait: pulumi.String("200s"),
 * 					},
 * 				},
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		return nil
 * 	})
 * }
 * ```
 * ```java
 * 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 com.pulumi.gcp.clouddeploy.Automation;
 * import com.pulumi.gcp.clouddeploy.AutomationArgs;
 * import com.pulumi.gcp.clouddeploy.inputs.AutomationSelectorArgs;
 * import com.pulumi.gcp.clouddeploy.inputs.AutomationRuleArgs;
 * import com.pulumi.gcp.clouddeploy.inputs.AutomationRulePromoteReleaseRuleArgs;
 * import com.pulumi.gcp.clouddeploy.inputs.AutomationRuleAdvanceRolloutRuleArgs;
 * 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 pipeline = new DeliveryPipeline("pipeline", DeliveryPipelineArgs.builder()
 *             .name("cd-pipeline")
 *             .location("us-central1")
 *             .serialPipeline(DeliveryPipelineSerialPipelineArgs.builder()
 *                 .stages(DeliveryPipelineSerialPipelineStageArgs.builder()
 *                     .targetId("test")
 *                     .profiles("test-profile")
 *                     .build())
 *                 .build())
 *             .build());
 *         var f_automation = new Automation("f-automation", AutomationArgs.builder()
 *             .name("cd-automation")
 *             .location("us-central1")
 *             .deliveryPipeline(pipeline.name())
 *             .serviceAccount("[email protected]")
 *             .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")
 *             ))
 *             .description("automation resource")
 *             .selector(AutomationSelectorArgs.builder()
 *                 .targets(AutomationSelectorTargetArgs.builder()
 *                     .id("test")
 *                     .labels(Map.of("foo", "bar"))
 *                     .build())
 *                 .build())
 *             .suspended(true)
 *             .rules(
 *                 AutomationRuleArgs.builder()
 *                     .promoteReleaseRule(AutomationRulePromoteReleaseRuleArgs.builder()
 *                         .id("promote-release")
 *                         .wait("200s")
 *                         .destinationTargetId("@next")
 *                         .destinationPhase("stable")
 *                         .build())
 *                     .build(),
 *                 AutomationRuleArgs.builder()
 *                     .advanceRolloutRule(AutomationRuleAdvanceRolloutRuleArgs.builder()
 *                         .id("advance-rollout")
 *                         .sourcePhases("deploy")
 *                         .wait("200s")
 *                         .build())
 *                     .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   f-automation:
 *     type: gcp:clouddeploy:Automation
 *     properties:
 *       name: cd-automation
 *       location: us-central1
 *       deliveryPipeline: ${pipeline.name}
 *       serviceAccount: [email protected]
 *       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
 *       description: automation resource
 *       selector:
 *         targets:
 *           - id: test
 *             labels:
 *               foo: bar
 *       suspended: true
 *       rules:
 *         - promoteReleaseRule:
 *             id: promote-release
 *             wait: 200s
 *             destinationTargetId: '@next'
 *             destinationPhase: stable
 *         - advanceRolloutRule:
 *             id: advance-rollout
 *             sourcePhases:
 *               - deploy
 *             wait: 200s
 *   pipeline:
 *     type: gcp:clouddeploy:DeliveryPipeline
 *     properties:
 *       name: cd-pipeline
 *       location: us-central1
 *       serialPipeline:
 *         stages:
 *           - targetId: test
 *             profiles:
 *               - test-profile
 * ```
 * 
 * ## Import
 * Automation can be imported using any of these accepted formats:
 * * `projects/{{project}}/locations/{{location}}/deliveryPipelines/{{delivery_pipeline}}/automations/{{name}}`
 * * `{{project}}/{{location}}/{{delivery_pipeline}}/{{name}}`
 * * `{{location}}/{{delivery_pipeline}}/{{name}}`
 * When using the `pulumi import` command, Automation can be imported using one of the formats above. For example:
 * ```sh
 * $ pulumi import gcp:clouddeploy/automation:Automation default projects/{{project}}/locations/{{location}}/deliveryPipelines/{{delivery_pipeline}}/automations/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:clouddeploy/automation:Automation default {{project}}/{{location}}/{{delivery_pipeline}}/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:clouddeploy/automation:Automation default {{location}}/{{delivery_pipeline}}/{{name}}
 * ```
 */
public class Automation internal constructor(
    override val javaResource: com.pulumi.gcp.clouddeploy.Automation,
) : KotlinCustomResource(javaResource, AutomationMapper) {
    /**
     * Optional. User annotations. These attributes can only be set and used by the user, and not by Cloud Deploy. Annotations
     * must meet the following constraints: * Annotations are key/value pairs. * Valid annotation keys have two segments: an
     * optional prefix and name, separated by a slash ('/'). * The name segment is required and must be 63 characters or less,
     * beginning and ending with an alphanumeric character ('[a-z0-9A-Z]') with dashes ('-'), underscores ('_'), dots ('.'),
     * and alphanumerics between. * The prefix is optional. If specified, the prefix must be a DNS subdomain: a series of DNS
     * labels separated by dots('.'), not longer than 253 characters in total, followed by a slash ('/'). See
     * https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/#syntax-and-character-set for more
     * details. **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.
     */
    public val annotations: Output>?
        get() = javaResource.annotations().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.map({ args0 ->
                    args0.key.to(args0.value)
                }).toMap()
            }).orElse(null)
        })

    /**
     * Output only. Time at which the automation was created.
     */
    public val createTime: Output
        get() = javaResource.createTime().applyValue({ args0 -> args0 })

    /**
     * The delivery_pipeline for the resource
     */
    public val deliveryPipeline: Output
        get() = javaResource.deliveryPipeline().applyValue({ args0 -> args0 })

    /**
     * Optional. Description of the 'Automation'. Max length is 255 characters.
     */
    public val description: Output?
        get() = javaResource.description().applyValue({ args0 ->
            args0.map({ args0 ->
                args0
            }).orElse(null)
        })

    public val effectiveAnnotations: Output>
        get() = javaResource.effectiveAnnotations().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.key.to(args0.value)
            }).toMap()
        })

    /**
     * All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
     */
    public val effectiveLabels: Output>
        get() = javaResource.effectiveLabels().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.key.to(args0.value)
            }).toMap()
        })

    /**
     * Optional. The weak etag of the `Automation` resource. 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.
     */
    public val etag: Output
        get() = javaResource.etag().applyValue({ args0 -> args0 })

    /**
     * Optional. Labels are attributes that can be set and used by both the user and by 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 <= 63 characters. **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.
     */
    public val labels: Output>?
        get() = javaResource.labels().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.map({ args0 ->
                    args0.key.to(args0.value)
                }).toMap()
            }).orElse(null)
        })

    /**
     * The location for the resource
     */
    public val location: Output
        get() = javaResource.location().applyValue({ args0 -> args0 })

    /**
     * Name of the `Automation`.
     */
    public val name: Output
        get() = javaResource.name().applyValue({ args0 -> args0 })

    public val project: Output
        get() = javaResource.project().applyValue({ args0 -> args0 })

    /**
     * The combination of labels configured directly on the resource
     * and default labels configured on the provider.
     */
    public val pulumiLabels: Output>
        get() = javaResource.pulumiLabels().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.key.to(args0.value)
            }).toMap()
        })

    /**
     * Required. List of Automation rules associated with the Automation resource. Must have at least one rule and limited to 250 rules per Delivery Pipeline. Note: the order of the rules here is not the same as the order of execution.
     * Structure is documented below.
     */
    public val rules: Output>
        get() = javaResource.rules().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 ->
                    automationRuleToKotlin(args0)
                })
            })
        })

    /**
     * Required. Selected resources to which the automation will be applied.
     * Structure is documented below.
     */
    public val selector: Output
        get() = javaResource.selector().applyValue({ args0 ->
            args0.let({ args0 ->
                automationSelectorToKotlin(args0)
            })
        })

    /**
     * Required. Email address of the user-managed IAM service account that creates Cloud Deploy release and rollout resources.
     */
    public val serviceAccount: Output
        get() = javaResource.serviceAccount().applyValue({ args0 -> args0 })

    /**
     * Optional. When Suspended, automation is deactivated from execution.
     */
    public val suspended: Output?
        get() = javaResource.suspended().applyValue({ args0 -> args0.map({ args0 -> args0 }).orElse(null) })

    /**
     * Output only. Unique identifier of the `Automation`.
     */
    public val uid: Output
        get() = javaResource.uid().applyValue({ args0 -> args0 })

    /**
     * Output only. Time at which the automation was updated.
     */
    public val updateTime: Output
        get() = javaResource.updateTime().applyValue({ args0 -> args0 })
}

public object AutomationMapper : ResourceMapper {
    override fun supportsMappingOfType(javaResource: Resource): Boolean =
        com.pulumi.gcp.clouddeploy.Automation::class == javaResource::class

    override fun map(javaResource: Resource): Automation = Automation(
        javaResource as
            com.pulumi.gcp.clouddeploy.Automation,
    )
}

/**
 * @see [Automation].
 * @param name The _unique_ name of the resulting resource.
 * @param block Builder for [Automation].
 */
public suspend fun automation(name: String, block: suspend AutomationResourceBuilder.() -> Unit): Automation {
    val builder = AutomationResourceBuilder()
    builder.name(name)
    block(builder)
    return builder.build()
}

/**
 * @see [Automation].
 * @param name The _unique_ name of the resulting resource.
 */
public fun automation(name: String): Automation {
    val builder = AutomationResourceBuilder()
    builder.name(name)
    return builder.build()
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy