AWS Systems Manager Construct Library

This module is part of the AWS Cloud Development Kit project.

Using existing SSM Parameters in your CDK app

You can reference existing SSM Parameter Store values that you want to use in your CDK app by using ssm.StringParameter.fromStringParameterAttributes:

const parameterVersion = Token.asNumber({ Ref: 'MyParameter' });

// Retrieve the latest value of the non-secret parameter
// with name "/My/String/Parameter".
const stringValue = ssm.StringParameter.fromStringParameterAttributes(this, 'MyValue', {
  parameterName: '/My/Public/Parameter',
  // 'version' can be specified but is optional.
}).stringValue;
const stringValueVersionFromToken = ssm.StringParameter.fromStringParameterAttributes(this, 'MyValueVersionFromToken', {
  parameterName: '/My/Public/Parameter',
  // parameter version from token
  version: parameterVersion,
}).stringValue;

// Retrieve a specific version of the secret (SecureString) parameter.
// 'version' is always required.
const secretValue = ssm.StringParameter.fromSecureStringParameterAttributes(this, 'MySecureValue', {
  parameterName: '/My/Secret/Parameter',
  version: 5,
});
const secretValueVersionFromToken = ssm.StringParameter.fromSecureStringParameterAttributes(this, 'MySecureValueVersionFromToken', {
  parameterName: '/My/Secret/Parameter',
  // parameter version from token
  version: parameterVersion,
});

python

parameter_version = Token.as_number({"Ref": "MyParameter"})

# Retrieve the latest value of the non-secret parameter
# with name "/My/String/Parameter".
string_value = ssm.StringParameter.from_string_parameter_attributes(self, "MyValue",
    parameter_name="/My/Public/Parameter"
).string_value
string_value_version_from_token = ssm.StringParameter.from_string_parameter_attributes(self, "MyValueVersionFromToken",
    parameter_name="/My/Public/Parameter",
    # parameter version from token
    version=parameter_version
).string_value

# Retrieve a specific version of the secret (SecureString) parameter.
# 'version' is always required.
secret_value = ssm.StringParameter.from_secure_string_parameter_attributes(self, "MySecureValue",
    parameter_name="/My/Secret/Parameter",
    version=5
)
secret_value_version_from_token = ssm.StringParameter.from_secure_string_parameter_attributes(self, "MySecureValueVersionFromToken",
    parameter_name="/My/Secret/Parameter",
    # parameter version from token
    version=parameter_version
)

java

Number parameterVersion = Token.asNumber(Map.of("Ref", "MyParameter"));

// Retrieve the latest value of the non-secret parameter
// with name "/My/String/Parameter".
String stringValue = StringParameter.fromStringParameterAttributes(this, "MyValue", StringParameterAttributes.builder()
        .parameterName("/My/Public/Parameter")
        .build()).getStringValue();
String stringValueVersionFromToken = StringParameter.fromStringParameterAttributes(this, "MyValueVersionFromToken", StringParameterAttributes.builder()
        .parameterName("/My/Public/Parameter")
        // parameter version from token
        .version(parameterVersion)
        .build()).getStringValue();

// Retrieve a specific version of the secret (SecureString) parameter.
// 'version' is always required.
IStringParameter secretValue = StringParameter.fromSecureStringParameterAttributes(this, "MySecureValue", SecureStringParameterAttributes.builder()
        .parameterName("/My/Secret/Parameter")
        .version(5)
        .build());
IStringParameter secretValueVersionFromToken = StringParameter.fromSecureStringParameterAttributes(this, "MySecureValueVersionFromToken", SecureStringParameterAttributes.builder()
        .parameterName("/My/Secret/Parameter")
        // parameter version from token
        .version(parameterVersion)
        .build());

csharp

var parameterVersion = Token.AsNumber(new Dictionary<string, string> { { "Ref", "MyParameter" } });

// Retrieve the latest value of the non-secret parameter
// with name "/My/String/Parameter".
var stringValue = StringParameter.FromStringParameterAttributes(this, "MyValue", new StringParameterAttributes {
    ParameterName = "/My/Public/Parameter"
}).StringValue;
var stringValueVersionFromToken = StringParameter.FromStringParameterAttributes(this, "MyValueVersionFromToken", new StringParameterAttributes {
    ParameterName = "/My/Public/Parameter",
    // parameter version from token
    Version = parameterVersion
}).StringValue;

