aws-cdk-lib.aws_appconfig

AWS AppConfig Construct Library

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

For a high level overview of what AWS AppConfig is and how it works, please take a look here: What is AWS AppConfig?

Basic Hosted Configuration Use Case

The main way most AWS AppConfig users utilize the service is through hosted configuration, which involves storing configuration data directly within AWS AppConfig.

An example use case:

const app = new appconfig.Application(this, 'MyApp');
const env = new appconfig.Environment(this, 'MyEnv', {
  application: app,
});

new appconfig.HostedConfiguration(this, 'MyHostedConfig', {
  application: app,
  deployTo: [env],
  content: appconfig.ConfigurationContent.fromInlineText('This is my configuration content.'),
});

app = appconfig.Application(self, "MyApp")
env = appconfig.Environment(self, "MyEnv",
    application=app
)

appconfig.HostedConfiguration(self, "MyHostedConfig",
    application=app,
    deploy_to=[env],
    content=appconfig.ConfigurationContent.from_inline_text("This is my configuration content.")
)

Application app = new Application(this, "MyApp");
Environment env = Environment.Builder.create(this, "MyEnv")
        .application(app)
        .build();

HostedConfiguration.Builder.create(this, "MyHostedConfig")
        .application(app)
        .deployTo(List.of(env))
        .content(ConfigurationContent.fromInlineText("This is my configuration content."))
        .build();

var app = new Application(this, "MyApp");
var env = new Environment(this, "MyEnv", new EnvironmentProps {
    Application = app
});

new HostedConfiguration(this, "MyHostedConfig", new HostedConfigurationProps {
    Application = app,
    DeployTo = new [] { env },
    Content = ConfigurationContent.FromInlineText("This is my configuration content.")
});

app := appconfig.NewApplication(this, jsii.String("MyApp"))
env := appconfig.NewEnvironment(this, jsii.String("MyEnv"), &EnvironmentProps{
	Application: app,
})

appconfig.NewHostedConfiguration(this, jsii.String("MyHostedConfig"), &HostedConfigurationProps{
	Application: app,
	DeployTo: []IEnvironment{
		env,
	},
	Content: appconfig.ConfigurationContent_FromInlineText(jsii.String("This is my configuration content.")),
})

This will create the application and environment for your configuration and then deploy your configuration to the specified environment.

For more information about what these resources are: Creating feature flags and free form configuration data in AWS AppConfig.

For more information about deploying configuration: Deploying feature flags and configuration data in AWS AppConfig

---

For an in-depth walkthrough of specific resources and how to use them, please take a look at the following sections.

Application

AWS AppConfig Application Documentation

In AWS AppConfig, an application is simply an organizational construct like a folder. Configurations and environments are associated with the application.

When creating an application through CDK, the name and description of an application are optional.

Create a simple application:

new appconfig.Application(this, 'MyApplication');

appconfig.Application(self, "MyApplication")

new Application(this, "MyApplication");

new Application(this, "MyApplication");

appconfig.NewApplication(this, jsii.String("MyApplication"))

Environment

AWS AppConfig Environment Documentation

Basic environment with monitors:

declare const application: appconfig.Application;
declare const alarm: cloudwatch.Alarm;
declare const compositeAlarm: cloudwatch.CompositeAlarm;

new appconfig.Environment(this, 'MyEnvironment', {
  application,
  monitors: [
    appconfig.Monitor.fromCloudWatchAlarm(alarm),
    appconfig.Monitor.fromCloudWatchAlarm(compositeAlarm),
  ],
});

# application: appconfig.Application
# alarm: cloudwatch.Alarm
# composite_alarm: cloudwatch.CompositeAlarm


appconfig.Environment(self, "MyEnvironment",
    application=application,
    monitors=[
        appconfig.Monitor.from_cloud_watch_alarm(alarm),
        appconfig.Monitor.from_cloud_watch_alarm(composite_alarm)
    ]
)

Application application;
Alarm alarm;
CompositeAlarm compositeAlarm;


Environment.Builder.create(this, "MyEnvironment")
        .application(application)
        .monitors(List.of(Monitor.fromCloudWatchAlarm(alarm), Monitor.fromCloudWatchAlarm(compositeAlarm)))
        .build();

Application application;
Alarm alarm;
CompositeAlarm compositeAlarm;


new Environment(this, "MyEnvironment", new EnvironmentProps {
    Application = application,
    Monitors = new [] { Monitor.FromCloudWatchAlarm(alarm), Monitor.FromCloudWatchAlarm(compositeAlarm) }
});

var application Application
var alarm Alarm
var compositeAlarm CompositeAlarm


appconfig.NewEnvironment(this, jsii.String("MyEnvironment"), &EnvironmentProps{
	Application: Application,
	Monitors: []Monitor{
		appconfig.Monitor_FromCloudWatchAlarm(alarm),
		appconfig.Monitor_*FromCloudWatchAlarm(compositeAlarm),
	},
})

Environment monitors also support L1 CfnEnvironment.MonitorsProperty constructs through the fromCfnMonitorsProperty method. However, this is not the recommended approach for CloudWatch alarms because a role will not be auto-generated if not provided.

See About the AWS AppConfig data plane service for more information.

Permissions

You can grant read permission on the environment's configurations with the grantReadConfig method as follows:

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

const app = new appconfig.Application(this, 'MyAppConfig');
const env = new appconfig.Environment(this, 'MyEnvironment', {
  application: app,
});

const user = new iam.User(this, 'MyUser');
env.grantReadConfig(user);

import aws_cdk.aws_iam as iam


app = appconfig.Application(self, "MyAppConfig")
env = appconfig.Environment(self, "MyEnvironment",
    application=app
)

user = iam.User(self, "MyUser")
env.grant_read_config(user)

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


Application app = new Application(this, "MyAppConfig");
Environment env = Environment.Builder.create(this, "MyEnvironment")
        .application(app)
        .build();

User user = new User(this, "MyUser");
env.grantReadConfig(user);

using Amazon.CDK.AWS.IAM;


var app = new Application(this, "MyAppConfig");
var env = new Environment(this, "MyEnvironment", new EnvironmentProps {
    Application = app
});

var user = new User(this, "MyUser");
env.GrantReadConfig(user);

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


app := appconfig.NewApplication(this, jsii.String("MyAppConfig"))
env := appconfig.NewEnvironment(this, jsii.String("MyEnvironment"), &EnvironmentProps{
	Application: app,
})

user := iam.NewUser(this, jsii.String("MyUser"))
env.grantReadConfig(user)

Deployment Strategy

AWS AppConfig Deployment Strategy Documentation

A deployment strategy defines how a configuration will roll out. The roll out is defined by four parameters: deployment type, growth factor, deployment duration, and final bake time.

Deployment strategy with predefined values:

new appconfig.DeploymentStrategy(this, 'MyDeploymentStrategy', {
  rolloutStrategy: appconfig.RolloutStrategy.CANARY_10_PERCENT_20_MINUTES,
});

appconfig.DeploymentStrategy(self, "MyDeploymentStrategy",
    rollout_strategy=appconfig.RolloutStrategy.CANARY_10_PERCENT_20_MINUTES
)

DeploymentStrategy.Builder.create(this, "MyDeploymentStrategy")
        .rolloutStrategy(RolloutStrategy.CANARY_10_PERCENT_20_MINUTES)
        .build();

new DeploymentStrategy(this, "MyDeploymentStrategy", new DeploymentStrategyProps {
    RolloutStrategy = RolloutStrategy.CANARY_10_PERCENT_20_MINUTES
});

appconfig.NewDeploymentStrategy(this, jsii.String("MyDeploymentStrategy"), &DeploymentStrategyProps{
	RolloutStrategy: appconfig.RolloutStrategy_CANARY_10_PERCENT_20_MINUTES(),
})

Deployment strategy with custom values:

new appconfig.DeploymentStrategy(this, 'MyDeploymentStrategy', {
  rolloutStrategy: appconfig.RolloutStrategy.linear({
    growthFactor: 20,
    deploymentDuration: Duration.minutes(30),
    finalBakeTime: Duration.minutes(30),
  }),
});

appconfig.DeploymentStrategy(self, "MyDeploymentStrategy",
    rollout_strategy=appconfig.RolloutStrategy.linear(
        growth_factor=20,
        deployment_duration=Duration.minutes(30),
        final_bake_time=Duration.minutes(30)
    )
)

DeploymentStrategy.Builder.create(this, "MyDeploymentStrategy")
        .rolloutStrategy(RolloutStrategy.linear(RolloutStrategyProps.builder()
                .growthFactor(20)
                .deploymentDuration(Duration.minutes(30))
                .finalBakeTime(Duration.minutes(30))
                .build()))
        .build();

new DeploymentStrategy(this, "MyDeploymentStrategy", new DeploymentStrategyProps {
    RolloutStrategy = RolloutStrategy.Linear(new RolloutStrategyProps {
        GrowthFactor = 20,
        DeploymentDuration = Duration.Minutes(30),
        FinalBakeTime = Duration.Minutes(30)
    })
});

appconfig.NewDeploymentStrategy(this, jsii.String("MyDeploymentStrategy"), &DeploymentStrategyProps{
	RolloutStrategy: appconfig.RolloutStrategy_Linear(&RolloutStrategyProps{
		GrowthFactor: jsii.Number(20),
		DeploymentDuration: awscdk.Duration_Minutes(jsii.Number(30)),
		FinalBakeTime: awscdk.Duration_*Minutes(jsii.Number(30)),
	}),
})

Referencing a deployment strategy by ID:

appconfig.DeploymentStrategy.fromDeploymentStrategyId(this, 'MyImportedDeploymentStrategy', appconfig.DeploymentStrategyId.fromString('abc123'));

appconfig.DeploymentStrategy.from_deployment_strategy_id(self, "MyImportedDeploymentStrategy", appconfig.DeploymentStrategyId.from_string("abc123"))

DeploymentStrategy.fromDeploymentStrategyId(this, "MyImportedDeploymentStrategy", DeploymentStrategyId.fromString("abc123"));

