pulumi-alicloud-kotlin/com.pulumi.alicloud.ros.kotlin/StackInstance

StackInstance

class StackInstance : KotlinCustomResource

Provides a ROS Stack Instance resource. For information about ROS Stack Instance and how to use it, see What is Stack Instance.

NOTE: Available in v1.145.0+.

Example Usage

Basic Usage

import * as pulumi from "@pulumi/pulumi";
import * as alicloud from "@pulumi/alicloud";
const config = new pulumi.Config();
const name = config.get("name") || "tf-example";
const this = alicloud.getAccount({});
const default = alicloud.ros.getRegions({});
const defaultStackGroup = new alicloud.ros.StackGroup("default", {
    stackGroupName: name,
    templateBody: "{\"ROSTemplateFormatVersion\":\"2015-09-01\", \"Parameters\": {\"VpcName\": {\"Type\": \"String\"},\"InstanceType\": {\"Type\": \"String\"}}}",
    description: "test for stack groups",
    parameters: [
        {
            parameterKey: "VpcName",
            parameterValue: "VpcName",
        },
        {
            parameterKey: "InstanceType",
            parameterValue: "InstanceType",
        },
    ],
});
const example = new alicloud.ros.StackInstance("example", {
    stackGroupName: defaultStackGroup.stackGroupName,
    stackInstanceAccountId: _this.then(_this => _this.id),
    stackInstanceRegionId: _default.then(_default => _default.regions?.[0]?.regionId),
    operationPreferences: "{\"FailureToleranceCount\": 1, \"MaxConcurrentCount\": 2}",
    timeoutInMinutes: "60",
    operationDescription: "tf-example",
    retainStacks: true,
    parameterOverrides: [{
        parameterValue: "VpcName",
        parameterKey: "VpcName",
    }],
});
Content copied to clipboard
import pulumi
import pulumi_alicloud as alicloud
config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "tf-example"
this = alicloud.get_account()
default = alicloud.ros.get_regions()
default_stack_group = alicloud.ros.StackGroup("default",
    stack_group_name=name,
    template_body="{\"ROSTemplateFormatVersion\":\"2015-09-01\", \"Parameters\": {\"VpcName\": {\"Type\": \"String\"},\"InstanceType\": {\"Type\": \"String\"}}}",
    description="test for stack groups",
    parameters=[
        alicloud.ros.StackGroupParameterArgs(
            parameter_key="VpcName",
            parameter_value="VpcName",
        ),
        alicloud.ros.StackGroupParameterArgs(
            parameter_key="InstanceType",
            parameter_value="InstanceType",
        ),
    ])
example = alicloud.ros.StackInstance("example",
    stack_group_name=default_stack_group.stack_group_name,
    stack_instance_account_id=this.id,
    stack_instance_region_id=default.regions[0].region_id,
    operation_preferences="{\"FailureToleranceCount\": 1, \"MaxConcurrentCount\": 2}",
    timeout_in_minutes="60",
    operation_description="tf-example",
    retain_stacks=True,
    parameter_overrides=[alicloud.ros.StackInstanceParameterOverrideArgs(
        parameter_value="VpcName",
        parameter_key="VpcName",
    )])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AliCloud = Pulumi.AliCloud;
