platform.Lifecycle

import * as pulumi from "@pulumi/pulumi";
import * as platform from "@pulumi/platform";

// First, create the lifecycle stages
const dev = new platform.LifecycleStage("dev", {
    name: "dev",
    category: "promote",
});
const qa = new platform.LifecycleStage("qa", {
    name: "qa",
    category: "promote",
});
// Global lifecycle
// Note: PROD, PR, and COMMIT are system-managed stages and should not be included in promote_stages
const global = new platform.Lifecycle("global", {promoteStages: [
    dev.name,
    qa.name,
]});
// Project-level lifecycle
// Note: Project-scoped stages must be prefixed with project_key
const projectDev = new platform.LifecycleStage("project_dev", {
    name: "my-project-dev",
    projectKey: "my-project",
    category: "promote",
});
const projectStaging = new platform.LifecycleStage("project_staging", {
    name: "my-project-staging",
    projectKey: "my-project",
    category: "promote",
});
const project = new platform.Lifecycle("project", {
    projectKey: "my-project",
    promoteStages: [
        projectDev.name,
        projectStaging.name,
    ],
});

import pulumi
import pulumi_platform as platform

# First, create the lifecycle stages
dev = platform.LifecycleStage("dev",
    name="dev",
    category="promote")
qa = platform.LifecycleStage("qa",
    name="qa",
    category="promote")
# Global lifecycle
# Note: PROD, PR, and COMMIT are system-managed stages and should not be included in promote_stages
global_ = platform.Lifecycle("global", promote_stages=[
    dev.name,
    qa.name,
])
# Project-level lifecycle
# Note: Project-scoped stages must be prefixed with project_key
project_dev = platform.LifecycleStage("project_dev",
    name="my-project-dev",
    project_key="my-project",
    category="promote")
project_staging = platform.LifecycleStage("project_staging",
    name="my-project-staging",
    project_key="my-project",
    category="promote")
