pulumi-aws-kotlin/com.pulumi.aws.ssm.kotlin/ParameterArgs

ParameterArgs

data class ParameterArgs(val allowedPattern: Output<String>? = null, val arn: Output<String>? = null, val dataType: Output<String>? = null, val description: Output<String>? = null, val insecureValue: Output<String>? = null, val keyId: Output<String>? = null, val name: Output<String>? = null, val overwrite: Output<Boolean>? = null, val tags: Output<Map<String, String>>? = null, val tier: Output<String>? = null, val type: Output<Either<String, ParameterType>>? = null, val value: Output<String>? = null) : ConvertibleToJava<ParameterArgs>

Provides an SSM Parameter resource.

Note: The overwrite argument makes it possible to overwrite an existing SSM Parameter created outside of IAC.

Example Usage

Basic example

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const foo = new aws.ssm.Parameter("foo", {
    name: "foo",
    type: aws.ssm.ParameterType.String,
    value: "bar",
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
foo = aws.ssm.Parameter("foo",
    name="foo",
    type=aws.ssm.ParameterType.STRING,
    value="bar")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var foo = new Aws.Ssm.Parameter("foo", new()
    {
        Name = "foo",
        Type = Aws.Ssm.ParameterType.String,
        Value = "bar",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ssm"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ssm.NewParameter(ctx, "foo", &ssm.ParameterArgs{
			Name:  pulumi.String("foo"),
			Type:  pulumi.String(ssm.ParameterTypeString),
			Value: pulumi.String("bar"),
		})
		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.aws.ssm.Parameter;
import com.pulumi.aws.ssm.ParameterArgs;
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 foo = new Parameter("foo", ParameterArgs.builder()
            .name("foo")
            .type("String")
            .value("bar")
            .build());
    }
}
Content copied to clipboard
resources:
  foo:
    type: aws:ssm:Parameter
    properties:
      name: foo
      type: String
      value: bar
Content copied to clipboard

