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

Parameter

class Parameter : KotlinCustomResource

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

Properties

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

Regular expression used to validate the parameter value.

Link copied to clipboard
val arn: Output<String>

ARN of the parameter.

Link copied to clipboard
val dataType: Output<String>

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>?

Description of the parameter.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val insecureValue: Output<String>

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>

KMS key ID or ARN for encrypting a SecureString.

Link copied to clipboard
val name: Output<String>

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>?

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 pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val tags: Output<Map<String, String>>?

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 tagsAll: Output<Map<String, String>>

Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

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

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<String>

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

Link copied to clipboard
val urn: Output<String>
Link copied to clipboard
val value: Output<String>

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

Link copied to clipboard
val version: Output<Int>

Version of the parameter.