com.pulumi.aws.cloudformation.kotlin.StackSet.kt Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of pulumi-aws-kotlin Show documentation
Show all versions of pulumi-aws-kotlin Show documentation
Build cloud applications and infrastructure by combining the safety and reliability of infrastructure as code with the power of the Kotlin programming language.
@file:Suppress("NAME_SHADOWING", "DEPRECATION")
package com.pulumi.aws.cloudformation.kotlin
import com.pulumi.aws.cloudformation.kotlin.outputs.StackSetAutoDeployment
import com.pulumi.aws.cloudformation.kotlin.outputs.StackSetManagedExecution
import com.pulumi.aws.cloudformation.kotlin.outputs.StackSetOperationPreferences
import com.pulumi.core.Output
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.Deprecated
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.Map
import com.pulumi.aws.cloudformation.kotlin.outputs.StackSetAutoDeployment.Companion.toKotlin as stackSetAutoDeploymentToKotlin
import com.pulumi.aws.cloudformation.kotlin.outputs.StackSetManagedExecution.Companion.toKotlin as stackSetManagedExecutionToKotlin
import com.pulumi.aws.cloudformation.kotlin.outputs.StackSetOperationPreferences.Companion.toKotlin as stackSetOperationPreferencesToKotlin
/**
* Builder for [StackSet].
*/
@PulumiTagMarker
public class StackSetResourceBuilder internal constructor() {
public var name: String? = null
public var args: StackSetArgs = StackSetArgs()
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 StackSetArgsBuilder.() -> Unit) {
val builder = StackSetArgsBuilder()
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(): StackSet {
val builtJavaResource = com.pulumi.aws.cloudformation.StackSet(
this.name,
this.args.toJava(),
this.opts.toJava(),
)
return StackSet(builtJavaResource)
}
}
/**
* Manages a CloudFormation StackSet. StackSets allow CloudFormation templates to be easily deployed across multiple accounts and regions via StackSet Instances (`aws.cloudformation.StackSetInstance` resource). Additional information about StackSets can be found in the [AWS CloudFormation User Guide](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/what-is-cfnstacksets.html).
* > **NOTE:** All template parameters, including those with a `Default`, must be configured or ignored with the `lifecycle` configuration block `ignore_changes` argument.
* > **NOTE:** All `NoEcho` template parameters must be ignored with the `lifecycle` configuration block `ignore_changes` argument.
* > **NOTE:** When using a delegated administrator account, ensure that your IAM User or Role has the `organizations:ListDelegatedAdministrators` permission. Otherwise, you may get an error like `ValidationError: Account used is not a delegated administrator`.
* ## Example Usage
*
* ```typescript
* import * as pulumi from "@pulumi/pulumi";
* import * as aws from "@pulumi/aws";
* const aWSCloudFormationStackSetAdministrationRoleAssumeRolePolicy = aws.iam.getPolicyDocument({
* statements: [{
* actions: ["sts:AssumeRole"],
* effect: "Allow",
* principals: [{
* identifiers: ["cloudformation.amazonaws.com"],
* type: "Service",
* }],
* }],
* });
* const aWSCloudFormationStackSetAdministrationRole = new aws.iam.Role("AWSCloudFormationStackSetAdministrationRole", {
* assumeRolePolicy: aWSCloudFormationStackSetAdministrationRoleAssumeRolePolicy.then(aWSCloudFormationStackSetAdministrationRoleAssumeRolePolicy => aWSCloudFormationStackSetAdministrationRoleAssumeRolePolicy.json),
* name: "AWSCloudFormationStackSetAdministrationRole",
* });
* const example = new aws.cloudformation.StackSet("example", {
* administrationRoleArn: aWSCloudFormationStackSetAdministrationRole.arn,
* name: "example",
* parameters: {
* VPCCidr: "10.0.0.0/16",
* },
* templateBody: JSON.stringify({
* Parameters: {
* VPCCidr: {
* Type: "String",
* Default: "10.0.0.0/16",
* Description: "Enter the CIDR block for the VPC. Default is 10.0.0.0/16.",
* },
* },
* Resources: {
* myVpc: {
* Type: "AWS::EC2::VPC",
* Properties: {
* CidrBlock: {
* Ref: "VPCCidr",
* },
* Tags: [{
* Key: "Name",
* Value: "Primary_CF_VPC",
* }],
* },
* },
* },
* }),
* });
* const aWSCloudFormationStackSetAdministrationRoleExecutionPolicy = aws.iam.getPolicyDocumentOutput({
* statements: [{
* actions: ["sts:AssumeRole"],
* effect: "Allow",
* resources: [pulumi.interpolate`arn:aws:iam::*:role/${example.executionRoleName}`],
* }],
* });
* const aWSCloudFormationStackSetAdministrationRoleExecutionPolicyRolePolicy = new aws.iam.RolePolicy("AWSCloudFormationStackSetAdministrationRole_ExecutionPolicy", {
* name: "ExecutionPolicy",
* policy: aWSCloudFormationStackSetAdministrationRoleExecutionPolicy.apply(aWSCloudFormationStackSetAdministrationRoleExecutionPolicy => aWSCloudFormationStackSetAdministrationRoleExecutionPolicy.json),
* role: aWSCloudFormationStackSetAdministrationRole.name,
* });
* ```
* ```python
* import pulumi
* import json
* import pulumi_aws as aws
* a_ws_cloud_formation_stack_set_administration_role_assume_role_policy = aws.iam.get_policy_document(statements=[{
* "actions": ["sts:AssumeRole"],
* "effect": "Allow",
* "principals": [{
* "identifiers": ["cloudformation.amazonaws.com"],
* "type": "Service",
* }],
* }])
* a_ws_cloud_formation_stack_set_administration_role = aws.iam.Role("AWSCloudFormationStackSetAdministrationRole",
* assume_role_policy=a_ws_cloud_formation_stack_set_administration_role_assume_role_policy.json,
* name="AWSCloudFormationStackSetAdministrationRole")
* example = aws.cloudformation.StackSet("example",
* administration_role_arn=a_ws_cloud_formation_stack_set_administration_role.arn,
* name="example",
* parameters={
* "VPCCidr": "10.0.0.0/16",
* },
* template_body=json.dumps({
* "Parameters": {
* "VPCCidr": {
* "Type": "String",
* "Default": "10.0.0.0/16",
* "Description": "Enter the CIDR block for the VPC. Default is 10.0.0.0/16.",
* },
* },
* "Resources": {
* "myVpc": {
* "Type": "AWS::EC2::VPC",
* "Properties": {
* "CidrBlock": {
* "Ref": "VPCCidr",
* },
* "Tags": [{
* "Key": "Name",
* "Value": "Primary_CF_VPC",
* }],
* },
* },
* },
* }))
* a_ws_cloud_formation_stack_set_administration_role_execution_policy = aws.iam.get_policy_document_output(statements=[{
* "actions": ["sts:AssumeRole"],
* "effect": "Allow",
* "resources": [example.execution_role_name.apply(lambda execution_role_name: f"arn:aws:iam::*:role/{execution_role_name}")],
* }])
* a_ws_cloud_formation_stack_set_administration_role_execution_policy_role_policy = aws.iam.RolePolicy("AWSCloudFormationStackSetAdministrationRole_ExecutionPolicy",
* name="ExecutionPolicy",
* policy=a_ws_cloud_formation_stack_set_administration_role_execution_policy.json,
* role=a_ws_cloud_formation_stack_set_administration_role.name)
* ```
* ```csharp
* using System.Collections.Generic;
* using System.Linq;
* using System.Text.Json;
* using Pulumi;
* using Aws = Pulumi.Aws;
* return await Deployment.RunAsync(() =>
* {
* var aWSCloudFormationStackSetAdministrationRoleAssumeRolePolicy = Aws.Iam.GetPolicyDocument.Invoke(new()
* {
* Statements = new[]
* {
* new Aws.Iam.Inputs.GetPolicyDocumentStatementInputArgs
* {
* Actions = new[]
* {
* "sts:AssumeRole",
* },
* Effect = "Allow",
* Principals = new[]
* {
* new Aws.Iam.Inputs.GetPolicyDocumentStatementPrincipalInputArgs
* {
* Identifiers = new[]
* {
* "cloudformation.amazonaws.com",
* },
* Type = "Service",
* },
* },
* },
* },
* });
* var aWSCloudFormationStackSetAdministrationRole = new Aws.Iam.Role("AWSCloudFormationStackSetAdministrationRole", new()
* {
* AssumeRolePolicy = aWSCloudFormationStackSetAdministrationRoleAssumeRolePolicy.Apply(getPolicyDocumentResult => getPolicyDocumentResult.Json),
* Name = "AWSCloudFormationStackSetAdministrationRole",
* });
* var example = new Aws.CloudFormation.StackSet("example", new()
* {
* AdministrationRoleArn = aWSCloudFormationStackSetAdministrationRole.Arn,
* Name = "example",
* Parameters =
* {
* { "VPCCidr", "10.0.0.0/16" },
* },
* TemplateBody = JsonSerializer.Serialize(new Dictionary
* {
* ["Parameters"] = new Dictionary
* {
* ["VPCCidr"] = new Dictionary
* {
* ["Type"] = "String",
* ["Default"] = "10.0.0.0/16",
* ["Description"] = "Enter the CIDR block for the VPC. Default is 10.0.0.0/16.",
* },
* },
* ["Resources"] = new Dictionary
* {
* ["myVpc"] = new Dictionary
* {
* ["Type"] = "AWS::EC2::VPC",
* ["Properties"] = new Dictionary
* {
* ["CidrBlock"] = new Dictionary
* {
* ["Ref"] = "VPCCidr",
* },
* ["Tags"] = new[]
* {
* new Dictionary
* {
* ["Key"] = "Name",
* ["Value"] = "Primary_CF_VPC",
* },
* },
* },
* },
* },
* }),
* });
* var aWSCloudFormationStackSetAdministrationRoleExecutionPolicy = Aws.Iam.GetPolicyDocument.Invoke(new()
* {
* Statements = new[]
* {
* new Aws.Iam.Inputs.GetPolicyDocumentStatementInputArgs
* {
* Actions = new[]
* {
* "sts:AssumeRole",
* },
* Effect = "Allow",
* Resources = new[]
* {
* $"arn:aws:iam::*:role/{example.ExecutionRoleName}",
* },
* },
* },
* });
* var aWSCloudFormationStackSetAdministrationRoleExecutionPolicyRolePolicy = new Aws.Iam.RolePolicy("AWSCloudFormationStackSetAdministrationRole_ExecutionPolicy", new()
* {
* Name = "ExecutionPolicy",
* Policy = aWSCloudFormationStackSetAdministrationRoleExecutionPolicy.Apply(getPolicyDocumentResult => getPolicyDocumentResult.Json),
* Role = aWSCloudFormationStackSetAdministrationRole.Name,
* });
* });
* ```
* ```go
* package main
* import (
* "encoding/json"
* "fmt"
* "github.com/pulumi/pulumi-aws/sdk/v6/go/aws/cloudformation"
* "github.com/pulumi/pulumi-aws/sdk/v6/go/aws/iam"
* "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
* )
* func main() {
* pulumi.Run(func(ctx *pulumi.Context) error {
* aWSCloudFormationStackSetAdministrationRoleAssumeRolePolicy, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
* Statements: []iam.GetPolicyDocumentStatement{
* {
* Actions: []string{
* "sts:AssumeRole",
* },
* Effect: pulumi.StringRef("Allow"),
* Principals: []iam.GetPolicyDocumentStatementPrincipal{
* {
* Identifiers: []string{
* "cloudformation.amazonaws.com",
* },
* Type: "Service",
* },
* },
* },
* },
* }, nil)
* if err != nil {
* return err
* }
* aWSCloudFormationStackSetAdministrationRole, err := iam.NewRole(ctx, "AWSCloudFormationStackSetAdministrationRole", &iam.RoleArgs{
* AssumeRolePolicy: pulumi.String(aWSCloudFormationStackSetAdministrationRoleAssumeRolePolicy.Json),
* Name: pulumi.String("AWSCloudFormationStackSetAdministrationRole"),
* })
* if err != nil {
* return err
* }
* tmpJSON0, err := json.Marshal(map[string]interface{}{
* "Parameters": map[string]interface{}{
* "VPCCidr": map[string]interface{}{
* "Type": "String",
* "Default": "10.0.0.0/16",
* "Description": "Enter the CIDR block for the VPC. Default is 10.0.0.0/16.",
* },
* },
* "Resources": map[string]interface{}{
* "myVpc": map[string]interface{}{
* "Type": "AWS::EC2::VPC",
* "Properties": map[string]interface{}{
* "CidrBlock": map[string]interface{}{
* "Ref": "VPCCidr",
* },
* "Tags": []map[string]interface{}{
* map[string]interface{}{
* "Key": "Name",
* "Value": "Primary_CF_VPC",
* },
* },
* },
* },
* },
* })
* if err != nil {
* return err
* }
* json0 := string(tmpJSON0)
* example, err := cloudformation.NewStackSet(ctx, "example", &cloudformation.StackSetArgs{
* AdministrationRoleArn: aWSCloudFormationStackSetAdministrationRole.Arn,
* Name: pulumi.String("example"),
* Parameters: pulumi.StringMap{
* "VPCCidr": pulumi.String("10.0.0.0/16"),
* },
* TemplateBody: pulumi.String(json0),
* })
* if err != nil {
* return err
* }
* aWSCloudFormationStackSetAdministrationRoleExecutionPolicy := iam.GetPolicyDocumentOutput(ctx, iam.GetPolicyDocumentOutputArgs{
* Statements: iam.GetPolicyDocumentStatementArray{
* &iam.GetPolicyDocumentStatementArgs{
* Actions: pulumi.StringArray{
* pulumi.String("sts:AssumeRole"),
* },
* Effect: pulumi.String("Allow"),
* Resources: pulumi.StringArray{
* example.ExecutionRoleName.ApplyT(func(executionRoleName string) (string, error) {
* return fmt.Sprintf("arn:aws:iam::*:role/%v", executionRoleName), nil
* }).(pulumi.StringOutput),
* },
* },
* },
* }, nil)
* _, err = iam.NewRolePolicy(ctx, "AWSCloudFormationStackSetAdministrationRole_ExecutionPolicy", &iam.RolePolicyArgs{
* Name: pulumi.String("ExecutionPolicy"),
* Policy: pulumi.String(aWSCloudFormationStackSetAdministrationRoleExecutionPolicy.ApplyT(func(aWSCloudFormationStackSetAdministrationRoleExecutionPolicy iam.GetPolicyDocumentResult) (*string, error) {
* return &aWSCloudFormationStackSetAdministrationRoleExecutionPolicy.Json, nil
* }).(pulumi.StringPtrOutput)),
* Role: aWSCloudFormationStackSetAdministrationRole.Name,
* })
* 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.aws.iam.IamFunctions;
* import com.pulumi.aws.iam.inputs.GetPolicyDocumentArgs;
* import com.pulumi.aws.iam.Role;
* import com.pulumi.aws.iam.RoleArgs;
* import com.pulumi.aws.cloudformation.StackSet;
* import com.pulumi.aws.cloudformation.StackSetArgs;
* import com.pulumi.aws.iam.RolePolicy;
* import com.pulumi.aws.iam.RolePolicyArgs;
* import static com.pulumi.codegen.internal.Serialization.*;
* 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 aWSCloudFormationStackSetAdministrationRoleAssumeRolePolicy = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
* .statements(GetPolicyDocumentStatementArgs.builder()
* .actions("sts:AssumeRole")
* .effect("Allow")
* .principals(GetPolicyDocumentStatementPrincipalArgs.builder()
* .identifiers("cloudformation.amazonaws.com")
* .type("Service")
* .build())
* .build())
* .build());
* var aWSCloudFormationStackSetAdministrationRole = new Role("aWSCloudFormationStackSetAdministrationRole", RoleArgs.builder()
* .assumeRolePolicy(aWSCloudFormationStackSetAdministrationRoleAssumeRolePolicy.applyValue(getPolicyDocumentResult -> getPolicyDocumentResult.json()))
* .name("AWSCloudFormationStackSetAdministrationRole")
* .build());
* var example = new StackSet("example", StackSetArgs.builder()
* .administrationRoleArn(aWSCloudFormationStackSetAdministrationRole.arn())
* .name("example")
* .parameters(Map.of("VPCCidr", "10.0.0.0/16"))
* .templateBody(serializeJson(
* jsonObject(
* jsonProperty("Parameters", jsonObject(
* jsonProperty("VPCCidr", jsonObject(
* jsonProperty("Type", "String"),
* jsonProperty("Default", "10.0.0.0/16"),
* jsonProperty("Description", "Enter the CIDR block for the VPC. Default is 10.0.0.0/16.")
* ))
* )),
* jsonProperty("Resources", jsonObject(
* jsonProperty("myVpc", jsonObject(
* jsonProperty("Type", "AWS::EC2::VPC"),
* jsonProperty("Properties", jsonObject(
* jsonProperty("CidrBlock", jsonObject(
* jsonProperty("Ref", "VPCCidr")
* )),
* jsonProperty("Tags", jsonArray(jsonObject(
* jsonProperty("Key", "Name"),
* jsonProperty("Value", "Primary_CF_VPC")
* )))
* ))
* ))
* ))
* )))
* .build());
* final var aWSCloudFormationStackSetAdministrationRoleExecutionPolicy = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
* .statements(GetPolicyDocumentStatementArgs.builder()
* .actions("sts:AssumeRole")
* .effect("Allow")
* .resources(example.executionRoleName().applyValue(executionRoleName -> String.format("arn:aws:iam::*:role/%s", executionRoleName)))
* .build())
* .build());
* var aWSCloudFormationStackSetAdministrationRoleExecutionPolicyRolePolicy = new RolePolicy("aWSCloudFormationStackSetAdministrationRoleExecutionPolicyRolePolicy", RolePolicyArgs.builder()
* .name("ExecutionPolicy")
* .policy(aWSCloudFormationStackSetAdministrationRoleExecutionPolicy.applyValue(getPolicyDocumentResult -> getPolicyDocumentResult).applyValue(aWSCloudFormationStackSetAdministrationRoleExecutionPolicy -> aWSCloudFormationStackSetAdministrationRoleExecutionPolicy.applyValue(getPolicyDocumentResult -> getPolicyDocumentResult.json())))
* .role(aWSCloudFormationStackSetAdministrationRole.name())
* .build());
* }
* }
* ```
* ```yaml
* resources:
* aWSCloudFormationStackSetAdministrationRole:
* type: aws:iam:Role
* name: AWSCloudFormationStackSetAdministrationRole
* properties:
* assumeRolePolicy: ${aWSCloudFormationStackSetAdministrationRoleAssumeRolePolicy.json}
* name: AWSCloudFormationStackSetAdministrationRole
* example:
* type: aws:cloudformation:StackSet
* properties:
* administrationRoleArn: ${aWSCloudFormationStackSetAdministrationRole.arn}
* name: example
* parameters:
* VPCCidr: 10.0.0.0/16
* templateBody:
* fn::toJSON:
* Parameters:
* VPCCidr:
* Type: String
* Default: 10.0.0.0/16
* Description: Enter the CIDR block for the VPC. Default is 10.0.0.0/16.
* Resources:
* myVpc:
* Type: AWS::EC2::VPC
* Properties:
* CidrBlock:
* Ref: VPCCidr
* Tags:
* - Key: Name
* Value: Primary_CF_VPC
* aWSCloudFormationStackSetAdministrationRoleExecutionPolicyRolePolicy:
* type: aws:iam:RolePolicy
* name: AWSCloudFormationStackSetAdministrationRole_ExecutionPolicy
* properties:
* name: ExecutionPolicy
* policy: ${aWSCloudFormationStackSetAdministrationRoleExecutionPolicy.json}
* role: ${aWSCloudFormationStackSetAdministrationRole.name}
* variables:
* aWSCloudFormationStackSetAdministrationRoleAssumeRolePolicy:
* fn::invoke:
* Function: aws:iam:getPolicyDocument
* Arguments:
* statements:
* - actions:
* - sts:AssumeRole
* effect: Allow
* principals:
* - identifiers:
* - cloudformation.amazonaws.com
* type: Service
* aWSCloudFormationStackSetAdministrationRoleExecutionPolicy:
* fn::invoke:
* Function: aws:iam:getPolicyDocument
* Arguments:
* statements:
* - actions:
* - sts:AssumeRole
* effect: Allow
* resources:
* - arn:aws:iam::*:role/${example.executionRoleName}
* ```
*
* ## Import
* Import CloudFormation StackSets when acting a delegated administrator in a member account using the `name` and `call_as` values separated by a comma (`,`). For example:
* Using `pulumi import`, import CloudFormation StackSets using the `name`. For example:
* ```sh
* $ pulumi import aws:cloudformation/stackSet:StackSet example example
* ```
* Using `pulumi import`, import CloudFormation StackSets when acting a delegated administrator in a member account using the `name` and `call_as` values separated by a comma (`,`). For example:
* ```sh
* $ pulumi import aws:cloudformation/stackSet:StackSet example example,DELEGATED_ADMIN
* ```
*/
public class StackSet internal constructor(
override val javaResource: com.pulumi.aws.cloudformation.StackSet,
) : KotlinCustomResource(javaResource, StackSetMapper) {
/**
* Amazon Resource Number (ARN) of the IAM Role in the administrator account. This must be defined when using the `SELF_MANAGED` permission model.
*/
public val administrationRoleArn: Output?
get() = javaResource.administrationRoleArn().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* Amazon Resource Name (ARN) of the StackSet.
*/
public val arn: Output
get() = javaResource.arn().applyValue({ args0 -> args0 })
/**
* Configuration block containing the auto-deployment model for your StackSet. This can only be defined when using the `SERVICE_MANAGED` permission model.
*/
public val autoDeployment: Output?
get() = javaResource.autoDeployment().applyValue({ args0 ->
args0.map({ args0 ->
args0.let({ args0 -> stackSetAutoDeploymentToKotlin(args0) })
}).orElse(null)
})
/**
* Specifies whether you are acting as an account administrator in the organization's management account or as a delegated administrator in a member account. Valid values: `SELF` (default), `DELEGATED_ADMIN`.
*/
public val callAs: Output?
get() = javaResource.callAs().applyValue({ args0 -> args0.map({ args0 -> args0 }).orElse(null) })
/**
* A list of capabilities. Valid values: `CAPABILITY_IAM`, `CAPABILITY_NAMED_IAM`, `CAPABILITY_AUTO_EXPAND`.
*/
public val capabilities: Output>?
get() = javaResource.capabilities().applyValue({ args0 ->
args0.map({ args0 ->
args0.map({ args0 ->
args0
})
}).orElse(null)
})
/**
* Description of the StackSet.
*/
public val description: Output?
get() = javaResource.description().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* Name of the IAM Role in all target accounts for StackSet operations. Defaults to `AWSCloudFormationStackSetExecutionRole` when using the `SELF_MANAGED` permission model. This should not be defined when using the `SERVICE_MANAGED` permission model.
*/
public val executionRoleName: Output
get() = javaResource.executionRoleName().applyValue({ args0 -> args0 })
/**
* Configuration block to allow StackSets to perform non-conflicting operations concurrently and queues conflicting operations.
*/
public val managedExecution: Output?
get() = javaResource.managedExecution().applyValue({ args0 ->
args0.map({ args0 ->
args0.let({ args0 -> stackSetManagedExecutionToKotlin(args0) })
}).orElse(null)
})
/**
* Name of the StackSet. The name must be unique in the region where you create your StackSet. The name can contain only alphanumeric characters (case-sensitive) and hyphens. It must start with an alphabetic character and cannot be longer than 128 characters.
*/
public val name: Output
get() = javaResource.name().applyValue({ args0 -> args0 })
/**
* Preferences for how AWS CloudFormation performs a stack set update.
*/
public val operationPreferences: Output?
get() = javaResource.operationPreferences().applyValue({ args0 ->
args0.map({ args0 ->
args0.let({ args0 -> stackSetOperationPreferencesToKotlin(args0) })
}).orElse(null)
})
/**
* Key-value map of input parameters for the StackSet template. All template parameters, including those with a `Default`, must be configured or ignored with `lifecycle` configuration block `ignore_changes` argument. All `NoEcho` template parameters must be ignored with the `lifecycle` configuration block `ignore_changes` argument.
*/
public val parameters: Output>?
get() = javaResource.parameters().applyValue({ args0 ->
args0.map({ args0 ->
args0.map({ args0 ->
args0.key.to(args0.value)
}).toMap()
}).orElse(null)
})
/**
* Describes how the IAM roles required for your StackSet are created. Valid values: `SELF_MANAGED` (default), `SERVICE_MANAGED`.
*/
public val permissionModel: Output?
get() = javaResource.permissionModel().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* Unique identifier of the StackSet.
*/
public val stackSetId: Output
get() = javaResource.stackSetId().applyValue({ args0 -> args0 })
/**
* Key-value map of tags to associate with this StackSet and the Stacks created from it. AWS CloudFormation also propagates these tags to supported resources that are created in the Stacks. A maximum number of 50 tags can be specified. If configured with a provider `default_tags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
*/
public val tags: Output>?
get() = javaResource.tags().applyValue({ args0 ->
args0.map({ args0 ->
args0.map({ args0 ->
args0.key.to(args0.value)
}).toMap()
}).orElse(null)
})
/**
* A map of tags assigned to the resource, including those inherited from the provider `default_tags` configuration block.
*/
@Deprecated(
message = """
Please use `tags` instead.
""",
)
public val tagsAll: Output>
get() = javaResource.tagsAll().applyValue({ args0 ->
args0.map({ args0 ->
args0.key.to(args0.value)
}).toMap()
})
/**
* String containing the CloudFormation template body. Maximum size: 51,200 bytes. Conflicts with `template_url`.
*/
public val templateBody: Output
get() = javaResource.templateBody().applyValue({ args0 -> args0 })
/**
* String containing the location of a file containing the CloudFormation template body. The URL must point to a template that is located in an Amazon S3 bucket. Maximum location file size: 460,800 bytes. Conflicts with `template_body`.
*/
public val templateUrl: Output?
get() = javaResource.templateUrl().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
}
public object StackSetMapper : ResourceMapper {
override fun supportsMappingOfType(javaResource: Resource): Boolean =
com.pulumi.aws.cloudformation.StackSet::class == javaResource::class
override fun map(javaResource: Resource): StackSet = StackSet(
javaResource as
com.pulumi.aws.cloudformation.StackSet,
)
}
/**
* @see [StackSet].
* @param name The _unique_ name of the resulting resource.
* @param block Builder for [StackSet].
*/
public suspend fun stackSet(name: String, block: suspend StackSetResourceBuilder.() -> Unit): StackSet {
val builder = StackSetResourceBuilder()
builder.name(name)
block(builder)
return builder.build()
}
/**
* @see [StackSet].
* @param name The _unique_ name of the resulting resource.
*/
public fun stackSet(name: String): StackSet {
val builder = StackSetResourceBuilder()
builder.name(name)
return builder.build()
}