// Retrieve a specific version of the secret (SecureString) parameter.
// 'version' is always required.
var secretValue = StringParameter.FromSecureStringParameterAttributes(this, "MySecureValue", new SecureStringParameterAttributes {
    ParameterName = "/My/Secret/Parameter",
    Version = 5
});
var secretValueVersionFromToken = StringParameter.FromSecureStringParameterAttributes(this, "MySecureValueVersionFromToken", new SecureStringParameterAttributes {
    ParameterName = "/My/Secret/Parameter",
    // parameter version from token
    Version = parameterVersion
});

parameterVersion := awscdk.Token_AsNumber(map[string]*string{
	"Ref": jsii.String("MyParameter"),
})

// Retrieve the latest value of the non-secret parameter
// with name "/My/String/Parameter".
stringValue := ssm.StringParameter_FromStringParameterAttributes(this, jsii.String("MyValue"), &StringParameterAttributes{
	ParameterName: jsii.String("/My/Public/Parameter"),
}).StringValue
stringValueVersionFromToken := ssm.StringParameter_FromStringParameterAttributes(this, jsii.String("MyValueVersionFromToken"), &StringParameterAttributes{
	ParameterName: jsii.String("/My/Public/Parameter"),
	// parameter version from token
	Version: parameterVersion,
}).StringValue

// Retrieve a specific version of the secret (SecureString) parameter.
// 'version' is always required.
secretValue := ssm.StringParameter_FromSecureStringParameterAttributes(this, jsii.String("MySecureValue"), &SecureStringParameterAttributes{
	ParameterName: jsii.String("/My/Secret/Parameter"),
	Version: jsii.Number(5),
})
secretValueVersionFromToken := ssm.StringParameter_FromSecureStringParameterAttributes(this, jsii.String("MySecureValueVersionFromToken"), &SecureStringParameterAttributes{
	ParameterName: jsii.String("/My/Secret/Parameter"),
	// parameter version from token
	Version: parameterVersion,
})

You can also reference an existing SSM Parameter Store value that matches an AWS specific parameter type:

ssm.StringParameter.valueForTypedStringParameterV2(this, '/My/Public/Parameter', ssm.ParameterValueType.AWS_EC2_IMAGE_ID);

python

ssm.StringParameter.value_for_typed_string_parameter_v2(self, "/My/Public/Parameter", ssm.ParameterValueType.AWS_EC2_IMAGE_ID)

java

StringParameter.valueForTypedStringParameterV2(this, "/My/Public/Parameter", ParameterValueType.AWS_EC2_IMAGE_ID);

csharp

StringParameter.ValueForTypedStringParameterV2(this, "/My/Public/Parameter", ParameterValueType.AWS_EC2_IMAGE_ID);

ssm.StringParameter_ValueForTypedStringParameterV2(this, jsii.String("/My/Public/Parameter"), ssm.ParameterValueType_AWS_EC2_IMAGE_ID)

To do the same for a SSM Parameter Store value that is stored as a list:

ssm.StringListParameter.valueForTypedListParameter(this, '/My/Public/Parameter', ssm.ParameterValueType.AWS_EC2_IMAGE_ID);

python

ssm.StringListParameter.value_for_typed_list_parameter(self, "/My/Public/Parameter", ssm.ParameterValueType.AWS_EC2_IMAGE_ID)

java

StringListParameter.valueForTypedListParameter(this, "/My/Public/Parameter", ParameterValueType.AWS_EC2_IMAGE_ID);

csharp

StringListParameter.ValueForTypedListParameter(this, "/My/Public/Parameter", ParameterValueType.AWS_EC2_IMAGE_ID);

ssm.StringListParameter_ValueForTypedListParameter(this, jsii.String("/My/Public/Parameter"), ssm.ParameterValueType_AWS_EC2_IMAGE_ID)

Lookup existing parameters

You can also use an existing parameter by looking up the parameter from the AWS environment. This method uses AWS API calls to lookup the value from SSM during synthesis.

const stringValue = ssm.StringParameter.valueFromLookup(this, '/My/Public/Parameter');

python

string_value = ssm.StringParameter.value_from_lookup(self, "/My/Public/Parameter")

java

String stringValue = StringParameter.valueFromLookup(this, "/My/Public/Parameter");

csharp

var stringValue = StringParameter.ValueFromLookup(this, "/My/Public/Parameter");

stringValue := ssm.StringParameter_ValueFromLookup(this, jsii.String("/My/Public/Parameter"))

The result of the StringParameter.valueFromLookup() operation will be written to a file called cdk.context.json. You must commit this file to source control so that the lookup values are available in non-privileged environments such as CI build steps, and to ensure your template builds are repeatable.