DeploymentStrategy.FromDeploymentStrategyId(this, "MyImportedDeploymentStrategy", DeploymentStrategyId.FromString("abc123"));

appconfig.DeploymentStrategy_FromDeploymentStrategyId(this, jsii.String("MyImportedDeploymentStrategy"), appconfig.DeploymentStrategyId_FromString(jsii.String("abc123")))

Referencing an AWS AppConfig predefined deployment strategy by ID:

appconfig.DeploymentStrategy.fromDeploymentStrategyId(
  this,
  'MyImportedPredefinedDeploymentStrategy',
  appconfig.DeploymentStrategyId.CANARY_10_PERCENT_20_MINUTES,
);

appconfig.DeploymentStrategy.from_deployment_strategy_id(self, "MyImportedPredefinedDeploymentStrategy", appconfig.DeploymentStrategyId.CANARY_10_PERCENT_20_MINUTES)

DeploymentStrategy.fromDeploymentStrategyId(this, "MyImportedPredefinedDeploymentStrategy", DeploymentStrategyId.CANARY_10_PERCENT_20_MINUTES);

DeploymentStrategy.FromDeploymentStrategyId(this, "MyImportedPredefinedDeploymentStrategy", DeploymentStrategyId.CANARY_10_PERCENT_20_MINUTES);

appconfig.DeploymentStrategy_FromDeploymentStrategyId(this, jsii.String("MyImportedPredefinedDeploymentStrategy"), appconfig.DeploymentStrategyId_CANARY_10_PERCENT_20_MINUTES())

Configuration

A configuration is a higher-level construct that can either be a HostedConfiguration (stored internally through AWS AppConfig) or a SourcedConfiguration (stored in an Amazon S3 bucket, AWS Secrets Manager secrets, Systems Manager (SSM) Parameter Store parameters, SSM documents, or AWS CodePipeline). This construct manages deployments on creation.

HostedConfiguration

A hosted configuration represents configuration stored in the AWS AppConfig hosted configuration store. A hosted configuration takes in the configuration content and associated AWS AppConfig application. On construction of a hosted configuration, the configuration is deployed.

You can define hosted configuration content using any of the following ConfigurationContent methods:

• fromFile - Defines the hosted configuration content from a file (you can specify a relative path). The content type will be determined by the file extension unless specified.

declare const application: appconfig.Application;

new appconfig.HostedConfiguration(this, 'MyHostedConfiguration', {
  application,
  content: appconfig.ConfigurationContent.fromFile('config.json'),
});

# application: appconfig.Application


appconfig.HostedConfiguration(self, "MyHostedConfiguration",
    application=application,
    content=appconfig.ConfigurationContent.from_file("config.json")
)

Application application;


HostedConfiguration.Builder.create(this, "MyHostedConfiguration")
        .application(application)
        .content(ConfigurationContent.fromFile("config.json"))
        .build();

Application application;


new HostedConfiguration(this, "MyHostedConfiguration", new HostedConfigurationProps {
    Application = application,
    Content = ConfigurationContent.FromFile("config.json")
});

var application Application


appconfig.NewHostedConfiguration(this, jsii.String("MyHostedConfiguration"), &HostedConfigurationProps{
	Application: Application,
	Content: appconfig.ConfigurationContent_FromFile(jsii.String("config.json")),
})

• fromInlineText - Defines the hosted configuration from inline text. The content type will be set as text/plain.

declare const application: appconfig.Application;

new appconfig.HostedConfiguration(this, 'MyHostedConfiguration', {
  application,
  content: appconfig.ConfigurationContent.fromInlineText('This is my configuration content.'),
});

# application: appconfig.Application


appconfig.HostedConfiguration(self, "MyHostedConfiguration",
    application=application,
    content=appconfig.ConfigurationContent.from_inline_text("This is my configuration content.")
)

Application application;


HostedConfiguration.Builder.create(this, "MyHostedConfiguration")
        .application(application)
        .content(ConfigurationContent.fromInlineText("This is my configuration content."))
        .build();

Application application;


new HostedConfiguration(this, "MyHostedConfiguration", new HostedConfigurationProps {
    Application = application,
    Content = ConfigurationContent.FromInlineText("This is my configuration content.")
});

var application Application


appconfig.NewHostedConfiguration(this, jsii.String("MyHostedConfiguration"), &HostedConfigurationProps{
	Application: Application,
	Content: appconfig.ConfigurationContent_FromInlineText(jsii.String("This is my configuration content.")),
})

• fromInlineJson - Defines the hosted configuration from inline JSON. The content type will be set as application/json unless specified.

declare const application: appconfig.Application;

new appconfig.HostedConfiguration(this, 'MyHostedConfiguration', {
  application,
  content: appconfig.ConfigurationContent.fromInlineJson('{}'),
});

# application: appconfig.Application


appconfig.HostedConfiguration(self, "MyHostedConfiguration",
    application=application,
    content=appconfig.ConfigurationContent.from_inline_json("{}")
)

Application application;


HostedConfiguration.Builder.create(this, "MyHostedConfiguration")
        .application(application)
        .content(ConfigurationContent.fromInlineJson("{}"))
        .build();

Application application;


new HostedConfiguration(this, "MyHostedConfiguration", new HostedConfigurationProps {
    Application = application,
    Content = ConfigurationContent.FromInlineJson("{}")
});

var application Application


appconfig.NewHostedConfiguration(this, jsii.String("MyHostedConfiguration"), &HostedConfigurationProps{
	Application: Application,
	Content: appconfig.ConfigurationContent_FromInlineJson(jsii.String("{}")),
})

• fromInlineYaml - Defines the hosted configuration from inline YAML. The content type will be set as application/x-yaml.

declare const application: appconfig.Application;

new appconfig.HostedConfiguration(this, 'MyHostedConfiguration', {
  application,
  content: appconfig.ConfigurationContent.fromInlineYaml('MyConfig: This is my content.'),
});

# application: appconfig.Application


appconfig.HostedConfiguration(self, "MyHostedConfiguration",
    application=application,
    content=appconfig.ConfigurationContent.from_inline_yaml("MyConfig: This is my content.")
)

Application application;


HostedConfiguration.Builder.create(this, "MyHostedConfiguration")
        .application(application)
        .content(ConfigurationContent.fromInlineYaml("MyConfig: This is my content."))
        .build();

Application application;


new HostedConfiguration(this, "MyHostedConfiguration", new HostedConfigurationProps {
    Application = application,
    Content = ConfigurationContent.FromInlineYaml("MyConfig: This is my content.")
});

var application Application


appconfig.NewHostedConfiguration(this, jsii.String("MyHostedConfiguration"), &HostedConfigurationProps{
	Application: Application,
	Content: appconfig.ConfigurationContent_FromInlineYaml(jsii.String("MyConfig: This is my content.")),
})

• fromInline - Defines the hosted configuration from user-specified content types. The content type will be set as application/octet-stream unless specified.

declare const application: appconfig.Application;

new appconfig.HostedConfiguration(this, 'MyHostedConfiguration', {
  application,
  content: appconfig.ConfigurationContent.fromInline('This is my configuration content.'),
});

# application: appconfig.Application


appconfig.HostedConfiguration(self, "MyHostedConfiguration",
    application=application,
    content=appconfig.ConfigurationContent.from_inline("This is my configuration content.")
)

Application application;


HostedConfiguration.Builder.create(this, "MyHostedConfiguration")
        .application(application)
        .content(ConfigurationContent.fromInline("This is my configuration content."))
        .build();

Application application;


new HostedConfiguration(this, "MyHostedConfiguration", new HostedConfigurationProps {
    Application = application,
    Content = ConfigurationContent.FromInline("This is my configuration content.")
});

var application Application


appconfig.NewHostedConfiguration(this, jsii.String("MyHostedConfiguration"), &HostedConfigurationProps{
	Application: Application,
	Content: appconfig.ConfigurationContent_FromInline(jsii.String("This is my configuration content.")),
})

AWS AppConfig supports the following types of configuration profiles.

• Feature flag: Use a feature flag configuration to turn on new features that require a timely deployment, such as a product launch or announcement.
• Freeform: Use a freeform configuration to carefully introduce changes to your application.

A hosted configuration with type:

declare const application: appconfig.Application;

new appconfig.HostedConfiguration(this, 'MyHostedConfiguration', {
  application,
  content: appconfig.ConfigurationContent.fromInlineText('This is my configuration content.'),
  type: appconfig.ConfigurationType.FEATURE_FLAGS,
});

# application: appconfig.Application


appconfig.HostedConfiguration(self, "MyHostedConfiguration",
    application=application,
    content=appconfig.ConfigurationContent.from_inline_text("This is my configuration content."),
    type=appconfig.ConfigurationType.FEATURE_FLAGS
)

Application application;


HostedConfiguration.Builder.create(this, "MyHostedConfiguration")
        .application(application)
        .content(ConfigurationContent.fromInlineText("This is my configuration content."))
        .type(ConfigurationType.FEATURE_FLAGS)
        .build();

Application application;


new HostedConfiguration(this, "MyHostedConfiguration", new HostedConfigurationProps {
    Application = application,
    Content = ConfigurationContent.FromInlineText("This is my configuration content."),
    Type = ConfigurationType.FEATURE_FLAGS
});

var application Application


appconfig.NewHostedConfiguration(this, jsii.String("MyHostedConfiguration"), &HostedConfigurationProps{
	Application: Application,
	Content: appconfig.ConfigurationContent_FromInlineText(jsii.String("This is my configuration content.")),
	Type: appconfig.ConfigurationType_FEATURE_FLAGS,
})

When you create a configuration and configuration profile, you can specify up to two validators. A validator ensures that your configuration data is syntactically and semantically correct. You can create validators in either JSON Schema or as an AWS Lambda function. See About validators for more information.

When you import a JSON Schema validator from a file, you can pass in a relative path.

A hosted configuration with validators:

declare const application: appconfig.Application;
declare const fn: lambda.Function;