project = platform.Lifecycle("project",
    project_key="my-project",
    promote_stages=[
        project_dev.name,
        project_staging.name,
    ])

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/platform/v2/platform"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// First, create the lifecycle stages
		dev, err := platform.NewLifecycleStage(ctx, "dev", &platform.LifecycleStageArgs{
			Name:     pulumi.String("dev"),
			Category: pulumi.String("promote"),
		})
		if err != nil {
			return err
		}
		qa, err := platform.NewLifecycleStage(ctx, "qa", &platform.LifecycleStageArgs{
			Name:     pulumi.String("qa"),
			Category: pulumi.String("promote"),
		})
		if err != nil {
			return err
		}
		// Global lifecycle
		// Note: PROD, PR, and COMMIT are system-managed stages and should not be included in promote_stages
		_, err = platform.NewLifecycle(ctx, "global", &platform.LifecycleArgs{
			PromoteStages: pulumi.StringArray{
				dev.Name,
				qa.Name,
			},
		})
		if err != nil {
			return err
		}
		// Project-level lifecycle
		// Note: Project-scoped stages must be prefixed with project_key
		projectDev, err := platform.NewLifecycleStage(ctx, "project_dev", &platform.LifecycleStageArgs{
			Name:       pulumi.String("my-project-dev"),
			ProjectKey: pulumi.String("my-project"),
			Category:   pulumi.String("promote"),
		})
		if err != nil {
			return err
		}
		projectStaging, err := platform.NewLifecycleStage(ctx, "project_staging", &platform.LifecycleStageArgs{
			Name:       pulumi.String("my-project-staging"),
			ProjectKey: pulumi.String("my-project"),
			Category:   pulumi.String("promote"),
		})
		if err != nil {
			return err
		}
		_, err = platform.NewLifecycle(ctx, "project", &platform.LifecycleArgs{
			ProjectKey: pulumi.String("my-project"),
			PromoteStages: pulumi.StringArray{
				projectDev.Name,
				projectStaging.Name,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Platform = Pulumi.Platform;

return await Deployment.RunAsync(() => 
{
    // First, create the lifecycle stages
    var dev = new Platform.LifecycleStage("dev", new()
    {
        Name = "dev",
        Category = "promote",
    });

    var qa = new Platform.LifecycleStage("qa", new()
    {
        Name = "qa",
        Category = "promote",
    });

    // Global lifecycle
    // Note: PROD, PR, and COMMIT are system-managed stages and should not be included in promote_stages
    var @global = new Platform.Lifecycle("global", new()
    {
        PromoteStages = new[]
        {
            dev.Name,
            qa.Name,
        },
    });

    // Project-level lifecycle
    // Note: Project-scoped stages must be prefixed with project_key
    var projectDev = new Platform.LifecycleStage("project_dev", new()
    {
        Name = "my-project-dev",
        ProjectKey = "my-project",
        Category = "promote",
    });

    var projectStaging = new Platform.LifecycleStage("project_staging", new()
    {
        Name = "my-project-staging",
        ProjectKey = "my-project",
        Category = "promote",
    });

    var project = new Platform.Lifecycle("project", new()
    {
        ProjectKey = "my-project",
        PromoteStages = new[]
        {
            projectDev.Name,
            projectStaging.Name,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.platform.LifecycleStage;
import com.pulumi.platform.LifecycleStageArgs;
import com.pulumi.platform.Lifecycle;
import com.pulumi.platform.LifecycleArgs;
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) {
        // First, create the lifecycle stages
        var dev = new LifecycleStage("dev", LifecycleStageArgs.builder()
            .name("dev")
            .category("promote")
            .build());

        var qa = new LifecycleStage("qa", LifecycleStageArgs.builder()
            .name("qa")
            .category("promote")
            .build());

        // Global lifecycle
        // Note: PROD, PR, and COMMIT are system-managed stages and should not be included in promote_stages
        var global = new Lifecycle("global", LifecycleArgs.builder()
            .promoteStages(            
                dev.name(),
                qa.name())
            .build());

        // Project-level lifecycle
        // Note: Project-scoped stages must be prefixed with project_key
        var projectDev = new LifecycleStage("projectDev", LifecycleStageArgs.builder()
            .name("my-project-dev")
            .projectKey("my-project")
            .category("promote")
            .build());

        var projectStaging = new LifecycleStage("projectStaging", LifecycleStageArgs.builder()
            .name("my-project-staging")
            .projectKey("my-project")
            .category("promote")
            .build());

        var project = new Lifecycle("project", LifecycleArgs.builder()
            .projectKey("my-project")
            .promoteStages(            
                projectDev.name(),
                projectStaging.name())
            .build());

    }
}

resources:
  # First, create the lifecycle stages
  dev:
    type: platform:LifecycleStage
    properties:
      name: dev
      category: promote
  qa:
    type: platform:LifecycleStage
    properties:
      name: qa
      category: promote
  # Global lifecycle
  # Note: PROD, PR, and COMMIT are system-managed stages and should not be included in promote_stages
  global:
    type: platform:Lifecycle
    properties:
      promoteStages:
        - ${dev.name}
        - ${qa.name}
  # Project-level lifecycle
  # Note: Project-scoped stages must be prefixed with project_key
  projectDev:
    type: platform:LifecycleStage
    name: project_dev
    properties:
      name: my-project-dev
      projectKey: my-project
      category: promote
  projectStaging:
    type: platform:LifecycleStage
    name: project_staging
    properties:
      name: my-project-staging
      projectKey: my-project
      category: promote
  project:
    type: platform:Lifecycle
    properties:
      projectKey: my-project
      promoteStages:
        - ${projectDev.name}
        - ${projectStaging.name}

var lifecycleResource = new Platform.Lifecycle("lifecycleResource", new()
{
    PromoteStages = new[]
    {
        "string",
    },
    ProjectKey = "string",
});

example, err := platform.NewLifecycle(ctx, "lifecycleResource", &platform.LifecycleArgs{
	PromoteStages: pulumi.StringArray{
		pulumi.String("string"),
	},
	ProjectKey: pulumi.String("string"),
})

var lifecycleResource = new Lifecycle("lifecycleResource", LifecycleArgs.builder()
    .promoteStages("string")
    .projectKey("string")
    .build());

lifecycle_resource = platform.Lifecycle("lifecycleResource",
    promote_stages=["string"],
    project_key="string")

const lifecycleResource = new platform.Lifecycle("lifecycleResource", {
    promoteStages: ["string"],
    projectKey: "string",
});

type: platform:Lifecycle
properties:
    projectKey: string
    promoteStages:
        - string