To customize the cache key, use the additionalCacheKey property of the options parameter. This allows you to have multiple lookups with the same parameters cache their values separately. This can be useful if you want to scope the context variable to a construct (ie, using additionalCacheKey: this.node.path), so that if the value in the cache needs to be updated, it does not need to be updated for all constructs at the same time.

const stringValue = ssm.StringParameter.valueFromLookup(this, '/My/Public/Parameter', undefined, { additionalCacheKey: this.node.path });

python

string_value = ssm.StringParameter.value_from_lookup(self, "/My/Public/Parameter", undefined, additional_cache_key=self.node.path)

java

String stringValue = StringParameter.valueFromLookup(this, "/My/Public/Parameter", undefined, StringParameterLookupOptions.builder().additionalCacheKey(this.node.getPath()).build());

csharp

var stringValue = StringParameter.ValueFromLookup(this, "/My/Public/Parameter", undefined, new StringParameterLookupOptions { AdditionalCacheKey = Node.Path });

stringValue := ssm.StringParameter_ValueFromLookup(this, jsii.String("/My/Public/Parameter"), undefined, &StringParameterLookupOptions{
	AdditionalCacheKey: this.Node.Path,
})

When using valueFromLookup an initial value of 'dummy-value-for-${parameterName}' (dummy-value-for-/My/Public/Parameter in the above example) is returned prior to the lookup being performed. This can lead to errors if you are using this value in places that require a certain format. For example if you have stored the ARN for a SNS topic in a SSM Parameter which you want to lookup and provide to Topic.fromTopicArn()

const arnLookup = ssm.StringParameter.valueFromLookup(this, '/my/topic/arn');
sns.Topic.fromTopicArn(this, 'Topic', arnLookup);

python

arn_lookup = ssm.StringParameter.value_from_lookup(self, "/my/topic/arn")
sns.Topic.from_topic_arn(self, "Topic", arn_lookup)

java

String arnLookup = StringParameter.valueFromLookup(this, "/my/topic/arn");
Topic.fromTopicArn(this, "Topic", arnLookup);

csharp

var arnLookup = StringParameter.ValueFromLookup(this, "/my/topic/arn");
Topic.FromTopicArn(this, "Topic", arnLookup);

arnLookup := ssm.StringParameter_ValueFromLookup(this, jsii.String("/my/topic/arn"))
sns.Topic_FromTopicArn(this, jsii.String("Topic"), arnLookup)

Initially arnLookup will be equal to dummy-value-for-/my/topic/arn which will cause Topic.fromTopicArn to throw an error indicating that the value is not in arn format.

For these use cases you need to handle the dummy-value in your code. For example:

const arnLookup = ssm.StringParameter.valueFromLookup(this, '/my/topic/arn');
let arnLookupValue: string;
if (arnLookup.includes('dummy-value')) {
	arnLookupValue = this.formatArn({
	service: 'sns',
	resource: 'topic',
	resourceName: arnLookup,
	});

} else {
	arnLookupValue = arnLookup;
}

sns.Topic.fromTopicArn(this, 'Topic', arnLookupValue);

python

arn_lookup = ssm.StringParameter.value_from_lookup(self, "/my/topic/arn")
# arn_lookup_value: str
if arn_lookup.includes("dummy-value"):
    arn_lookup_value = self.format_arn(
        service="sns",
        resource="topic",
        resource_name=arn_lookup
    )
else:
    arn_lookup_value = arn_lookup

sns.Topic.from_topic_arn(self, "Topic", arn_lookup_value)

java

String arnLookup = StringParameter.valueFromLookup(this, "/my/topic/arn");
String arnLookupValue;
if (arnLookup.includes("dummy-value")) {
    arnLookupValue = this.formatArn(ArnComponents.builder()
            .service("sns")
            .resource("topic")
            .resourceName(arnLookup)
            .build());
} else {
    arnLookupValue = arnLookup;
}

Topic.fromTopicArn(this, "Topic", arnLookupValue);

csharp

var arnLookup = StringParameter.ValueFromLookup(this, "/my/topic/arn");
string arnLookupValue;
if (arnLookup.Includes("dummy-value"))
{
    arnLookupValue = FormatArn(new ArnComponents {
        Service = "sns",
        Resource = "topic",
        ResourceName = arnLookup
    });
}
else
{
    arnLookupValue = arnLookup;
}

Topic.FromTopicArn(this, "Topic", arnLookupValue);