new appconfig.HostedConfiguration(this, 'MyHostedConfiguration', {
  application,
  content: appconfig.ConfigurationContent.fromInlineText('This is my configuration content.'),
  validators: [
    appconfig.JsonSchemaValidator.fromFile('schema.json'),
    appconfig.LambdaValidator.fromFunction(fn),
  ],
});

# application: appconfig.Application
# fn: lambda.Function


appconfig.HostedConfiguration(self, "MyHostedConfiguration",
    application=application,
    content=appconfig.ConfigurationContent.from_inline_text("This is my configuration content."),
    validators=[
        appconfig.JsonSchemaValidator.from_file("schema.json"),
        appconfig.LambdaValidator.from_function(fn)
    ]
)

Application application;
Function fn;


HostedConfiguration.Builder.create(this, "MyHostedConfiguration")
        .application(application)
        .content(ConfigurationContent.fromInlineText("This is my configuration content."))
        .validators(List.of(JsonSchemaValidator.fromFile("schema.json"), LambdaValidator.fromFunction(fn)))
        .build();

Application application;
Function fn;


new HostedConfiguration(this, "MyHostedConfiguration", new HostedConfigurationProps {
    Application = application,
    Content = ConfigurationContent.FromInlineText("This is my configuration content."),
    Validators = new [] { JsonSchemaValidator.FromFile("schema.json"), LambdaValidator.FromFunction(fn) }
});

var application Application
var fn Function


appconfig.NewHostedConfiguration(this, jsii.String("MyHostedConfiguration"), &HostedConfigurationProps{
	Application: Application,
	Content: appconfig.ConfigurationContent_FromInlineText(jsii.String("This is my configuration content.")),
	Validators: []IValidator{
		appconfig.JsonSchemaValidator_FromFile(jsii.String("schema.json")),
		appconfig.LambdaValidator_FromFunction(fn),
	},
})

You can attach a deployment strategy (as described in the previous section) to your configuration to specify how you want your configuration to roll out.

A hosted configuration with a deployment strategy:

declare const application: appconfig.Application;

new appconfig.HostedConfiguration(this, 'MyHostedConfiguration', {
  application,
  content: appconfig.ConfigurationContent.fromInlineText('This is my configuration content.'),
  deploymentStrategy: new appconfig.DeploymentStrategy(this, 'MyDeploymentStrategy', {
    rolloutStrategy: appconfig.RolloutStrategy.linear({
      growthFactor: 15,
      deploymentDuration: Duration.minutes(30),
      finalBakeTime: Duration.minutes(15),
    }),
  }),
});

# application: appconfig.Application


appconfig.HostedConfiguration(self, "MyHostedConfiguration",
    application=application,
    content=appconfig.ConfigurationContent.from_inline_text("This is my configuration content."),
    deployment_strategy=appconfig.DeploymentStrategy(self, "MyDeploymentStrategy",
        rollout_strategy=appconfig.RolloutStrategy.linear(
            growth_factor=15,
            deployment_duration=Duration.minutes(30),
            final_bake_time=Duration.minutes(15)
        )
    )
)

Application application;


HostedConfiguration.Builder.create(this, "MyHostedConfiguration")
        .application(application)
        .content(ConfigurationContent.fromInlineText("This is my configuration content."))
        .deploymentStrategy(DeploymentStrategy.Builder.create(this, "MyDeploymentStrategy")
                .rolloutStrategy(RolloutStrategy.linear(RolloutStrategyProps.builder()
                        .growthFactor(15)
                        .deploymentDuration(Duration.minutes(30))
                        .finalBakeTime(Duration.minutes(15))
                        .build()))
                .build())
        .build();

Application application;


new HostedConfiguration(this, "MyHostedConfiguration", new HostedConfigurationProps {
    Application = application,
    Content = ConfigurationContent.FromInlineText("This is my configuration content."),
    DeploymentStrategy = new DeploymentStrategy(this, "MyDeploymentStrategy", new DeploymentStrategyProps {
        RolloutStrategy = RolloutStrategy.Linear(new RolloutStrategyProps {
            GrowthFactor = 15,
            DeploymentDuration = Duration.Minutes(30),
            FinalBakeTime = Duration.Minutes(15)
        })
    })
});

var application Application


appconfig.NewHostedConfiguration(this, jsii.String("MyHostedConfiguration"), &HostedConfigurationProps{
	Application: Application,
	Content: appconfig.ConfigurationContent_FromInlineText(jsii.String("This is my configuration content.")),
	DeploymentStrategy: appconfig.NewDeploymentStrategy(this, jsii.String("MyDeploymentStrategy"), &DeploymentStrategyProps{
		RolloutStrategy: appconfig.RolloutStrategy_Linear(&RolloutStrategyProps{
			GrowthFactor: jsii.Number(15),
			DeploymentDuration: awscdk.Duration_Minutes(jsii.Number(30)),
			FinalBakeTime: awscdk.Duration_*Minutes(jsii.Number(15)),
		}),
	}),
})

The deployTo parameter is used to specify which environments to deploy the configuration to.

A hosted configuration with deployTo:

declare const application: appconfig.Application;
declare const env: appconfig.Environment;

new appconfig.HostedConfiguration(this, 'MyHostedConfiguration', {
  application,
  content: appconfig.ConfigurationContent.fromInlineText('This is my configuration content.'),
  deployTo: [env],
});

# application: appconfig.Application
# env: appconfig.Environment


appconfig.HostedConfiguration(self, "MyHostedConfiguration",
    application=application,
    content=appconfig.ConfigurationContent.from_inline_text("This is my configuration content."),
    deploy_to=[env]
)

Application application;
Environment env;


HostedConfiguration.Builder.create(this, "MyHostedConfiguration")
        .application(application)
        .content(ConfigurationContent.fromInlineText("This is my configuration content."))
        .deployTo(List.of(env))
        .build();

Application application;
Environment env;


new HostedConfiguration(this, "MyHostedConfiguration", new HostedConfigurationProps {
    Application = application,
    Content = ConfigurationContent.FromInlineText("This is my configuration content."),
    DeployTo = new [] { env }
});

var application Application
var env Environment


appconfig.NewHostedConfiguration(this, jsii.String("MyHostedConfiguration"), &HostedConfigurationProps{
	Application: Application,
	Content: appconfig.ConfigurationContent_FromInlineText(jsii.String("This is my configuration content.")),
	DeployTo: []IEnvironment{
		env,
	},
})

When more than one configuration is set to deploy to the same environment, the deployments will occur one at a time. This is done to satisfy AppConfig's constraint:

NOTE

You can only deploy one configuration at a time to an environment. However, you can deploy one configuration each to different environments at the same time.

The deployment order matches the order in which the configurations are declared.

const app = new appconfig.Application(this, 'MyApp');
const env = new appconfig.Environment(this, 'MyEnv', {
  application: app,
});

new appconfig.HostedConfiguration(this, 'MyFirstHostedConfig', {
  application: app,
  deployTo: [env],
  content: appconfig.ConfigurationContent.fromInlineText('This is my first configuration content.'),
});

new appconfig.HostedConfiguration(this, 'MySecondHostedConfig', {
  application: app,
  deployTo: [env],
  content: appconfig.ConfigurationContent.fromInlineText('This is my second configuration content.'),
});

app = appconfig.Application(self, "MyApp")
env = appconfig.Environment(self, "MyEnv",
    application=app
)

appconfig.HostedConfiguration(self, "MyFirstHostedConfig",
    application=app,
    deploy_to=[env],
    content=appconfig.ConfigurationContent.from_inline_text("This is my first configuration content.")
)

appconfig.HostedConfiguration(self, "MySecondHostedConfig",
    application=app,
    deploy_to=[env],
    content=appconfig.ConfigurationContent.from_inline_text("This is my second configuration content.")
)

Application app = new Application(this, "MyApp");
Environment env = Environment.Builder.create(this, "MyEnv")
        .application(app)
        .build();

HostedConfiguration.Builder.create(this, "MyFirstHostedConfig")
        .application(app)
        .deployTo(List.of(env))
        .content(ConfigurationContent.fromInlineText("This is my first configuration content."))
        .build();

HostedConfiguration.Builder.create(this, "MySecondHostedConfig")
        .application(app)
        .deployTo(List.of(env))
        .content(ConfigurationContent.fromInlineText("This is my second configuration content."))
        .build();

var app = new Application(this, "MyApp");
var env = new Environment(this, "MyEnv", new EnvironmentProps {
    Application = app
});

new HostedConfiguration(this, "MyFirstHostedConfig", new HostedConfigurationProps {
    Application = app,
    DeployTo = new [] { env },
    Content = ConfigurationContent.FromInlineText("This is my first configuration content.")
});

new HostedConfiguration(this, "MySecondHostedConfig", new HostedConfigurationProps {
    Application = app,
    DeployTo = new [] { env },
    Content = ConfigurationContent.FromInlineText("This is my second configuration content.")
});

app := appconfig.NewApplication(this, jsii.String("MyApp"))
env := appconfig.NewEnvironment(this, jsii.String("MyEnv"), &EnvironmentProps{
	Application: app,
})

appconfig.NewHostedConfiguration(this, jsii.String("MyFirstHostedConfig"), &HostedConfigurationProps{
	Application: app,
	DeployTo: []IEnvironment{
		env,
	},
	Content: appconfig.ConfigurationContent_FromInlineText(jsii.String("This is my first configuration content.")),
})

appconfig.NewHostedConfiguration(this, jsii.String("MySecondHostedConfig"), &HostedConfigurationProps{
	Application: app,
	DeployTo: []IEnvironment{
		env,
	},
	Content: appconfig.ConfigurationContent_*FromInlineText(jsii.String("This is my second configuration content.")),
})

If an application would benefit from a deployment order that differs from the declared order, you can defer the decision by using IEnvironment.addDeployment rather than the deployTo property. In this example, firstConfig will be deployed before secondConfig.

const app = new appconfig.Application(this, 'MyApp');
const env = new appconfig.Environment(this, 'MyEnv', {
  application: app,
});