Encrypted string using default SSM KMS key

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const _default = new aws.rds.Instance("default", {
    allocatedStorage: 10,
    storageType: aws.rds.StorageType.GP2,
    engine: "mysql",
    engineVersion: "5.7.16",
    instanceClass: aws.rds.InstanceType.T2_Micro,
    dbName: "mydb",
    username: "foo",
    password: databaseMasterPassword,
    dbSubnetGroupName: "my_database_subnet_group",
    parameterGroupName: "default.mysql5.7",
});
const secret = new aws.ssm.Parameter("secret", {
    name: "/production/database/password/master",
    description: "The parameter description",
    type: aws.ssm.ParameterType.SecureString,
    value: databaseMasterPassword,
    tags: {
        environment: "production",
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
default = aws.rds.Instance("default",
    allocated_storage=10,
    storage_type=aws.rds.StorageType.GP2,
    engine="mysql",
    engine_version="5.7.16",
    instance_class=aws.rds.InstanceType.T2_MICRO,
    db_name="mydb",
    username="foo",
    password=database_master_password,
    db_subnet_group_name="my_database_subnet_group",
    parameter_group_name="default.mysql5.7")
secret = aws.ssm.Parameter("secret",
    name="/production/database/password/master",
    description="The parameter description",
    type=aws.ssm.ParameterType.SECURE_STRING,
    value=database_master_password,
    tags={
        "environment": "production",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var @default = new Aws.Rds.Instance("default", new()
    {
        AllocatedStorage = 10,
        StorageType = Aws.Rds.StorageType.GP2,
        Engine = "mysql",
        EngineVersion = "5.7.16",
        InstanceClass = Aws.Rds.InstanceType.T2_Micro,
        DbName = "mydb",
        Username = "foo",
        Password = databaseMasterPassword,
        DbSubnetGroupName = "my_database_subnet_group",
        ParameterGroupName = "default.mysql5.7",
    });
    var secret = new Aws.Ssm.Parameter("secret", new()
    {
        Name = "/production/database/password/master",
        Description = "The parameter description",
        Type = Aws.Ssm.ParameterType.SecureString,
        Value = databaseMasterPassword,
        Tags =
        {
            { "environment", "production" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/rds"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ssm"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rds.NewInstance(ctx, "default", &rds.InstanceArgs{
			AllocatedStorage:   pulumi.Int(10),
			StorageType:        pulumi.String(rds.StorageTypeGP2),
			Engine:             pulumi.String("mysql"),
			EngineVersion:      pulumi.String("5.7.16"),
			InstanceClass:      pulumi.String(rds.InstanceType_T2_Micro),
			DbName:             pulumi.String("mydb"),
			Username:           pulumi.String("foo"),
			Password:           pulumi.Any(databaseMasterPassword),
			DbSubnetGroupName:  pulumi.String("my_database_subnet_group"),
			ParameterGroupName: pulumi.String("default.mysql5.7"),
		})
		if err != nil {
			return err
		}
		_, err = ssm.NewParameter(ctx, "secret", &ssm.ParameterArgs{
			Name:        pulumi.String("/production/database/password/master"),
			Description: pulumi.String("The parameter description"),
			Type:        pulumi.String(ssm.ParameterTypeSecureString),
			Value:       pulumi.Any(databaseMasterPassword),
			Tags: pulumi.StringMap{
				"environment": pulumi.String("production"),
			},
		})
		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.aws.rds.Instance;
import com.pulumi.aws.rds.InstanceArgs;
import com.pulumi.aws.ssm.Parameter;
import com.pulumi.aws.ssm.ParameterArgs;
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 default_ = new Instance("default", InstanceArgs.builder()
            .allocatedStorage(10)
            .storageType("gp2")
            .engine("mysql")
            .engineVersion("5.7.16")
            .instanceClass("db.t2.micro")
            .dbName("mydb")
            .username("foo")
            .password(databaseMasterPassword)
            .dbSubnetGroupName("my_database_subnet_group")
            .parameterGroupName("default.mysql5.7")
            .build());
        var secret = new Parameter("secret", ParameterArgs.builder()
            .name("/production/database/password/master")
            .description("The parameter description")
            .type("SecureString")
            .value(databaseMasterPassword)
            .tags(Map.of("environment", "production"))
            .build());
    }
}
Content copied to clipboard
resources:
  default:
    type: aws:rds:Instance
    properties:
      allocatedStorage: 10
      storageType: gp2
      engine: mysql
      engineVersion: 5.7.16
      instanceClass: db.t2.micro
      dbName: mydb
      username: foo
      password: ${databaseMasterPassword}
      dbSubnetGroupName: my_database_subnet_group
      parameterGroupName: default.mysql5.7
  secret:
    type: aws:ssm:Parameter
    properties:
      name: /production/database/password/master
      description: The parameter description
      type: SecureString
      value: ${databaseMasterPassword}
      tags:
        environment: production
Content copied to clipboard

Import

Using pulumi import, import SSM Parameters using the parameter store name. For example:

$ pulumi import aws:ssm/parameter:Parameter my_param /my_path/my_paramname
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(allowedPattern: Output<String>? = null, arn: Output<String>? = null, dataType: Output<String>? = null, description: Output<String>? = null, insecureValue: Output<String>? = null, keyId: Output<String>? = null, name: Output<String>? = null, overwrite: Output<Boolean>? = null, tags: Output<Map<String, String>>? = null, tier: Output<String>? = null, type: Output<Either<String, ParameterType>>? = null, value: Output<String>? = null)

Properties

Link copied to clipboard
val allowedPattern: Output<String>? = null

Regular expression used to validate the parameter value.

Link copied to clipboard
val arn: Output<String>? = null

ARN of the parameter.

Link copied to clipboard
val dataType: Output<String>? = null

Data type of the parameter. Valid values: text, aws:ssm:integration and aws:ec2:image for AMI format, see the Native parameter support for Amazon Machine Image IDs.

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

Description of the parameter.

Link copied to clipboard
val insecureValue: Output<String>? = null

Value of the parameter. Use caution: This value is never marked as sensitive in the pulumi preview output. This argument is not valid with a type of SecureString.

Link copied to clipboard
val keyId: Output<String>? = null

KMS key ID or ARN for encrypting a SecureString.

Link copied to clipboard
val name: Output<String>? = null

Name of the parameter. If the name contains a path (e.g., any forward slashes (/)), it must be fully qualified with a leading forward slash (/). For additional requirements and constraints, see the AWS SSM User Guide.

Link copied to clipboard
val overwrite: Output<Boolean>? = null

Overwrite an existing parameter. If not specified, defaults to false during create operations to avoid overwriting existing resources and then true for all subsequent operations once the resource is managed by IAC. Lifecycle rules should be used to manage non-standard update behavior.

Link copied to clipboard
val tags: Output<Map<String, String>>? = null

Map of tags to assign to the object. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

Link copied to clipboard
val tier: Output<String>? = null

Parameter tier to assign to the parameter. If not specified, will use the default parameter tier for the region. Valid tiers are Standard, Advanced, and Intelligent-Tiering. Downgrading an Advanced tier parameter to Standard will recreate the resource. For more information on parameter tiers, see the AWS SSM Parameter tier comparison and guide.

Link copied to clipboard
val type: Output<Either<String, ParameterType>>? = null

Type of the parameter. Valid types are String, StringList and SecureString. The following arguments are optional:

Link copied to clipboard
val value: Output<String>? = null

Value of the parameter. This value is always marked as sensitive in the pulumi preview output, regardless of `type

Functions

Link copied to clipboard
open override fun toJava(): ParameterArgs