arnLookup := ssm.StringParameter_ValueFromLookup(this, jsii.String("/my/topic/arn"))
var arnLookupValue string
if arnLookup.includes(jsii.String("dummy-value")) {
	arnLookupValue = this.FormatArn(&ArnComponents{
		Service: jsii.String("sns"),
		Resource: jsii.String("topic"),
		ResourceName: arnLookup,
	})
} else {
	arnLookupValue = arnLookup
}

sns.Topic_FromTopicArn(this, jsii.String("Topic"), arnLookupValue)

Alternatively, if the property supports tokens you can convert the parameter value into a token to be resolved after the lookup has been completed.

const arnLookup = ssm.StringParameter.valueFromLookup(this, '/my/role/arn');
iam.Role.fromRoleArn(this, 'role', Lazy.string({ produce: () => arnLookup }));

python

arn_lookup = ssm.StringParameter.value_from_lookup(self, "/my/role/arn")
iam.Role.from_role_arn(self, "role", Lazy.string({"produce": () => arnLookup}))

java

String arnLookup = StringParameter.valueFromLookup(this, "/my/role/arn");
Role.fromRoleArn(this, "role", Lazy.string(Map.of("produce", () => arnLookup)));

csharp

var arnLookup = StringParameter.ValueFromLookup(this, "/my/role/arn");
Role.FromRoleArn(this, "role", Lazy.String(new Dictionary<string, produce> { { "produce", () => arnLookup } }));

arnLookup := ssm.StringParameter_ValueFromLookup(this, jsii.String("/my/role/arn"))
iam.Role_FromRoleArn(this, jsii.String("role"), awscdk.Lazy_String(map[string]produce{
	"produce": () => arnLookup,
}))

AWS Systems Manager (SSM) Parameter Store supports cross-account sharing of parameters using the AWS Resource Access Manager (AWS RAM) service. In a multi-account environment, this feature enables accounts (referred to as "consuming accounts") to access and retrieve parameter values that are shared by other accounts (referred to as "sharing accounts"). To reference and use a shared SSM parameter in a consuming account, the fromStringParameterArn() method can be employed.

The fromStringParameterArn() method provides a way for consuming accounts to create an instance of the StringParameter class from the Amazon Resource Name (ARN) of a shared SSM parameter. This allows the consuming account to retrieve and utilize the parameter value, even though the parameter itself is owned and managed by a different sharing account.

const sharingParameterArn = 'arn:aws:ssm:us-east-1:1234567890:parameter/dummyName';
const sharedParam = ssm.StringParameter.fromStringParameterArn(this, 'SharedParam', sharingParameterArn);
// the value can be accessed via sharedParam.stringValue

python

sharing_parameter_arn = "arn:aws:ssm:us-east-1:1234567890:parameter/dummyName"
shared_param = ssm.StringParameter.from_string_parameter_arn(self, "SharedParam", sharing_parameter_arn)

java

String sharingParameterArn = "arn:aws:ssm:us-east-1:1234567890:parameter/dummyName";
IStringParameter sharedParam = StringParameter.fromStringParameterArn(this, "SharedParam", sharingParameterArn);

csharp

var sharingParameterArn = "arn:aws:ssm:us-east-1:1234567890:parameter/dummyName";
var sharedParam = StringParameter.FromStringParameterArn(this, "SharedParam", sharingParameterArn);

sharingParameterArn := "arn:aws:ssm:us-east-1:1234567890:parameter/dummyName"
sharedParam := ssm.StringParameter_FromStringParameterArn(this, jsii.String("SharedParam"), sharingParameterArn)

Things to note:

The account that owns the AWS Systems Manager (SSM) parameter and wants to share it with other accounts (referred to as the "sharing account") must create the parameter in the advanced tier. This is a prerequisite for sharing SSM parameters across accounts.
After creating the parameter in the advanced tier, the sharing account needs to set up a resource share using AWS Resource Access Manager (RAM). This resource share will specify the SSM parameter(s) to be shared and the accounts (referred to as "consuming accounts") with which the parameter(s) should be shared.
Once the resource share is created by the sharing account, the consuming account(s) will receive an invitation to join the resource share. For the consuming account(s) to access and use the shared SSM parameter(s), they must accept the resource share invitation from the sharing account.
The AWS Systems Manager Parameter Store parameter being referenced must be located in the same AWS region as the AWS CDK stack that is consuming or using the parameter.

In summary, the process involves three main steps:

The sharing account creates the SSM parameter(s) in the advanced tier.
The sharing account creates a resource share using AWS RAM, specifying the SSM parameter(s) and the consuming account(s).
The consuming account(s) accept the resource share invitation to gain access to the shared SSM parameter(s).