const secondConfig = new appconfig.HostedConfiguration(this, 'MySecondHostedConfig', {
  application: app,
  content: appconfig.ConfigurationContent.fromInlineText('This is my second configuration content.'),
});

const firstConfig = new appconfig.HostedConfiguration(this, 'MyFirstHostedConfig', {
  application: app,
  deployTo: [env],
  content: appconfig.ConfigurationContent.fromInlineText('This is my first configuration content.'),
});

env.addDeployment(secondConfig);

app = appconfig.Application(self, "MyApp")
env = appconfig.Environment(self, "MyEnv",
    application=app
)

second_config = appconfig.HostedConfiguration(self, "MySecondHostedConfig",
    application=app,
    content=appconfig.ConfigurationContent.from_inline_text("This is my second configuration content.")
)

first_config = appconfig.HostedConfiguration(self, "MyFirstHostedConfig",
    application=app,
    deploy_to=[env],
    content=appconfig.ConfigurationContent.from_inline_text("This is my first configuration content.")
)

env.add_deployment(second_config)

Application app = new Application(this, "MyApp");
Environment env = Environment.Builder.create(this, "MyEnv")
        .application(app)
        .build();

HostedConfiguration secondConfig = HostedConfiguration.Builder.create(this, "MySecondHostedConfig")
        .application(app)
        .content(ConfigurationContent.fromInlineText("This is my second configuration content."))
        .build();

HostedConfiguration firstConfig = HostedConfiguration.Builder.create(this, "MyFirstHostedConfig")
        .application(app)
        .deployTo(List.of(env))
        .content(ConfigurationContent.fromInlineText("This is my first configuration content."))
        .build();

env.addDeployment(secondConfig);

var app = new Application(this, "MyApp");
var env = new Environment(this, "MyEnv", new EnvironmentProps {
    Application = app
});

var secondConfig = new HostedConfiguration(this, "MySecondHostedConfig", new HostedConfigurationProps {
    Application = app,
    Content = ConfigurationContent.FromInlineText("This is my second configuration content.")
});

var firstConfig = new HostedConfiguration(this, "MyFirstHostedConfig", new HostedConfigurationProps {
    Application = app,
    DeployTo = new [] { env },
    Content = ConfigurationContent.FromInlineText("This is my first configuration content.")
});

env.AddDeployment(secondConfig);

app := appconfig.NewApplication(this, jsii.String("MyApp"))
env := appconfig.NewEnvironment(this, jsii.String("MyEnv"), &EnvironmentProps{
	Application: app,
})

secondConfig := appconfig.NewHostedConfiguration(this, jsii.String("MySecondHostedConfig"), &HostedConfigurationProps{
	Application: app,
	Content: appconfig.ConfigurationContent_FromInlineText(jsii.String("This is my second configuration content.")),
})

firstConfig := appconfig.NewHostedConfiguration(this, jsii.String("MyFirstHostedConfig"), &HostedConfigurationProps{
	Application: app,
	DeployTo: []IEnvironment{
		env,
	},
	Content: appconfig.ConfigurationContent_*FromInlineText(jsii.String("This is my first configuration content.")),
})

env.addDeployment(secondConfig)

Alternatively, you can defer multiple deployments in favor of IEnvironment.addDeployments, which allows you to declare multiple configurations in the order they will be deployed. In this example the deployment order will be firstConfig, then secondConfig, and finally thirdConfig.

const app = new appconfig.Application(this, 'MyApp');
const env = new appconfig.Environment(this, 'MyEnv', {
  application: app,
});

const secondConfig = new appconfig.HostedConfiguration(this, 'MySecondHostedConfig', {
  application: app,
  content: appconfig.ConfigurationContent.fromInlineText('This is my second configuration content.'),
});

const thirdConfig = new appconfig.HostedConfiguration(this, 'MyThirdHostedConfig', {
  application: app,
  content: appconfig.ConfigurationContent.fromInlineText('This is my third configuration content.'),
});

const firstConfig = new appconfig.HostedConfiguration(this, 'MyFirstHostedConfig', {
  application: app,
  content: appconfig.ConfigurationContent.fromInlineText('This is my first configuration content.'),
});

env.addDeployments(firstConfig, secondConfig, thirdConfig);

app = appconfig.Application(self, "MyApp")
env = appconfig.Environment(self, "MyEnv",
    application=app
)

second_config = appconfig.HostedConfiguration(self, "MySecondHostedConfig",
    application=app,
    content=appconfig.ConfigurationContent.from_inline_text("This is my second configuration content.")
)

third_config = appconfig.HostedConfiguration(self, "MyThirdHostedConfig",
    application=app,
    content=appconfig.ConfigurationContent.from_inline_text("This is my third configuration content.")
)

first_config = appconfig.HostedConfiguration(self, "MyFirstHostedConfig",
    application=app,
    content=appconfig.ConfigurationContent.from_inline_text("This is my first configuration content.")
)

env.add_deployments(first_config, second_config, third_config)

Application app = new Application(this, "MyApp");
Environment env = Environment.Builder.create(this, "MyEnv")
        .application(app)
        .build();

HostedConfiguration secondConfig = HostedConfiguration.Builder.create(this, "MySecondHostedConfig")
        .application(app)
        .content(ConfigurationContent.fromInlineText("This is my second configuration content."))
        .build();

HostedConfiguration thirdConfig = HostedConfiguration.Builder.create(this, "MyThirdHostedConfig")
        .application(app)
        .content(ConfigurationContent.fromInlineText("This is my third configuration content."))
        .build();

HostedConfiguration firstConfig = HostedConfiguration.Builder.create(this, "MyFirstHostedConfig")
        .application(app)
        .content(ConfigurationContent.fromInlineText("This is my first configuration content."))
        .build();

env.addDeployments(firstConfig, secondConfig, thirdConfig);

var app = new Application(this, "MyApp");
var env = new Environment(this, "MyEnv", new EnvironmentProps {
    Application = app
});

var secondConfig = new HostedConfiguration(this, "MySecondHostedConfig", new HostedConfigurationProps {
    Application = app,
    Content = ConfigurationContent.FromInlineText("This is my second configuration content.")
});

var thirdConfig = new HostedConfiguration(this, "MyThirdHostedConfig", new HostedConfigurationProps {
    Application = app,
    Content = ConfigurationContent.FromInlineText("This is my third configuration content.")
});

var firstConfig = new HostedConfiguration(this, "MyFirstHostedConfig", new HostedConfigurationProps {
    Application = app,
    Content = ConfigurationContent.FromInlineText("This is my first configuration content.")
});

env.AddDeployments(firstConfig, secondConfig, thirdConfig);

app := appconfig.NewApplication(this, jsii.String("MyApp"))
env := appconfig.NewEnvironment(this, jsii.String("MyEnv"), &EnvironmentProps{
	Application: app,
})

secondConfig := appconfig.NewHostedConfiguration(this, jsii.String("MySecondHostedConfig"), &HostedConfigurationProps{
	Application: app,
	Content: appconfig.ConfigurationContent_FromInlineText(jsii.String("This is my second configuration content.")),
})

thirdConfig := appconfig.NewHostedConfiguration(this, jsii.String("MyThirdHostedConfig"), &HostedConfigurationProps{
	Application: app,
	Content: appconfig.ConfigurationContent_*FromInlineText(jsii.String("This is my third configuration content.")),
})

firstConfig := appconfig.NewHostedConfiguration(this, jsii.String("MyFirstHostedConfig"), &HostedConfigurationProps{
	Application: app,
	Content: appconfig.ConfigurationContent_*FromInlineText(jsii.String("This is my first configuration content.")),
})

env.addDeployments(firstConfig, secondConfig, thirdConfig)

Any mix of deployTo, addDeployment, and addDeployments is permitted. The declaration order will be respected regardless of the approach used.

IMPORTANT

If none of these options are utilized, there will not be any deployments.

You can use customer managed key to encrypt a hosted configuration. For mora information, see Data encryption at rest for AWS AppConfig.

declare const application: appconfig.Application;
declare const kmsKey: kms.Key;

new appconfig.HostedConfiguration(this, 'MyHostedConfiguration', {
  application,
  content: appconfig.ConfigurationContent.fromInlineText('This is my configuration content.'),
  type: appconfig.ConfigurationType.FEATURE_FLAGS,
  kmsKey, // set customer managed key
});

# application: appconfig.Application
# kms_key: kms.Key


appconfig.HostedConfiguration(self, "MyHostedConfiguration",
    application=application,
    content=appconfig.ConfigurationContent.from_inline_text("This is my configuration content."),
    type=appconfig.ConfigurationType.FEATURE_FLAGS,
    kms_key=kms_key
)

Application application;
Key kmsKey;


HostedConfiguration.Builder.create(this, "MyHostedConfiguration")
        .application(application)
        .content(ConfigurationContent.fromInlineText("This is my configuration content."))
        .type(ConfigurationType.FEATURE_FLAGS)
        .kmsKey(kmsKey)
        .build();

Application application;
Key kmsKey;


new HostedConfiguration(this, "MyHostedConfiguration", new HostedConfigurationProps {
    Application = application,
    Content = ConfigurationContent.FromInlineText("This is my configuration content."),
    Type = ConfigurationType.FEATURE_FLAGS,
    KmsKey = kmsKey
});

var application Application
var kmsKey Key


appconfig.NewHostedConfiguration(this, jsii.String("MyHostedConfiguration"), &HostedConfigurationProps{
	Application: Application,
	Content: appconfig.ConfigurationContent_FromInlineText(jsii.String("This is my configuration content.")),
	Type: appconfig.ConfigurationType_FEATURE_FLAGS,
	KmsKey: KmsKey,
})

SourcedConfiguration

A sourced configuration represents configuration stored in any of the following:

• Amazon S3 bucket
• AWS Secrets Manager secret
• Systems Manager
• (SSM) Parameter Store parameter
• SSM document
• AWS CodePipeline.