return await Deployment.RunAsync(() =>
{
    var config = new Config();
    var name = config.Get("name") ?? "tf-example";
    var @this = AliCloud.GetAccount.Invoke();
    var @default = AliCloud.Ros.GetRegions.Invoke();
    var defaultStackGroup = new AliCloud.Ros.StackGroup("default", new()
    {
        StackGroupName = name,
        TemplateBody = "{\"ROSTemplateFormatVersion\":\"2015-09-01\", \"Parameters\": {\"VpcName\": {\"Type\": \"String\"},\"InstanceType\": {\"Type\": \"String\"}}}",
        Description = "test for stack groups",
        Parameters = new[]
        {
            new AliCloud.Ros.Inputs.StackGroupParameterArgs
            {
                ParameterKey = "VpcName",
                ParameterValue = "VpcName",
            },
            new AliCloud.Ros.Inputs.StackGroupParameterArgs
            {
                ParameterKey = "InstanceType",
                ParameterValue = "InstanceType",
            },
        },
    });
    var example = new AliCloud.Ros.StackInstance("example", new()
    {
        StackGroupName = defaultStackGroup.StackGroupName,
        StackInstanceAccountId = @this.Apply(@this => @this.Apply(getAccountResult => getAccountResult.Id)),
        StackInstanceRegionId = @default.Apply(@default => @default.Apply(getRegionsResult => getRegionsResult.Regions[0]?.RegionId)),
        OperationPreferences = "{\"FailureToleranceCount\": 1, \"MaxConcurrentCount\": 2}",
        TimeoutInMinutes = "60",
        OperationDescription = "tf-example",
        RetainStacks = true,
        ParameterOverrides = new[]
        {
            new AliCloud.Ros.Inputs.StackInstanceParameterOverrideArgs
            {
                ParameterValue = "VpcName",
                ParameterKey = "VpcName",
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ros"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		name := "tf-example"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		this, err := alicloud.GetAccount(ctx, nil, nil)
		if err != nil {
			return err
		}
		_default, err := ros.GetRegions(ctx, nil, nil)
		if err != nil {
			return err
		}
		defaultStackGroup, err := ros.NewStackGroup(ctx, "default", &ros.StackGroupArgs{
			StackGroupName: pulumi.String(name),
			TemplateBody:   pulumi.String("{\"ROSTemplateFormatVersion\":\"2015-09-01\", \"Parameters\": {\"VpcName\": {\"Type\": \"String\"},\"InstanceType\": {\"Type\": \"String\"}}}"),
			Description:    pulumi.String("test for stack groups"),
			Parameters: ros.StackGroupParameterArray{
				&ros.StackGroupParameterArgs{
					ParameterKey:   pulumi.String("VpcName"),
					ParameterValue: pulumi.String("VpcName"),
				},
				&ros.StackGroupParameterArgs{
					ParameterKey:   pulumi.String("InstanceType"),
					ParameterValue: pulumi.String("InstanceType"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = ros.NewStackInstance(ctx, "example", &ros.StackInstanceArgs{
			StackGroupName:         defaultStackGroup.StackGroupName,
			StackInstanceAccountId: pulumi.String(this.Id),
			StackInstanceRegionId:  pulumi.String(_default.Regions[0].RegionId),
			OperationPreferences:   pulumi.String("{\"FailureToleranceCount\": 1, \"MaxConcurrentCount\": 2}"),
			TimeoutInMinutes:       pulumi.String("60"),
			OperationDescription:   pulumi.String("tf-example"),
			RetainStacks:           pulumi.Bool(true),
			ParameterOverrides: ros.StackInstanceParameterOverrideArray{
				&ros.StackInstanceParameterOverrideArgs{
					ParameterValue: pulumi.String("VpcName"),
					ParameterKey:   pulumi.String("VpcName"),
				},
			},
		})
		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.alicloud.AlicloudFunctions;
import com.pulumi.alicloud.ros.RosFunctions;
import com.pulumi.alicloud.ros.inputs.GetRegionsArgs;
import com.pulumi.alicloud.ros.StackGroup;
import com.pulumi.alicloud.ros.StackGroupArgs;
import com.pulumi.alicloud.ros.inputs.StackGroupParameterArgs;
import com.pulumi.alicloud.ros.StackInstance;
import com.pulumi.alicloud.ros.StackInstanceArgs;
import com.pulumi.alicloud.ros.inputs.StackInstanceParameterOverrideArgs;
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) {
        final var config = ctx.config();
        final var name = config.get("name").orElse("tf-example");
        final var this = AlicloudFunctions.getAccount();
        final var default = RosFunctions.getRegions();
        var defaultStackGroup = new StackGroup("defaultStackGroup", StackGroupArgs.builder()
            .stackGroupName(name)
            .templateBody("{\"ROSTemplateFormatVersion\":\"2015-09-01\", \"Parameters\": {\"VpcName\": {\"Type\": \"String\"},\"InstanceType\": {\"Type\": \"String\"}}}")
            .description("test for stack groups")
            .parameters(
                StackGroupParameterArgs.builder()
                    .parameterKey("VpcName")
                    .parameterValue("VpcName")
                    .build(),
                StackGroupParameterArgs.builder()
                    .parameterKey("InstanceType")
                    .parameterValue("InstanceType")
                    .build())
            .build());
        var example = new StackInstance("example", StackInstanceArgs.builder()
            .stackGroupName(defaultStackGroup.stackGroupName())
            .stackInstanceAccountId(this_.id())
            .stackInstanceRegionId(default_.regions()[0].regionId())
            .operationPreferences("{\"FailureToleranceCount\": 1, \"MaxConcurrentCount\": 2}")
            .timeoutInMinutes("60")
            .operationDescription("tf-example")
            .retainStacks("true")
            .parameterOverrides(StackInstanceParameterOverrideArgs.builder()
                .parameterValue("VpcName")
                .parameterKey("VpcName")
                .build())
            .build());
    }
}
Content copied to clipboard
configuration:
  name:
    type: string
    default: tf-example
resources:
  defaultStackGroup:
    type: alicloud:ros:StackGroup
    name: default
    properties:
      stackGroupName: ${name}
      templateBody: '{"ROSTemplateFormatVersion":"2015-09-01", "Parameters": {"VpcName": {"Type": "String"},"InstanceType": {"Type": "String"}}}'
      description: test for stack groups
      parameters:
        - parameterKey: VpcName
          parameterValue: VpcName
        - parameterKey: InstanceType
          parameterValue: InstanceType
  example:
    type: alicloud:ros:StackInstance
    properties:
      stackGroupName: ${defaultStackGroup.stackGroupName}
      stackInstanceAccountId: ${this.id}
      stackInstanceRegionId: ${default.regions[0].regionId}
      operationPreferences: '{"FailureToleranceCount": 1, "MaxConcurrentCount": 2}'
      timeoutInMinutes: '60'
      operationDescription: tf-example
      retainStacks: 'true'
      parameterOverrides:
        - parameterValue: VpcName
          parameterKey: VpcName
variables:
  this:
    fn::invoke:
      Function: alicloud:getAccount
      Arguments: {}
  default:
    fn::invoke:
      Function: alicloud:ros:getRegions
      Arguments: {}
Content copied to clipboard

Import

ROS Stack Instance can be imported using the id, e.g.

$ pulumi import alicloud:ros/stackInstance:StackInstance example <stack_group_name>:<stack_instance_account_id>:<stack_instance_region_id>
Content copied to clipboard

Properties

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val operationDescription: Output<String>?

The operation description.

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

The operation preferences. The operation settings. The following fields are supported:

Link copied to clipboard
val parameterOverrides: Output<List<StackInstanceParameterOverride>>?

ParameterOverrides. See the following Block parameter_overrides.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val retainStacks: Output<Boolean>?

Specifies whether to retain the stack corresponding to the stack instance.Default value false. NOTE: When retain_stacks is true, the stack is retained. If the stack is retained, the corresponding stack is not deleted when the stack instance is deleted from the stack group.

Link copied to clipboard
val stackGroupName: Output<String>

The name of the stack group.

Link copied to clipboard
val stackInstanceAccountId: Output<String>

The account to which the stack instance belongs.

Link copied to clipboard
val stackInstanceRegionId: Output<String>

The region of the stack instance.

Link copied to clipboard
val status: Output<String>

The status of the stack instance. Valid values: CURRENT or OUTDATED.

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

The timeout period that is specified for the stack creation request. Default value: 60. Unit: minutes.

Link copied to clipboard
val urn: Output<String>