This cross-account sharing mechanism allows for centralized management and distribution of configuration data (stored as SSM parameters) across multiple AWS accounts within an organization or between different organizations.

Read Working with shared parameters for more details.

Creating new SSM Parameters in your CDK app

You can create either ssm.StringParameter or ssm.StringListParameters in a CDK app. These are public (not secret) values. Parameters of type SecureString cannot be created directly from a CDK application; if you want to provision secrets automatically, use Secrets Manager Secrets (see the aws-cdk-lib/aws-secretsmanager package).

new ssm.StringParameter(this, 'Parameter', {
  allowedPattern: '.*',
  description: 'The value Foo',
  parameterName: 'FooParameter',
  stringValue: 'Foo',
  tier: ssm.ParameterTier.ADVANCED,
});

python

ssm.StringParameter(self, "Parameter",
    allowed_pattern=".*",
    description="The value Foo",
    parameter_name="FooParameter",
    string_value="Foo",
    tier=ssm.ParameterTier.ADVANCED
)

java

StringParameter.Builder.create(this, "Parameter")
        .allowedPattern(".*")
        .description("The value Foo")
        .parameterName("FooParameter")
        .stringValue("Foo")
        .tier(ParameterTier.ADVANCED)
        .build();

csharp

new StringParameter(this, "Parameter", new StringParameterProps {
    AllowedPattern = ".*",
    Description = "The value Foo",
    ParameterName = "FooParameter",
    StringValue = "Foo",
    Tier = ParameterTier.ADVANCED
});

ssm.NewStringParameter(this, jsii.String("Parameter"), &StringParameterProps{
	AllowedPattern: jsii.String(".*"),
	Description: jsii.String("The value Foo"),
	ParameterName: jsii.String("FooParameter"),
	StringValue: jsii.String("Foo"),
	Tier: ssm.ParameterTier_ADVANCED,
})

// Create a new SSM Parameter holding a String
const param = new ssm.StringParameter(this, 'StringParameter', {
  // description: 'Some user-friendly description',
  // name: 'ParameterName',
  stringValue: 'Initial parameter value',
  // allowedPattern: '.*',
});

// Grant read access to some Role
declare const role: iam.IRole;
param.grantRead(role);

// Create a new SSM Parameter holding a StringList
const listParameter = new ssm.StringListParameter(this, 'StringListParameter', {
  // description: 'Some user-friendly description',
  // name: 'ParameterName',
  stringListValue: ['Initial parameter value A', 'Initial parameter value B'],
  // allowedPattern: '.*',
});

python

# Grant read access to some Role
# role: iam.IRole
# Create a new SSM Parameter holding a String
param = ssm.StringParameter(self, "StringParameter",
    # description: 'Some user-friendly description',
    # name: 'ParameterName',
    string_value="Initial parameter value"
)
param.grant_read(role)

# Create a new SSM Parameter holding a StringList
list_parameter = ssm.StringListParameter(self, "StringListParameter",
    # description: 'Some user-friendly description',
    # name: 'ParameterName',
    string_list_value=["Initial parameter value A", "Initial parameter value B"]
)

java

// Grant read access to some Role
IRole role;
// Create a new SSM Parameter holding a String
StringParameter param = StringParameter.Builder.create(this, "StringParameter")
        // description: 'Some user-friendly description',
        // name: 'ParameterName',
        .stringValue("Initial parameter value")
        .build();
param.grantRead(role);

// Create a new SSM Parameter holding a StringList
StringListParameter listParameter = StringListParameter.Builder.create(this, "StringListParameter")
        // description: 'Some user-friendly description',
        // name: 'ParameterName',
        .stringListValue(List.of("Initial parameter value A", "Initial parameter value B"))
        .build();

csharp

// Grant read access to some Role
IRole role;
// Create a new SSM Parameter holding a String
var param = new StringParameter(this, "StringParameter", new StringParameterProps {
    // description: 'Some user-friendly description',
    // name: 'ParameterName',
    StringValue = "Initial parameter value"
});
param.GrantRead(role);

// Create a new SSM Parameter holding a StringList
var listParameter = new StringListParameter(this, "StringListParameter", new StringListParameterProps {
    // description: 'Some user-friendly description',
    // name: 'ParameterName',
    StringListValue = new [] { "Initial parameter value A", "Initial parameter value B" }
});

// Grant read access to some Role
var role IRole
// Create a new SSM Parameter holding a String
param := ssm.NewStringParameter(this, jsii.String("StringParameter"), &StringParameterProps{
	// description: 'Some user-friendly description',
	// name: 'ParameterName',
	StringValue: jsii.String("Initial parameter value"),
})
param.grantRead(role)