A sourced configuration takes in the location source construct and optionally a version number to deploy. On construction of a sourced configuration, the configuration is deployed only if a version number is specified.

S3

Use an Amazon S3 bucket to store a configuration.

declare const application: appconfig.Application;

const bucket = new s3.Bucket(this, 'MyBucket', {
  versioned: true,
});

new appconfig.SourcedConfiguration(this, 'MySourcedConfiguration', {
  application,
  location: appconfig.ConfigurationSource.fromBucket(bucket, 'path/to/file.json'),
});

# application: appconfig.Application


bucket = s3.Bucket(self, "MyBucket",
    versioned=True
)

appconfig.SourcedConfiguration(self, "MySourcedConfiguration",
    application=application,
    location=appconfig.ConfigurationSource.from_bucket(bucket, "path/to/file.json")
)

Application application;


Bucket bucket = Bucket.Builder.create(this, "MyBucket")
        .versioned(true)
        .build();

SourcedConfiguration.Builder.create(this, "MySourcedConfiguration")
        .application(application)
        .location(ConfigurationSource.fromBucket(bucket, "path/to/file.json"))
        .build();

Application application;


var bucket = new Bucket(this, "MyBucket", new BucketProps {
    Versioned = true
});

new SourcedConfiguration(this, "MySourcedConfiguration", new SourcedConfigurationProps {
    Application = application,
    Location = ConfigurationSource.FromBucket(bucket, "path/to/file.json")
});

var application Application


bucket := s3.NewBucket(this, jsii.String("MyBucket"), &BucketProps{
	Versioned: jsii.Boolean(true),
})

appconfig.NewSourcedConfiguration(this, jsii.String("MySourcedConfiguration"), &SourcedConfigurationProps{
	Application: Application,
	Location: appconfig.ConfigurationSource_FromBucket(bucket, jsii.String("path/to/file.json")),
})

Use an encrypted bucket:

declare const application: appconfig.Application;

const bucket = new s3.Bucket(this, 'MyBucket', {
  versioned: true,
  encryption: s3.BucketEncryption.KMS,
});

new appconfig.SourcedConfiguration(this, 'MySourcedConfiguration', {
  application,
  location: appconfig.ConfigurationSource.fromBucket(bucket, 'path/to/file.json'),
});

# application: appconfig.Application


bucket = s3.Bucket(self, "MyBucket",
    versioned=True,
    encryption=s3.BucketEncryption.KMS
)

appconfig.SourcedConfiguration(self, "MySourcedConfiguration",
    application=application,
    location=appconfig.ConfigurationSource.from_bucket(bucket, "path/to/file.json")
)

Application application;


Bucket bucket = Bucket.Builder.create(this, "MyBucket")
        .versioned(true)
        .encryption(BucketEncryption.KMS)
        .build();

SourcedConfiguration.Builder.create(this, "MySourcedConfiguration")
        .application(application)
        .location(ConfigurationSource.fromBucket(bucket, "path/to/file.json"))
        .build();

Application application;


var bucket = new Bucket(this, "MyBucket", new BucketProps {
    Versioned = true,
    Encryption = BucketEncryption.KMS
});

new SourcedConfiguration(this, "MySourcedConfiguration", new SourcedConfigurationProps {
    Application = application,
    Location = ConfigurationSource.FromBucket(bucket, "path/to/file.json")
});

var application Application


bucket := s3.NewBucket(this, jsii.String("MyBucket"), &BucketProps{
	Versioned: jsii.Boolean(true),
	Encryption: s3.BucketEncryption_KMS,
})

appconfig.NewSourcedConfiguration(this, jsii.String("MySourcedConfiguration"), &SourcedConfigurationProps{
	Application: Application,
	Location: appconfig.ConfigurationSource_FromBucket(bucket, jsii.String("path/to/file.json")),
})

AWS Secrets Manager secret

Use a Secrets Manager secret to store a configuration.

declare const application: appconfig.Application;
declare const secret: secrets.Secret;

new appconfig.SourcedConfiguration(this, 'MySourcedConfiguration', {
  application,
  location: appconfig.ConfigurationSource.fromSecret(secret),
});

# application: appconfig.Application
# secret: secrets.Secret


appconfig.SourcedConfiguration(self, "MySourcedConfiguration",
    application=application,
    location=appconfig.ConfigurationSource.from_secret(secret)
)

Application application;
Secret secret;


SourcedConfiguration.Builder.create(this, "MySourcedConfiguration")
        .application(application)
        .location(ConfigurationSource.fromSecret(secret))
        .build();

Application application;
Secret secret;


new SourcedConfiguration(this, "MySourcedConfiguration", new SourcedConfigurationProps {
    Application = application,
    Location = ConfigurationSource.FromSecret(secret)
});

var application Application
var secret Secret


appconfig.NewSourcedConfiguration(this, jsii.String("MySourcedConfiguration"), &SourcedConfigurationProps{
	Application: Application,
	Location: appconfig.ConfigurationSource_FromSecret(secret),
})

SSM Parameter Store parameter

Use an SSM parameter to store a configuration.

declare const application: appconfig.Application;
declare const parameter: ssm.StringParameter;

new appconfig.SourcedConfiguration(this, 'MySourcedConfiguration', {
  application,
  location: appconfig.ConfigurationSource.fromParameter(parameter),
  versionNumber: '1',
});

# application: appconfig.Application
# parameter: ssm.StringParameter


appconfig.SourcedConfiguration(self, "MySourcedConfiguration",
    application=application,
    location=appconfig.ConfigurationSource.from_parameter(parameter),
    version_number="1"
)

Application application;
StringParameter parameter;


SourcedConfiguration.Builder.create(this, "MySourcedConfiguration")
        .application(application)
        .location(ConfigurationSource.fromParameter(parameter))
        .versionNumber("1")
        .build();

Application application;
StringParameter parameter;


new SourcedConfiguration(this, "MySourcedConfiguration", new SourcedConfigurationProps {
    Application = application,
    Location = ConfigurationSource.FromParameter(parameter),
    VersionNumber = "1"
});

var application Application
var parameter StringParameter


appconfig.NewSourcedConfiguration(this, jsii.String("MySourcedConfiguration"), &SourcedConfigurationProps{
	Application: Application,
	Location: appconfig.ConfigurationSource_FromParameter(parameter),
	VersionNumber: jsii.String("1"),
})

SSM document

Use an SSM document to store a configuration.

declare const application: appconfig.Application;
declare const document: ssm.CfnDocument;

new appconfig.SourcedConfiguration(this, 'MySourcedConfiguration', {
  application,
  location: appconfig.ConfigurationSource.fromCfnDocument(document),
});

# application: appconfig.Application
# document: ssm.CfnDocument


appconfig.SourcedConfiguration(self, "MySourcedConfiguration",
    application=application,
    location=appconfig.ConfigurationSource.from_cfn_document(document)
)

Application application;
CfnDocument document;


SourcedConfiguration.Builder.create(this, "MySourcedConfiguration")
        .application(application)
        .location(ConfigurationSource.fromCfnDocument(document))
        .build();

Application application;
CfnDocument document;


new SourcedConfiguration(this, "MySourcedConfiguration", new SourcedConfigurationProps {
    Application = application,
    Location = ConfigurationSource.FromCfnDocument(document)
});

var application Application
var document CfnDocument


appconfig.NewSourcedConfiguration(this, jsii.String("MySourcedConfiguration"), &SourcedConfigurationProps{
	Application: Application,
	Location: appconfig.ConfigurationSource_FromCfnDocument(document),
})

AWS CodePipeline

Use an AWS CodePipeline pipeline to store a configuration.

declare const application: appconfig.Application;
declare const pipeline: codepipeline.Pipeline;

new appconfig.SourcedConfiguration(this, 'MySourcedConfiguration', {
  application,
  location: appconfig.ConfigurationSource.fromPipeline(pipeline),
});

# application: appconfig.Application
# pipeline: codepipeline.Pipeline


appconfig.SourcedConfiguration(self, "MySourcedConfiguration",
    application=application,
    location=appconfig.ConfigurationSource.from_pipeline(pipeline)
)

Application application;
Pipeline pipeline;


SourcedConfiguration.Builder.create(this, "MySourcedConfiguration")
        .application(application)
        .location(ConfigurationSource.fromPipeline(pipeline))
        .build();

Application application;
Pipeline pipeline;


new SourcedConfiguration(this, "MySourcedConfiguration", new SourcedConfigurationProps {
    Application = application,
    Location = ConfigurationSource.FromPipeline(pipeline)
});

var application Application
var pipeline Pipeline


appconfig.NewSourcedConfiguration(this, jsii.String("MySourcedConfiguration"), &SourcedConfigurationProps{
	Application: Application,
	Location: appconfig.ConfigurationSource_FromPipeline(pipeline),
})

Similar to a hosted configuration, a sourced configuration can optionally take in a type, validators, a deployTo parameter, and a deployment strategy.

A sourced configuration with type:

declare const application: appconfig.Application;
declare const bucket: s3.Bucket;

new appconfig.SourcedConfiguration(this, 'MySourcedConfiguration', {
  application,
  location: appconfig.ConfigurationSource.fromBucket(bucket, 'path/to/file.json'),
  type: appconfig.ConfigurationType.FEATURE_FLAGS,
  name: 'MyConfig',
  description: 'This is my sourced configuration from CDK.',
});

# application: appconfig.Application
# bucket: s3.Bucket


appconfig.SourcedConfiguration(self, "MySourcedConfiguration",
    application=application,
    location=appconfig.ConfigurationSource.from_bucket(bucket, "path/to/file.json"),
    type=appconfig.ConfigurationType.FEATURE_FLAGS,
    name="MyConfig",
    description="This is my sourced configuration from CDK."
)

Application application;
Bucket bucket;


SourcedConfiguration.Builder.create(this, "MySourcedConfiguration")
        .application(application)
        .location(ConfigurationSource.fromBucket(bucket, "path/to/file.json"))
        .type(ConfigurationType.FEATURE_FLAGS)
        .name("MyConfig")
        .description("This is my sourced configuration from CDK.")
        .build();