// Create a new SSM Parameter holding a StringList
listParameter := ssm.NewStringListParameter(this, jsii.String("StringListParameter"), &StringListParameterProps{
	// description: 'Some user-friendly description',
	// name: 'ParameterName',
	StringListValue: []*string{
		jsii.String("Initial parameter value A"),
		jsii.String("Initial parameter value B"),
	},
})

When specifying an allowedPattern, the values provided as string literals are validated against the pattern and an exception is raised if a value provided does not comply.

Using Tokens in parameter name

When using CDK Tokens in parameter name, you need to explicitly set the simpleName property. Setting simpleName to an incorrect boolean value may result in unexpected behaviours, such as having duplicate '/' in the parameter ARN or missing a '/' in the parameter ARN.

simpleName is used to indicates whether the parameter name is a simple name. A parameter name without any '/' is considered a simple name, thus you should set simpleName to true. If the parameter name includes '/', set simpleName to false.

import * as lambda from 'aws-cdk-lib/aws-lambda';

const simpleParameter = new ssm.StringParameter(this, 'StringParameter', {
  // the parameter name doesn't contain any '/'
  parameterName: 'parameter',
  stringValue: 'SOME_VALUE',
  simpleName: true, // set `simpleName` to true
});

declare const func: lambda.IFunction;
const nonSimpleParameter = new ssm.StringParameter(this, 'StringParameter', {
  // the parameter name contains '/'
  parameterName: `/${func.functionName}/my/app/param`,
  stringValue: 'SOME_VALUE',
  simpleName: false, // set `simpleName` to false
});

python

import aws_cdk.aws_lambda as lambda_

# func: lambda.IFunction


simple_parameter = ssm.StringParameter(self, "StringParameter",
    # the parameter name doesn't contain any '/'
    parameter_name="parameter",
    string_value="SOME_VALUE",
    simple_name=True
)
non_simple_parameter = ssm.StringParameter(self, "StringParameter",
    # the parameter name contains '/'
    parameter_name=f"/{func.functionName}/my/app/param",
    string_value="SOME_VALUE",
    simple_name=False
)

java

import software.amazon.awscdk.services.lambda.*;

IFunction func;


StringParameter simpleParameter = StringParameter.Builder.create(this, "StringParameter")
        // the parameter name doesn't contain any '/'
        .parameterName("parameter")
        .stringValue("SOME_VALUE")
        .simpleName(true)
        .build();
StringParameter nonSimpleParameter = StringParameter.Builder.create(this, "StringParameter")
        // the parameter name contains '/'
        .parameterName(String.format("/%s/my/app/param", func.getFunctionName()))
        .stringValue("SOME_VALUE")
        .simpleName(false)
        .build();

csharp

using Amazon.CDK.AWS.Lambda;

IFunction func;


var simpleParameter = new StringParameter(this, "StringParameter", new StringParameterProps {
    // the parameter name doesn't contain any '/'
    ParameterName = "parameter",
    StringValue = "SOME_VALUE",
    SimpleName = true
});
var nonSimpleParameter = new StringParameter(this, "StringParameter", new StringParameterProps {
    // the parameter name contains '/'
    ParameterName = $"/{func.functionName}/my/app/param",
    StringValue = "SOME_VALUE",
    SimpleName = false
});

import lambda "github.com/aws/aws-cdk-go/awscdk"

var func IFunction


simpleParameter := ssm.NewStringParameter(this, jsii.String("StringParameter"), &StringParameterProps{
	// the parameter name doesn't contain any '/'
	ParameterName: jsii.String("parameter"),
	StringValue: jsii.String("SOME_VALUE"),
	SimpleName: jsii.Boolean(true),
})
nonSimpleParameter := ssm.NewStringParameter(this, jsii.String("StringParameter"), &StringParameterProps{
	// the parameter name contains '/'
	ParameterName: fmt.Sprintf("/%v/my/app/param", func.FunctionName),
	StringValue: jsii.String("SOME_VALUE"),
	SimpleName: jsii.Boolean(false),
})

Types

Name	Kind	Summary
`StringListParameter`	Construct (L2)	Creates a new StringList SSM Parameter.
`StringParameter`	Construct (L2)	Creates a new String SSM Parameter.
`CfnAssociation`	Construct (L1)	The `AWS::SSM::Association` resource creates a State Manager association for your managed instances.
`CfnCloudConnector`	Construct (L1)	Resource Type definition for AWS::SSM::CloudConnector.
`CfnDocument`	Construct (L1)	The `AWS::SSM::Document` resource creates a Systems Manager (SSM) document in AWS Systems Manager .
`CfnMaintenanceWindow`	Construct (L1)	The `AWS::SSM::MaintenanceWindow` resource represents general information about a maintenance window for AWS Systems Manager .
`CfnMaintenanceWindowTarget`	Construct (L1)	The `AWS::SSM::MaintenanceWindowTarget` resource registers a target with a maintenance window for AWS Systems Manager .
`CfnMaintenanceWindowTask`	Construct (L1)	The `AWS::SSM::MaintenanceWindowTask` resource defines information about a task for an AWS Systems Manager maintenance window.
`CfnOpsItem`	Construct (L1)	Resource schema for AWS::SSM::OpsItem.
`CfnParameter`	Construct (L1)	The `AWS::SSM::Parameter` resource creates an SSM parameter in AWS Systems Manager Parameter Store.
`CfnPatchBaseline`	Construct (L1)	The `AWS::SSM::PatchBaseline` resource defines the basic information for an AWS Systems Manager patch baseline.
`CfnResourceDataSync`	Construct (L1)	The `AWS::SSM::ResourceDataSync` resource creates, updates, or deletes a resource data sync for AWS Systems Manager .
`CfnResourcePolicy`	Construct (L1)	Creates or updates a Systems Manager resource policy.
`CfnServiceSetting`	Construct (L1)	Resource Type definition for AWS::SSM::ServiceSetting.
`CfnAssociation.InstanceAssociationOutputLocationProperty`	Struct	`InstanceAssociationOutputLocation` is a property of the AWS::SSM::Association resource that specifies an Amazon S3 bucket where you want to store the results of this association request.
`CfnAssociation.S3OutputLocationProperty`	Struct	`S3OutputLocation` is a property of the AWS::SSM::Association resource that specifies an Amazon S3 bucket where you want to store the results of this association request.
`CfnAssociation.TargetProperty`	Struct	`Target` is a property of the AWS::SSM::Association resource that specifies the targets for an SSM document in Systems Manager . You can target all instances in an AWS account by specifying the `InstanceIds` key with a value of `*` . To view a JSON and a YAML example that targets all instances, see the example "Create an association for all managed instances in an AWS account " later in this page.
`CfnAssociationProps`	Struct	Properties for defining a `CfnAssociation`.
`CfnCloudConnector.AzureConfigurationProperty`	Struct	Configuration for connecting to Azure.
`CfnCloudConnector.AzureSubscriptionProperty`	Struct	An Azure subscription with its ID and optional display name.
`CfnCloudConnector.CloudConnectorConfigurationProperty`	Struct	The configuration for the cloud connector.
`CfnCloudConnector.ConfigurationTargetsProperty`	Struct	The targets for the cloud connector.
`CfnCloudConnectorProps`	Struct	Properties for defining a `CfnCloudConnector`.
`CfnDocument.AttachmentsSourceProperty`	Struct	Identifying information about a document attachment, including the file name and a key-value pair that identifies the location of an attachment to a document.
`CfnDocument.DocumentRequiresProperty`	Struct	An SSM document required by the current document.
`CfnDocumentProps`	Struct	Properties for defining a `CfnDocument`.
`CfnMaintenanceWindowProps`	Struct	Properties for defining a `CfnMaintenanceWindow`.
`CfnMaintenanceWindowTarget.TargetsProperty`	Struct	The `Targets` property type specifies adding a target to a maintenance window target in AWS Systems Manager .
`CfnMaintenanceWindowTargetProps`	Struct	Properties for defining a `CfnMaintenanceWindowTarget`.
`CfnMaintenanceWindowTask.CloudWatchOutputConfigProperty`	Struct	Configuration options for sending command output to Amazon CloudWatch Logs.
`CfnMaintenanceWindowTask.LoggingInfoProperty`	Struct	> `LoggingInfo` has been deprecated.
`CfnMaintenanceWindowTask.MaintenanceWindowAutomationParametersProperty`	Struct	The `MaintenanceWindowAutomationParameters` property type specifies the parameters for an `AUTOMATION` task type for a maintenance window task in AWS Systems Manager .
`CfnMaintenanceWindowTask.MaintenanceWindowLambdaParametersProperty`	Struct	The `MaintenanceWindowLambdaParameters` property type specifies the parameters for a `LAMBDA` task type for a maintenance window task in AWS Systems Manager .
`CfnMaintenanceWindowTask.MaintenanceWindowRunCommandParametersProperty`	Struct	The `MaintenanceWindowRunCommandParameters` property type specifies the parameters for a `RUN_COMMAND` task type for a maintenance window task in AWS Systems Manager .
`CfnMaintenanceWindowTask.MaintenanceWindowStepFunctionsParametersProperty`	Struct	The `MaintenanceWindowStepFunctionsParameters` property type specifies the parameters for the execution of a `STEP_FUNCTIONS` task in a Systems Manager maintenance window.
`CfnMaintenanceWindowTask.NotificationConfigProperty`	Struct	The `NotificationConfig` property type specifies configurations for sending notifications for a maintenance window task in AWS Systems Manager .
`CfnMaintenanceWindowTask.TargetProperty`	Struct	The `Target` property type specifies targets (either instances or window target IDs).
`CfnMaintenanceWindowTask.TaskInvocationParametersProperty`	Struct	The `TaskInvocationParameters` property type specifies the task execution parameters for a maintenance window task in AWS Systems Manager .
`CfnMaintenanceWindowTaskProps`	Struct	Properties for defining a `CfnMaintenanceWindowTask`.
`CfnOpsItemProps`	Struct	Properties for defining a `CfnOpsItem`.
`CfnParameterProps`	Struct	Properties for defining a `CfnParameter`.
`CfnPatchBaseline.PatchFilterGroupProperty`	Struct	The `PatchFilterGroup` property type specifies a set of patch filters for an AWS Systems Manager patch baseline, typically used for approval rules for a Systems Manager patch baseline.
`CfnPatchBaseline.PatchFilterProperty`	Struct	The `PatchFilter` property type defines a patch filter for an AWS Systems Manager patch baseline.
`CfnPatchBaseline.PatchSourceProperty`	Struct	`PatchSource` is the property type for the `Sources` resource of the AWS::SSM::PatchBaseline resource.
`CfnPatchBaseline.RuleGroupProperty`	Struct	The `RuleGroup` property type specifies a set of rules that define the approval rules for an AWS Systems Manager patch baseline.
`CfnPatchBaseline.RuleProperty`	Struct	The `Rule` property type specifies an approval rule for a Systems Manager patch baseline.
`CfnPatchBaselineProps`	Struct	Properties for defining a `CfnPatchBaseline`.
`CfnResourceDataSync.AwsOrganizationsSourceProperty`	Struct	Information about the `AwsOrganizationsSource` resource data sync source.
`CfnResourceDataSync.S3DestinationProperty`	Struct	Information about the target S3 bucket for the resource data sync.
`CfnResourceDataSync.SyncSourceProperty`	Struct	Information about the source of the data included in the resource data sync.
`CfnResourceDataSyncProps`	Struct	Properties for defining a `CfnResourceDataSync`.
`CfnResourcePolicyProps`	Struct	Properties for defining a `CfnResourcePolicy`.
`CfnServiceSettingProps`	Struct	Properties for defining a `CfnServiceSetting`.
`CommonStringParameterAttributes`	Struct	Common attributes for string parameters.
`IParameter`	Interface	An SSM Parameter reference.
`IStringListParameter`	Interface	A StringList SSM Parameter.
`IStringParameter`	Interface	A String SSM Parameter.
`ListParameterAttributes`	Struct	Attributes for parameters of string list type.
`ParameterDataType`	Enum	SSM parameter data type.
`ParameterOptions`	Struct	Properties needed to create a new SSM Parameter.
`ParameterTier`	Enum	SSM parameter tier.
`ParameterType`	Enum	SSM parameter type.
`ParameterValueType`	Enum	The type of CFN SSM Parameter.
`SecureStringParameterAttributes`	Struct	Attributes for secure string parameters.
`StringListParameterProps`	Struct	Properties needed to create a StringList SSM Parameter.
`StringParameterAttributes`	Struct	Attributes for parameters of various types of string.
`StringParameterLookupOptions`	Struct	Additional properties for looking up an existing StringParameter.
`StringParameterProps`	Struct	Properties needed to create a String SSM parameter.

AWS Systems Manager Construct Library ​

Using existing SSM Parameters in your CDK app ​

Lookup existing parameters ​

cross-account SSM Parameters sharing ​

Creating new SSM Parameters in your CDK app ​

Using Tokens in parameter name ​

Types ​

AWS Systems Manager Construct Library

Using existing SSM Parameters in your CDK app

Lookup existing parameters

cross-account SSM Parameters sharing

Creating new SSM Parameters in your CDK app

Using Tokens in parameter name

Types