Application application;
Bucket bucket;


new SourcedConfiguration(this, "MySourcedConfiguration", new SourcedConfigurationProps {
    Application = application,
    Location = ConfigurationSource.FromBucket(bucket, "path/to/file.json"),
    Type = ConfigurationType.FEATURE_FLAGS,
    Name = "MyConfig",
    Description = "This is my sourced configuration from CDK."
});

var application Application
var bucket Bucket


appconfig.NewSourcedConfiguration(this, jsii.String("MySourcedConfiguration"), &SourcedConfigurationProps{
	Application: Application,
	Location: appconfig.ConfigurationSource_FromBucket(bucket, jsii.String("path/to/file.json")),
	Type: appconfig.ConfigurationType_FEATURE_FLAGS,
	Name: jsii.String("MyConfig"),
	Description: jsii.String("This is my sourced configuration from CDK."),
})

A sourced configuration with validators:

declare const application: appconfig.Application;
declare const bucket: s3.Bucket;
declare const fn: lambda.Function;

new appconfig.SourcedConfiguration(this, 'MySourcedConfiguration', {
  application,
  location: appconfig.ConfigurationSource.fromBucket(bucket, 'path/to/file.json'),
  validators: [
    appconfig.JsonSchemaValidator.fromFile('schema.json'),
    appconfig.LambdaValidator.fromFunction(fn),
  ],
});

# application: appconfig.Application
# bucket: s3.Bucket
# fn: lambda.Function


appconfig.SourcedConfiguration(self, "MySourcedConfiguration",
    application=application,
    location=appconfig.ConfigurationSource.from_bucket(bucket, "path/to/file.json"),
    validators=[
        appconfig.JsonSchemaValidator.from_file("schema.json"),
        appconfig.LambdaValidator.from_function(fn)
    ]
)

Application application;
Bucket bucket;
Function fn;


SourcedConfiguration.Builder.create(this, "MySourcedConfiguration")
        .application(application)
        .location(ConfigurationSource.fromBucket(bucket, "path/to/file.json"))
        .validators(List.of(JsonSchemaValidator.fromFile("schema.json"), LambdaValidator.fromFunction(fn)))
        .build();

Application application;
Bucket bucket;
Function fn;


new SourcedConfiguration(this, "MySourcedConfiguration", new SourcedConfigurationProps {
    Application = application,
    Location = ConfigurationSource.FromBucket(bucket, "path/to/file.json"),
    Validators = new [] { JsonSchemaValidator.FromFile("schema.json"), LambdaValidator.FromFunction(fn) }
});

var application Application
var bucket Bucket
var fn Function


appconfig.NewSourcedConfiguration(this, jsii.String("MySourcedConfiguration"), &SourcedConfigurationProps{
	Application: Application,
	Location: appconfig.ConfigurationSource_FromBucket(bucket, jsii.String("path/to/file.json")),
	Validators: []IValidator{
		appconfig.JsonSchemaValidator_FromFile(jsii.String("schema.json")),
		appconfig.LambdaValidator_FromFunction(fn),
	},
})

A sourced configuration with a deployment strategy:

declare const application: appconfig.Application;
declare const bucket: s3.Bucket;

new appconfig.SourcedConfiguration(this, 'MySourcedConfiguration', {
  application,
  location: appconfig.ConfigurationSource.fromBucket(bucket, 'path/to/file.json'),
  deploymentStrategy: new appconfig.DeploymentStrategy(this, 'MyDeploymentStrategy', {
    rolloutStrategy: appconfig.RolloutStrategy.linear({
      growthFactor: 15,
      deploymentDuration: Duration.minutes(30),
      finalBakeTime: Duration.minutes(15),
    }),
  }),
});

# application: appconfig.Application
# bucket: s3.Bucket


appconfig.SourcedConfiguration(self, "MySourcedConfiguration",
    application=application,
    location=appconfig.ConfigurationSource.from_bucket(bucket, "path/to/file.json"),
    deployment_strategy=appconfig.DeploymentStrategy(self, "MyDeploymentStrategy",
        rollout_strategy=appconfig.RolloutStrategy.linear(
            growth_factor=15,
            deployment_duration=Duration.minutes(30),
            final_bake_time=Duration.minutes(15)
        )
    )
)

Application application;
Bucket bucket;


SourcedConfiguration.Builder.create(this, "MySourcedConfiguration")
        .application(application)
        .location(ConfigurationSource.fromBucket(bucket, "path/to/file.json"))
        .deploymentStrategy(DeploymentStrategy.Builder.create(this, "MyDeploymentStrategy")
                .rolloutStrategy(RolloutStrategy.linear(RolloutStrategyProps.builder()
                        .growthFactor(15)
                        .deploymentDuration(Duration.minutes(30))
                        .finalBakeTime(Duration.minutes(15))
                        .build()))
                .build())
        .build();

Application application;
Bucket bucket;


new SourcedConfiguration(this, "MySourcedConfiguration", new SourcedConfigurationProps {
    Application = application,
    Location = ConfigurationSource.FromBucket(bucket, "path/to/file.json"),
    DeploymentStrategy = new DeploymentStrategy(this, "MyDeploymentStrategy", new DeploymentStrategyProps {
        RolloutStrategy = RolloutStrategy.Linear(new RolloutStrategyProps {
            GrowthFactor = 15,
            DeploymentDuration = Duration.Minutes(30),
            FinalBakeTime = Duration.Minutes(15)
        })
    })
});

var application Application
var bucket Bucket


appconfig.NewSourcedConfiguration(this, jsii.String("MySourcedConfiguration"), &SourcedConfigurationProps{
	Application: Application,
	Location: appconfig.ConfigurationSource_FromBucket(bucket, jsii.String("path/to/file.json")),
	DeploymentStrategy: appconfig.NewDeploymentStrategy(this, jsii.String("MyDeploymentStrategy"), &DeploymentStrategyProps{
		RolloutStrategy: appconfig.RolloutStrategy_Linear(&RolloutStrategyProps{
			GrowthFactor: jsii.Number(15),
			DeploymentDuration: awscdk.Duration_Minutes(jsii.Number(30)),
			FinalBakeTime: awscdk.Duration_*Minutes(jsii.Number(15)),
		}),
	}),
})

Deletion Protection Check

You can enable deletion protection on the environment and configuration profile by setting the deletionProtectionCheck property.

• ACCOUNT_DEFAULT: The default setting, which uses account-level deletion protection. To configure account-level deletion protection, use the UpdateAccountSettings API.
• APPLY: Instructs the deletion protection check to run, even if deletion protection is disabled at the account level. APPLY also forces the deletion protection check to run against resources created in the past hour, which are normally excluded from deletion protection checks.
• BYPASS: Instructs AWS AppConfig to bypass the deletion protection check and delete an environment even if deletion protection would have otherwise prevented it.

declare const application: appconfig.Application;
declare const alarm: cloudwatch.Alarm;
declare const compositeAlarm: cloudwatch.CompositeAlarm;
declare const bucket: s3.Bucket;

// Environment deletion protection check
new appconfig.Environment(this, 'MyEnvironment', {
  application,
  deletionProtectionCheck: appconfig.DeletionProtectionCheck.APPLY,
});

// configuration profile with deletion protection check
new appconfig.HostedConfiguration(this, 'MyHostedConfigFromFile', {
  application,
  content: appconfig.ConfigurationContent.fromFile('config.json'),
  deletionProtectionCheck: appconfig.DeletionProtectionCheck.BYPASS,
});

new appconfig.SourcedConfiguration(this, 'MySourcedConfiguration', {
  application,
  location: appconfig.ConfigurationSource.fromBucket(bucket, 'path/to/file.json'),
  deletionProtectionCheck: appconfig.DeletionProtectionCheck.ACCOUNT_DEFAULT,
});

# application: appconfig.Application
# alarm: cloudwatch.Alarm
# composite_alarm: cloudwatch.CompositeAlarm
# bucket: s3.Bucket


# Environment deletion protection check
appconfig.Environment(self, "MyEnvironment",
    application=application,
    deletion_protection_check=appconfig.DeletionProtectionCheck.APPLY
)

# configuration profile with deletion protection check
appconfig.HostedConfiguration(self, "MyHostedConfigFromFile",
    application=application,
    content=appconfig.ConfigurationContent.from_file("config.json"),
    deletion_protection_check=appconfig.DeletionProtectionCheck.BYPASS
)

appconfig.SourcedConfiguration(self, "MySourcedConfiguration",
    application=application,
    location=appconfig.ConfigurationSource.from_bucket(bucket, "path/to/file.json"),
    deletion_protection_check=appconfig.DeletionProtectionCheck.ACCOUNT_DEFAULT
)

Application application;
Alarm alarm;
CompositeAlarm compositeAlarm;
Bucket bucket;


// Environment deletion protection check
// Environment deletion protection check
Environment.Builder.create(this, "MyEnvironment")
        .application(application)
        .deletionProtectionCheck(DeletionProtectionCheck.APPLY)
        .build();

// configuration profile with deletion protection check
// configuration profile with deletion protection check
HostedConfiguration.Builder.create(this, "MyHostedConfigFromFile")
        .application(application)
        .content(ConfigurationContent.fromFile("config.json"))
        .deletionProtectionCheck(DeletionProtectionCheck.BYPASS)
        .build();

SourcedConfiguration.Builder.create(this, "MySourcedConfiguration")
        .application(application)
        .location(ConfigurationSource.fromBucket(bucket, "path/to/file.json"))
        .deletionProtectionCheck(DeletionProtectionCheck.ACCOUNT_DEFAULT)
        .build();

Application application;
Alarm alarm;
CompositeAlarm compositeAlarm;
Bucket bucket;


// Environment deletion protection check
// Environment deletion protection check
new Environment(this, "MyEnvironment", new EnvironmentProps {
    Application = application,
    DeletionProtectionCheck = DeletionProtectionCheck.APPLY
});

// configuration profile with deletion protection check
// configuration profile with deletion protection check
new HostedConfiguration(this, "MyHostedConfigFromFile", new HostedConfigurationProps {
    Application = application,
    Content = ConfigurationContent.FromFile("config.json"),
    DeletionProtectionCheck = DeletionProtectionCheck.BYPASS
});

new SourcedConfiguration(this, "MySourcedConfiguration", new SourcedConfigurationProps {
    Application = application,
    Location = ConfigurationSource.FromBucket(bucket, "path/to/file.json"),
    DeletionProtectionCheck = DeletionProtectionCheck.ACCOUNT_DEFAULT
});

var application Application
var alarm Alarm
var compositeAlarm CompositeAlarm
var bucket Bucket


// Environment deletion protection check
// Environment deletion protection check
appconfig.NewEnvironment(this, jsii.String("MyEnvironment"), &EnvironmentProps{
	Application: Application,
	DeletionProtectionCheck: appconfig.DeletionProtectionCheck_APPLY,
})

// configuration profile with deletion protection check
// configuration profile with deletion protection check
appconfig.NewHostedConfiguration(this, jsii.String("MyHostedConfigFromFile"), &HostedConfigurationProps{
	Application: Application,
	Content: appconfig.ConfigurationContent_FromFile(jsii.String("config.json")),
	DeletionProtectionCheck: appconfig.DeletionProtectionCheck_BYPASS,
})

appconfig.NewSourcedConfiguration(this, jsii.String("MySourcedConfiguration"), &SourcedConfigurationProps{
	Application: Application,
	Location: appconfig.ConfigurationSource_FromBucket(bucket, jsii.String("path/to/file.json")),
	DeletionProtectionCheck: appconfig.DeletionProtectionCheck_ACCOUNT_DEFAULT,
})

Extension

An extension augments your ability to inject logic or behavior at different points during the AWS AppConfig workflow of creating or deploying a configuration. You can associate these types of tasks with AWS AppConfig applications, environments, and configuration profiles. See: https://docs.aws.amazon.com/appconfig/latest/userguide/working-with-appconfig-extensions.html

An extension defines one or more actions, that it performs during an AWS AppConfig workflow. Each action is invoked either when you interact with AWS AppConfig or when AWS AppConfig is performing a process on your behalf. These invocation points are called action points. AWS AppConfig extensions support the following action points:

• PRE_START_DEPLOYMENT
• PRE_CREATE_HOSTED_CONFIGURATION_VERSION
• ON_DEPLOYMENT_START
• ON_DEPLOYMENT_STEP
• ON_DEPLOYMENT_BAKING
• ON_DEPLOYMENT_COMPLETE
• ON_DEPLOYMENT_ROLLED_BACK
• AT_DEPLOYMENT_TICK

See: https://docs.aws.amazon.com/appconfig/latest/userguide/working-with-appconfig-extensions-about.html

AWS Lambda destination

Use an AWS Lambda as the event destination for an extension.

declare const fn: lambda.Function;

new appconfig.Extension(this, 'MyExtension', {
  actions: [
    new appconfig.Action({
      actionPoints: [appconfig.ActionPoint.ON_DEPLOYMENT_START],
      eventDestination: new appconfig.LambdaDestination(fn),
    }),
  ],
});

# fn: lambda.Function


appconfig.Extension(self, "MyExtension",
    actions=[
        appconfig.Action(
            action_points=[appconfig.ActionPoint.ON_DEPLOYMENT_START],
            event_destination=appconfig.LambdaDestination(fn)
        )
    ]
)

Function fn;


Extension.Builder.create(this, "MyExtension")
        .actions(List.of(
            Action.Builder.create()
                    .actionPoints(List.of(ActionPoint.ON_DEPLOYMENT_START))
                    .eventDestination(new LambdaDestination(fn))
                    .build()))
        .build();

Function fn;


new Extension(this, "MyExtension", new ExtensionProps {
    Actions = new [] {
        new Action(new ActionProps {
            ActionPoints = new [] { ActionPoint.ON_DEPLOYMENT_START },
            EventDestination = new LambdaDestination(fn)
        }) }
});

var fn Function


appconfig.NewExtension(this, jsii.String("MyExtension"), &ExtensionProps{
	Actions: []Action{
		appconfig.NewAction(&ActionProps{
			ActionPoints: []ActionPoint{
				appconfig.ActionPoint_ON_DEPLOYMENT_START,
			},
			EventDestination: appconfig.NewLambdaDestination(fn),
		}),
	},
})

Lambda extension with parameters:

declare const fn: lambda.Function;

new appconfig.Extension(this, 'MyExtension', {
  actions: [
    new appconfig.Action({
      actionPoints: [appconfig.ActionPoint.ON_DEPLOYMENT_START],
      eventDestination: new appconfig.LambdaDestination(fn),
    }),
  ],
  parameters: [
    appconfig.Parameter.required('testParam', 'true'),
    appconfig.Parameter.notRequired('testNotRequiredParam'),
  ]
});

# fn: lambda.Function


appconfig.Extension(self, "MyExtension",
    actions=[
        appconfig.Action(
            action_points=[appconfig.ActionPoint.ON_DEPLOYMENT_START],
            event_destination=appconfig.LambdaDestination(fn)
        )
    ],
    parameters=[
        appconfig.Parameter.required("testParam", "true"),
        appconfig.Parameter.not_required("testNotRequiredParam")
    ]
)

Function fn;


Extension.Builder.create(this, "MyExtension")
        .actions(List.of(
            Action.Builder.create()
                    .actionPoints(List.of(ActionPoint.ON_DEPLOYMENT_START))
                    .eventDestination(new LambdaDestination(fn))
                    .build()))
        .parameters(List.of(Parameter.required("testParam", "true"), Parameter.notRequired("testNotRequiredParam")))
        .build();

Function fn;


new Extension(this, "MyExtension", new ExtensionProps {
    Actions = new [] {
        new Action(new ActionProps {
            ActionPoints = new [] { ActionPoint.ON_DEPLOYMENT_START },
            EventDestination = new LambdaDestination(fn)
        }) },
    Parameters = new [] { Parameter.Required("testParam", "true"), Parameter.NotRequired("testNotRequiredParam") }
});

var fn Function


appconfig.NewExtension(this, jsii.String("MyExtension"), &ExtensionProps{
	Actions: []Action{
		appconfig.NewAction(&ActionProps{
			ActionPoints: []ActionPoint{
				appconfig.ActionPoint_ON_DEPLOYMENT_START,
			},
			EventDestination: appconfig.NewLambdaDestination(fn),
		}),
	},
	Parameters: []Parameter{
		appconfig.Parameter_Required(jsii.String("testParam"), jsii.String("true")),
		appconfig.Parameter_NotRequired(jsii.String("testNotRequiredParam")),
	},
})

Amazon Simple Queue Service (SQS) destination

Use a queue as the event destination for an extension.

declare const queue: sqs.Queue;

new appconfig.Extension(this, 'MyExtension', {
  actions: [
    new appconfig.Action({
      actionPoints: [appconfig.ActionPoint.ON_DEPLOYMENT_START],
      eventDestination: new appconfig.SqsDestination(queue),
    }),
  ],
});

# queue: sqs.Queue


appconfig.Extension(self, "MyExtension",
    actions=[
        appconfig.Action(
            action_points=[appconfig.ActionPoint.ON_DEPLOYMENT_START],
            event_destination=appconfig.SqsDestination(queue)
        )
    ]
)

Queue queue;


Extension.Builder.create(this, "MyExtension")
        .actions(List.of(
            Action.Builder.create()
                    .actionPoints(List.of(ActionPoint.ON_DEPLOYMENT_START))
                    .eventDestination(new SqsDestination(queue))
                    .build()))
        .build();

Queue queue;


new Extension(this, "MyExtension", new ExtensionProps {
    Actions = new [] {
        new Action(new ActionProps {
            ActionPoints = new [] { ActionPoint.ON_DEPLOYMENT_START },
            EventDestination = new SqsDestination(queue)
        }) }
});

var queue Queue


appconfig.NewExtension(this, jsii.String("MyExtension"), &ExtensionProps{
	Actions: []Action{
		appconfig.NewAction(&ActionProps{
			ActionPoints: []ActionPoint{
				appconfig.ActionPoint_ON_DEPLOYMENT_START,
			},
			EventDestination: appconfig.NewSqsDestination(queue),
		}),
	},
})

Amazon Simple Notification Service (SNS) destination

Use an SNS topic as the event destination for an extension.

declare const topic: sns.Topic;

new appconfig.Extension(this, 'MyExtension', {
  actions: [
    new appconfig.Action({
      actionPoints: [appconfig.ActionPoint.ON_DEPLOYMENT_START],
      eventDestination: new appconfig.SnsDestination(topic),
    }),
  ],
});

# topic: sns.Topic


appconfig.Extension(self, "MyExtension",
    actions=[
        appconfig.Action(
            action_points=[appconfig.ActionPoint.ON_DEPLOYMENT_START],
            event_destination=appconfig.SnsDestination(topic)
        )
    ]
)

Topic topic;


Extension.Builder.create(this, "MyExtension")
        .actions(List.of(
            Action.Builder.create()
                    .actionPoints(List.of(ActionPoint.ON_DEPLOYMENT_START))
                    .eventDestination(new SnsDestination(topic))
                    .build()))
        .build();

Topic topic;


new Extension(this, "MyExtension", new ExtensionProps {
    Actions = new [] {
        new Action(new ActionProps {
            ActionPoints = new [] { ActionPoint.ON_DEPLOYMENT_START },
            EventDestination = new SnsDestination(topic)
        }) }
});

var topic Topic


appconfig.NewExtension(this, jsii.String("MyExtension"), &ExtensionProps{
	Actions: []Action{
		appconfig.NewAction(&ActionProps{
			ActionPoints: []ActionPoint{
				appconfig.ActionPoint_ON_DEPLOYMENT_START,
			},
			EventDestination: appconfig.NewSnsDestination(topic),
		}),
	},
})

Amazon EventBridge destination

Use the default event bus as the event destination for an extension.

const bus = events.EventBus.fromEventBusName(this, 'MyEventBus', 'default');

new appconfig.Extension(this, 'MyExtension', {
  actions: [
    new appconfig.Action({
      actionPoints: [appconfig.ActionPoint.ON_DEPLOYMENT_START],
      eventDestination: new appconfig.EventBridgeDestination(bus),
    }),
  ],
});

bus = events.EventBus.from_event_bus_name(self, "MyEventBus", "default")

appconfig.Extension(self, "MyExtension",
    actions=[
        appconfig.Action(
            action_points=[appconfig.ActionPoint.ON_DEPLOYMENT_START],
            event_destination=appconfig.EventBridgeDestination(bus)
        )
    ]
)

IEventBus bus = EventBus.fromEventBusName(this, "MyEventBus", "default");

Extension.Builder.create(this, "MyExtension")
        .actions(List.of(
            Action.Builder.create()
                    .actionPoints(List.of(ActionPoint.ON_DEPLOYMENT_START))
                    .eventDestination(new EventBridgeDestination(bus))
                    .build()))
        .build();

var bus = EventBus.FromEventBusName(this, "MyEventBus", "default");

new Extension(this, "MyExtension", new ExtensionProps {
    Actions = new [] {
        new Action(new ActionProps {
            ActionPoints = new [] { ActionPoint.ON_DEPLOYMENT_START },
            EventDestination = new EventBridgeDestination(bus)
        }) }
});

bus := events.EventBus_FromEventBusName(this, jsii.String("MyEventBus"), jsii.String("default"))

appconfig.NewExtension(this, jsii.String("MyExtension"), &ExtensionProps{
	Actions: []Action{
		appconfig.NewAction(&ActionProps{
			ActionPoints: []ActionPoint{
				appconfig.ActionPoint_ON_DEPLOYMENT_START,
			},
			EventDestination: appconfig.NewEventBridgeDestination(bus),
		}),
	},
})

You can also add extensions and their associations directly by calling onDeploymentComplete() or any other action point method on the AWS AppConfig application, configuration, or environment resource. To add an association to an existing extension, you can call addExtension() on the resource.

Adding an association to an AWS AppConfig application:

declare const application: appconfig.Application;
declare const extension: appconfig.Extension;
declare const lambdaDestination: appconfig.LambdaDestination;

application.addExtension(extension);
application.onDeploymentComplete(lambdaDestination);

# application: appconfig.Application
# extension: appconfig.Extension
# lambda_destination: appconfig.LambdaDestination


application.add_extension(extension)
application.on_deployment_complete(lambda_destination)

Application application;
Extension extension;
LambdaDestination lambdaDestination;


application.addExtension(extension);
application.onDeploymentComplete(lambdaDestination);

Application application;
Extension extension;
LambdaDestination lambdaDestination;


application.AddExtension(extension);
application.OnDeploymentComplete(lambdaDestination);

var application Application
var extension Extension
var lambdaDestination LambdaDestination


application.addExtension(extension)
application.onDeploymentComplete(lambdaDestination)

Types

Name	Kind	Summary
Application	Construct (L2)	An AWS AppConfig application.
DeploymentStrategy	Construct (L2)	An AWS AppConfig deployment strategy.
Environment	Construct (L2)	An AWS AppConfig environment.
Extension	Construct (L2)	An AWS AppConfig extension.
CfnApplication	Construct (L1)	The AWS::AppConfig::Application resource creates an application.
CfnConfigurationProfile	Construct (L1)	The AWS::AppConfig::ConfigurationProfile resource creates a configuration profile that enables AWS AppConfig to access the configuration source.
CfnDeployment	Construct (L1)	The AWS::AppConfig::Deployment resource starts a deployment.
CfnDeploymentStrategy	Construct (L1)	The AWS::AppConfig::DeploymentStrategy resource creates an AWS AppConfig deployment strategy.
CfnEnvironment	Construct (L1)	The AWS::AppConfig::Environment resource creates an environment, which is a logical deployment group of AWS AppConfig targets, such as applications in a Beta or Production environment.
CfnExperimentDefinition	Construct (L1)	Resource Type definition for AWS::AppConfig::ExperimentDefinition.
CfnExperimentRun	Construct (L1)	Resource Type definition for AWS::AppConfig::ExperimentRun.
CfnExtension	Construct (L1)	Creates an AWS AppConfig extension.
CfnExtensionAssociation	Construct (L1)	When you create an extension or configure an AWS authored extension, you associate the extension with an AWS AppConfig application, environment, or configuration profile.
CfnHostedConfigurationVersion	Construct (L1)	Create a new configuration in the AWS AppConfig hosted configuration store.
Action	Class	Defines an action for an extension.
ActionPoint	Enum	Defines Extension action points.
ActionProps	Struct	Properties for the Action construct.
ApplicationProps	Struct	Properties for the Application construct.
CfnApplicationProps	Struct	Properties for defining a CfnApplication.
CfnConfigurationProfile.ValidatorsProperty	Struct	A validator provides a syntactic or semantic check to ensure the configuration that you want to deploy functions as intended.
CfnConfigurationProfileProps	Struct	Properties for defining a CfnConfigurationProfile.
CfnDeployment.DynamicExtensionParametersProperty	Struct	A map of dynamic extension parameter names to values to pass to associated extensions with PRE_START_DEPLOYMENT actions.
CfnDeploymentProps	Struct	Properties for defining a CfnDeployment.
CfnDeploymentStrategyProps	Struct	Properties for defining a CfnDeploymentStrategy.
CfnEnvironment.MonitorProperty	Struct	Amazon CloudWatch alarms to monitor during the deployment process.
CfnEnvironment.MonitorsProperty	Struct
CfnEnvironmentProps	Struct	Properties for defining a CfnEnvironment.
CfnExperimentDefinition.AttributeValueProperty	Struct	A typed attribute value for a treatment flag.
CfnExperimentDefinition.TreatmentProperty	Struct	A treatment variant with weight and flag value.
CfnExperimentDefinitionProps	Struct	Properties for defining a CfnExperimentDefinition.
CfnExperimentRun.TreatmentOverridesProperty	Struct	Treatment overrides for specific entities.
CfnExperimentRunProps	Struct	Properties for defining a CfnExperimentRun.
CfnExtension.ActionProperty	Struct	The actions defined in the extension.
CfnExtension.ParameterProperty	Struct	A value such as an Amazon Resource Name (ARN) or an Amazon Simple Notification Service topic entered in an extension when invoked.
CfnExtensionAssociationProps	Struct	Properties for defining a CfnExtensionAssociation.
CfnExtensionProps	Struct	Properties for defining a CfnExtension.
CfnHostedConfigurationVersionProps	Struct	Properties for defining a CfnHostedConfigurationVersion.
ConfigurationContent	Class	Defines the hosted configuration content.
ConfigurationOptions	Struct	Options for the Configuration construct.
ConfigurationProps	Struct	Properties for the Configuration construct.
ConfigurationSource	Class	Defines the integrated configuration sources.
ConfigurationSourceType	Enum	The configuration source type.
ConfigurationType	Enum	The configuration type.
DeletionProtectionCheck	Enum	The deletion protection check options.
DeploymentStrategyId	Class	Defines the deployment strategy ID's of AWS AppConfig deployment strategies.
DeploymentStrategyProps	Struct	Properties for DeploymentStrategy.
EnvironmentAttributes	Struct	Attributes of an existing AWS AppConfig environment to import it.
EnvironmentOptions	Struct	Options for the Environment construct.
EnvironmentProps	Struct	Properties for the Environment construct.
EventBridgeDestination	Class	Use an Amazon EventBridge event bus as an event destination.
ExtensibleBase	Class	This class is meant to be used by AWS AppConfig resources (application, configuration profile, environment) directly.
ExtensionAttributes	Struct	Attributes of an existing AWS AppConfig extension to import.
ExtensionOptions	Struct	Options for the Extension construct.
ExtensionProps	Struct	Properties for the Extension construct.
GrowthType	Enum	Defines the growth type of the deployment strategy.
HostedConfiguration	Construct	A hosted configuration represents configuration stored in the AWS AppConfig hosted configuration store.
HostedConfigurationOptions	Struct	Options for HostedConfiguration.
HostedConfigurationProps	Struct	Properties for HostedConfiguration.
IApplication	Interface
IConfiguration	Interface
IDeploymentStrategy	Interface
IEnvironment	Interface
IEventDestination	Interface	Implemented by allowed extension event destinations.
IExtensible	Interface	Defines the extensible base implementation for extension association resources.
IExtension	Interface
IValidator	Interface
JsonSchemaValidator	Class	Defines a JSON Schema validator.
LambdaDestination	Class	Use an AWS Lambda function as an event destination.
LambdaValidator	Class	Defines an AWS Lambda validator.
Monitor	Class	Defines monitors that will be associated with an AWS AppConfig environment.
MonitorType	Enum	The type of Monitor.
Parameter	Class	Defines a parameter for an extension.
Platform	Enum	Defines the platform for the AWS AppConfig Lambda extension.
RolloutStrategy	Class	Defines the rollout strategy for a deployment strategy and includes the growth factor, deployment duration, growth type, and optionally final bake time.
RolloutStrategyProps	Struct	Properties for the Rollout Strategy.
SnsDestination	Class	Use an Amazon SNS topic as an event destination.
SourcedConfiguration	Construct	A sourced configuration represents configuration stored in an Amazon S3 bucket, AWS Secrets Manager secret, Systems Manager (SSM) Parameter Store parameter, SSM document, or AWS CodePipeline.
SourcedConfigurationOptions	Struct	Options for SourcedConfiguration.
SourcedConfigurationProps	Struct	Properties for SourcedConfiguration.
SourceType	Enum	Defines the source type for event destinations.
SqsDestination	Class	Use an Amazon SQS queue as an event destination.
ValidatorType	Enum	The validator type.