aws-cdk

method addDockerImageAsset

addDockerImageAsset: (
    id: string,
    source: cxschema.DockerImageSource,
    destination: cxschema.DockerImageDestination
) => void;

method addFileAsset

addFileAsset: (
    id: string,
    source: cxschema.FileSource,
    destination: cxschema.FileDestination
) => void;

method toManifest

toManifest: (directory: string) => AssetManifest;

constructor

constructor(source: BootstrapSource, msg: IoMessaging);

method bootstrapEnvironment

bootstrapEnvironment: (
    environment: cxapi.Environment,
    sdkProvider: SdkProvider,
    options?: BootstrapEnvironmentOptions
) => Promise<SuccessfulDeployStackResult>;

method showTemplate

showTemplate: (json: boolean) => Promise<void>;

constructor

protected constructor(
    cfn: ICloudFormationClient,
    stackName: string,
    stack?: any,
    retrieveProcessedTemplate?: boolean
);

property exists

readonly exists: boolean;

• Whether the stack exists

property notificationArns

readonly notificationArns: string[];

• SNS Topic ARNs that will receive stack events.

  Empty list if the stack does not exist

property outputs

readonly outputs: Record<string, string>;

• The stack's current outputs

  Empty object if the stack doesn't exist

property parameterNames

readonly parameterNames: string[];

• Return the names of all current parameters to the stack

  Empty list if the stack does not exist.

property parameters

readonly parameters: Record<string, string>;

• Return the names and values of all current parameters to the stack

  Empty object if the stack does not exist.

property stackId

readonly stackId: string;

• The stack's ID

  Throws if the stack doesn't exist.

property stackName

readonly stackName: string;

property stackStatus

readonly stackStatus: StackStatus;

• The stack's status

  Special status NOT_FOUND if the stack does not exist.

property tags

readonly tags: Tag[];

• The stack's current tags

  Empty list if the stack does not exist

property terminationProtection

readonly terminationProtection: boolean;

• Return the termination protection of the stack

method doesNotExist

static doesNotExist: (
    cfn: ICloudFormationClient,
    stackName: string
) => CloudFormationStack;

• Return a copy of the given stack that does not exist

  It's a little silly that it needs arguments to do that, but there we go.

method fromStaticInformation

static fromStaticInformation: (
    cfn: ICloudFormationClient,
    stackName: string,
    stack: Stack
) => CloudFormationStack;

• From static information (for testing)

method lookup

static lookup: (
    cfn: ICloudFormationClient,
    stackName: string,
    retrieveProcessedTemplate?: boolean
) => Promise<CloudFormationStack>;

method template

template: () => Promise<Template>;

• Retrieve the stack's deployed template

  Cached, so will only be retrieved once. Will return an empty structure if the stack does not exist.

constructor

constructor(props: DeploymentsProps);

property envs

readonly envs: EnvironmentAccess;

method buildSingleAsset

buildSingleAsset: (
    assetArtifact: cxapi.AssetManifestArtifact | 'no-version-validation',
    assetManifest: cdk_assets.AssetManifest,
    asset: cdk_assets.IManifestEntry,
    options: BuildStackAssetsOptions
) => Promise<void>;

• Build a single asset from an asset manifest

  If an assert manifest artifact is given, the bootstrap stack version will be validated according to the constraints in that manifest artifact. If that is not necessary, 'no-version-validation' can be passed.

method deployStack

deployStack: (options: DeployStackOptions) => Promise<DeployStackResult>;

method destroyStack

destroyStack: (options: DestroyStackOptions) => Promise<void>;

method isSingleAssetPublished

isSingleAssetPublished: (
    assetManifest: cdk_assets.AssetManifest,
    asset: cdk_assets.IManifestEntry,
    options: PublishStackAssetsOptions
) => Promise<boolean>;

• Return whether a single asset has been published already

method publishSingleAsset

publishSingleAsset: (
    assetManifest: cdk_assets.AssetManifest,
    asset: cdk_assets.IManifestEntry,
    options: PublishStackAssetsOptions
) => Promise<void>;

• Publish a single asset from an asset manifest

method readCurrentTemplate

readCurrentTemplate: (
    stackArtifact: cxapi.CloudFormationStackArtifact
) => Promise<Template>;

method readCurrentTemplateWithNestedStacks

readCurrentTemplateWithNestedStacks: (
    rootStackArtifact: cxapi.CloudFormationStackArtifact,
    retrieveProcessedTemplate?: boolean
) => Promise<RootTemplateWithNestedStacks>;

method resolveEnvironment

resolveEnvironment: (
    stack: cxapi.CloudFormationStackArtifact
) => Promise<cxapi.Environment>;

• Resolves the environment for a stack.

method resourceIdentifierSummaries

resourceIdentifierSummaries: (
    stackArtifact: cxapi.CloudFormationStackArtifact
) => Promise<ResourceIdentifierSummaries>;

method rollbackStack

rollbackStack: (options: RollbackStackOptions) => Promise<RollbackStackResult>;

method stackExists

stackExists: (options: StackExistsOptions) => Promise<boolean>;

constructor

constructor(props: GarbageCollectorProps);

property props

readonly props: GarbageCollectorProps;

method garbageCollect

garbageCollect: () => Promise<void>;

• Perform garbage collection on the resolved environment.

method garbageCollectEcr

garbageCollectEcr: (
    sdk: SDK,
    activeAssets: ActiveAssetCache,
    backgroundStackRefresh: BackgroundStackRefresh
) => Promise<void>;

• Perform garbage collection on ECR assets

method garbageCollectS3

garbageCollectS3: (
    sdk: SDK,
    activeAssets: ActiveAssetCache,
    backgroundStackRefresh: BackgroundStackRefresh
) => Promise<void>;

• Perform garbage collection on S3 assets

constructor

constructor(digest: string, size: number, tags: string[], manifest: string);

property digest

readonly digest: string;

property manifest

readonly manifest: string;

property size

readonly size: number;

property tags

readonly tags: string[];

method buildImageTag

buildImageTag: (inc: number) => string;

method dateIsolated

dateIsolated: () => string | undefined;

method getIsolatedTag

getIsolatedTag: () => string | undefined;

method hasIsolatedTag

hasIsolatedTag: () => boolean;

method isolatedTagBefore

isolatedTagBefore: (date: Date) => boolean;

constructor

constructor(bucket: string, key: string, size: number);

property key

readonly key: string;

property size

readonly size: number;

method allTags

allTags: (s3: IS3Client) => Promise<Tag[] | undefined>;

method fileName

fileName: () => string;

method hasIsolatedTag

hasIsolatedTag: () => boolean;

method isolatedTagBefore

isolatedTagBefore: (date: Date) => boolean;

constructor

constructor(
    formalParams: Record<string, TemplateParameter>,
    updates: Record<string, string>,
    previousValues?: Record<string, string>
);

property apiParameters

readonly apiParameters: Parameter[];

property values

readonly values: Record<string, string>;

method hasChanges

hasChanges: (currentValues: Record<string, string>) => ParameterChanges;

• Whether this set of parameter updates will change the actual stack values

constructor

constructor(
    credProvider: AwsCredentialIdentityProvider,
    region: string,
    requestHandler: NodeHttpHandlerOptions,
    logger?: Logger
);

property config

readonly config: ConfigurationOptions;

property currentRegion

readonly currentRegion: string;

property logger

protected readonly logger?: Logger;

method appendCustomUserAgent

appendCustomUserAgent: (userAgentData?: string) => void;

method appsync

appsync: () => IAppSyncClient;

method cloudControl

cloudControl: () => ICloudControlClient;

method cloudFormation

cloudFormation: () => ICloudFormationClient;

method cloudWatchLogs

cloudWatchLogs: () => ICloudWatchLogsClient;

method codeBuild

codeBuild: () => ICodeBuildClient;

method currentAccount

currentAccount: () => Promise<Account>;

method ec2

ec2: () => IEC2Client;

method ecr

ecr: () => IECRClient;

method ecs

ecs: () => IECSClient;

method elbv2

elbv2: () => IElasticLoadBalancingV2Client;

method getUrlSuffix

getUrlSuffix: (region: string) => Promise<string>;

• The AWS SDK v3 requires a client config and a command in order to get an endpoint for any given service.

method iam

iam: () => IIAMClient;

method kms

kms: () => IKMSClient;

method lambda

lambda: () => ILambdaClient;

method removeCustomUserAgent

removeCustomUserAgent: (userAgentData: string) => void;

method route53

route53: () => IRoute53Client;

method s3

s3: () => IS3Client;

method secretsManager

secretsManager: () => ISecretsManagerClient;

method ssm

ssm: () => ISSMClient;

method stepFunctions

stepFunctions: () => IStepFunctionsClient;

method validateCredentials

validateCredentials: () => Promise<void>;

• Make sure the the current credentials are not expired

constructor

constructor(
    defaultCredentialProvider: AwsCredentialIdentityProvider,
    defaultRegion: string,
    requestHandler?: NodeHttpHandlerOptions,
    logger?: any
);

property defaultRegion

readonly defaultRegion: string;

• Default region

method baseCredentialsPartition

baseCredentialsPartition: (
    environment: Environment,
    mode: Mode
) => Promise<string | undefined>;

• Return the partition that base credentials are for

  Returns undefined if there are no base credentials.

method defaultAccount

defaultAccount: () => Promise<Account | undefined>;

• The account we'd auth into if we used default credentials.

  Default credentials are the set of ambiently configured credentials using one of the environment variables, or ~/.aws/credentials, or the *one* profile that was passed into the CLI.

  Might return undefined if there are no default/ambient credentials available (in which case the user should better hope they have credential plugins configured).

  Uses a cache to avoid STS calls if we don't need 'em.

method forEnvironment

forEnvironment: (
    environment: Environment,
    mode: Mode,
    options?: CredentialsOptions,
    quiet?: boolean
) => Promise<SdkForEnvironment>;

• Return an SDK which can do operations in the given environment

  The environment parameter is resolved first (see resolveEnvironment()).

method resolveEnvironment

resolveEnvironment: (env: Environment) => Promise<Environment>;

• Resolve the environment for a stack

  Replaces the magic values UNKNOWN_REGION and UNKNOWN_ACCOUNT with the defaults for the current SDK configuration (~/.aws/config or otherwise).

  It is an error if UNKNOWN_ACCOUNT is used but the user hasn't configured any SDK credentials.

method withAwsCliCompatibleDefaults

static withAwsCliCompatibleDefaults: (
    options?: SdkProviderOptions
) => Promise<SdkProvider>;

• Create a new SdkProvider which gets its defaults in a way that behaves like the AWS CLI does

  The AWS SDK for JS behaves slightly differently from the AWS CLI in a number of ways; see the class AwsCliCompatible for the details.

constructor

constructor(ioHost: IIoHost);

method debug

debug: (..._content: any[]) => void;

method error

error: (...content: any[]) => void;

• Error is called mostly (exclusively?) for failing API calls

  Payload (input would be the entire API call arguments).

  {
    clientName: 'STSClient',
    commandName: 'GetCallerIdentityCommand',
    input: {},
    error: AggregateError [ECONNREFUSED]:
        at internalConnectMultiple (node:net:1121:18)
        at afterConnectMultiple (node:net:1688:7) {
      code: 'ECONNREFUSED',
      '$metadata': { attempts: 3, totalRetryDelay: 600 },
      [errors]: [ [Error], [Error] ]
    },
    metadata: { attempts: 3, totalRetryDelay: 600 }
  }

method info

info: (...content: any[]) => void;

• Info is called mostly (exclusively?) for successful API calls

  Payload:

  (Note the input contains entire CFN templates, for example)

  {
    clientName: 'S3Client',
    commandName: 'GetBucketLocationCommand',
    input: {
      Bucket: '.....',
      ExpectedBucketOwner: undefined
    },
    output: { LocationConstraint: 'eu-central-1' },
    metadata: {
      httpStatusCode: 200,
      requestId: '....',
      extendedRequestId: '...',
      cfId: undefined,
      attempts: 1,
      totalRetryDelay: 0
    }
  }

method trace

trace: (..._content: any[]) => void;

method warn

warn: (...content: any[]) => void;

constructor

constructor(params: Record<string, TemplateParameter>);

method fromTemplate

static fromTemplate: (template: Template) => TemplateParameters;

method supplyAll

supplyAll: (updates: Record<string, string | undefined>) => ParameterValues;

• Calculate stack parameters to pass from the given desired parameter values

  Will throw if parameters without a Default value or a Previous value are not supplied.

method updateExisting

updateExisting: (
    updates: Record<string, string | undefined>,
    previousValues: Record<string, string>
) => ParameterValues;

• From the template, the given desired values and the current values, calculate the changes to the stack parameters

  Will take into account parameters already set on the template (will emit 'UsePreviousValue: true' for those unless the value is changed), and will throw if parameters without a Default value or a Previous value are not supplied.

constructor

constructor();

property bootstrapStack

abstract readonly bootstrapStack: CloudFormationStack;

property bucketName

abstract readonly bucketName: string;

property bucketUrl

abstract readonly bucketUrl: string;

property found

abstract readonly found: boolean;

property repositoryName

abstract readonly repositoryName: string;

property stackName

abstract readonly stackName: string;

property variant

abstract readonly variant: string;

property version

abstract readonly version: number;

method bootstrapStackLookupError

static bootstrapStackLookupError: (stackName: string, e: Error) => ToolkitInfo;

method bootstrapStackNotFoundInfo

static bootstrapStackNotFoundInfo: (stackName: string) => ToolkitInfo;

method determineName

static determineName: (overrideName?: string) => string;

method fromStack

static fromStack: (stack: CloudFormationStack) => ToolkitInfo;

method lookup

static lookup: (
    environment: cxapi.Environment,
    sdk: SDK,
    { ioHost, action }: IoMessaging,
    stackName: string | undefined
) => Promise<ToolkitInfo>;

property accountId

readonly accountId: string;

• The account number

property partition

readonly partition: string;

• The partition ('aws' or 'aws-cn' or otherwise)

property execute

readonly execute?: boolean;

• Whether to execute the changeset or only create it and leave it in review. true

property force

readonly force?: boolean;

property parameters

readonly parameters?: BootstrappingParameters;

property roleArn

readonly roleArn?: StringWithoutPlaceholders;

property source

readonly source?: BootstrapSource;

• The source of the bootstrap stack

  - modern v2-style bootstrapping

property tags

readonly tags?: Tag[];

• Tags for cdktoolkit stack.

  - None.

property terminationProtection

readonly terminationProtection?: boolean;

• Whether the stacks created by the bootstrap process should be protected from termination.

  See Also

  • https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html true

property toolkitStackName

readonly toolkitStackName?: string;

property usePreviousParameters

usePreviousParameters?: boolean;

• Use previous values for unspecified parameters

  If not set, all parameters must be specified for every deployment.

  true

property bucketName

readonly bucketName?: string;

• The name to be given to the CDK Bootstrap bucket.

  - a name is generated by CloudFormation.

property cloudFormationExecutionPolicies

readonly cloudFormationExecutionPolicies?: string[];

• The ARNs of the IAM managed policies that should be attached to the role performing CloudFormation deployments. In most cases, this will be the AdministratorAccess policy. At least one policy is required if trustedAccounts were passed.

  - the role will have no policies attached

property createCustomerMasterKey

readonly createCustomerMasterKey?: boolean;

• Whether or not to create a new customer master key (CMK)

  Only applies to modern bootstrapping. Legacy bootstrapping will never create a CMK, only use the default S3 key.

  false

property customPermissionsBoundary

readonly customPermissionsBoundary?: string;

• Name for the customer's custom permissions boundary for bootstrapping

  - No value, optional argument

property examplePermissionsBoundary

readonly examplePermissionsBoundary?: boolean;

• Flag for using the default permissions boundary for bootstrapping

  - No value, optional argument

property kmsKeyId

readonly kmsKeyId?: string;

• The ID of an existing KMS key to be used for encrypting items in the bucket.

  - use the default KMS key or create a custom one

property publicAccessBlockConfiguration

readonly publicAccessBlockConfiguration?: boolean;

• Whether or not to enable S3 Staging Bucket Public Access Block Configuration

  true

property qualifier

readonly qualifier?: string;

• Identifier to distinguish multiple bootstrapped environments

  - Default qualifier

property trustedAccounts

readonly trustedAccounts?: string[];

• The list of AWS account IDs that are trusted to deploy into the environment being bootstrapped.

  - only the bootstrapped account can deploy into this environment

property trustedAccountsForLookup

readonly trustedAccountsForLookup?: string[];

• The list of AWS account IDs that are trusted to look up values in the environment being bootstrapped.

  - only the bootstrapped account can look up values in this environment

property untrustedAccounts

readonly untrustedAccounts?: string[];

• The list of AWS account IDs that should not be trusted by the bootstrapped environment. If these accounts are already trusted, they will be removed on bootstrapping.

  - no account will be untrusted.

property stackName

readonly stackName?: string;

• Stack name this asset is for

property changeSetName

readonly changeSetName?: string;

• Optional name to use for the CloudFormation change set. If not provided, a name will be generated automatically.

property execute

readonly execute?: boolean;

• Whether to execute the changeset or leave it in review.

  true

property importExistingResources

readonly importExistingResources?: boolean;

• Indicates if the change set imports resources that already exist.

  false

property method

readonly method: 'change-set';

property computeChecksums

computeChecksums?: boolean;

property credentials

credentials: AwsCredentialIdentityProvider;

property customUserAgent

customUserAgent: string;

property logger

logger?: Logger;

property region

region: string;

property requestHandler

requestHandler: NodeHttpHandlerOptions;

property retryStrategy

retryStrategy: ConfiguredRetryStrategy;

property s3DisableBodySigning

s3DisableBodySigning?: boolean;

property assumeRoleAdditionalOptions

readonly assumeRoleAdditionalOptions?: AssumeRoleAdditionalOptions;

• Session tags required to assume the given role.

property assumeRoleArn

readonly assumeRoleArn?: string;

• The ARN of the role that needs to be assumed, if any

property assumeRoleExternalId

readonly assumeRoleExternalId?: string;

• External ID required to assume the given role.

property action

readonly action: ToolkitAction;

property ioHost

readonly ioHost: IIoHost;

property sdkProvider

readonly sdkProvider: SdkProvider;

property toolkitStackName

readonly toolkitStackName?: string;

property assetParallelism

readonly assetParallelism?: boolean;

• Whether to build/publish assets in parallel

  true To remain backward compatible.

property changeSetName

readonly changeSetName?: string;

• Optional name to use for the CloudFormation change set. If not provided, a name will be generated automatically.

  Deprecated

  Use 'deploymentMethod' instead

property deploymentMethod

readonly deploymentMethod?: DeploymentMethod;

• Select the deployment method (direct or using a change set)

  - Change set with default options

property deployName

readonly deployName?: string;

• Override name under which stack will be deployed

  - Use artifact default

property execute

readonly execute?: boolean;

• Stage the change set but don't execute it

  - true

  Deprecated

  Use 'deploymentMethod' instead

property extraUserAgent

readonly extraUserAgent?: string;

• The extra string to append to the User-Agent header when performing AWS SDK calls.

  - nothing extra is appended to the User-Agent header

property force

readonly force?: boolean;

• Force deployment, even if the deployed template is identical to the one we are about to deploy. false deployment will be skipped if the template is identical

property hotswap

readonly hotswap?: HotswapMode;

property hotswapPropertyOverrides

readonly hotswapPropertyOverrides?: HotswapPropertyOverrides;

• Properties that configure hotswap behavior

property ignoreNoStacks

ignoreNoStacks?: boolean;

• Whether to deploy if the app contains no stacks.

  false

property notificationArns

readonly notificationArns?: string[];

• Topic ARNs to send a message when deployment finishes (pass through to CloudFormation)

  - No notifications

property overrideTemplate

readonly overrideTemplate?: any;

• If present, use this given template instead of the stored one

  - Use the stored template

property parameters

readonly parameters?: {
    [name: string]: string | undefined;
};

• Extra parameters for CloudFormation - no additional parameters will be passed to the template

property resourcesToImport

readonly resourcesToImport?: ResourcesToImport;

• List of existing resources to be IMPORTED into the stack, instead of being CREATED

property reuseAssets

readonly reuseAssets?: string[];

• List of asset IDs which should NOT be built or uploaded

  - Build all assets

property roleArn

readonly roleArn?: string;

• Execution role for the deployment (pass through to CloudFormation)

  - Current role

property rollback

readonly rollback?: boolean;

• Rollback failed deployments

  true

property stack

readonly stack: cxapi.CloudFormationStackArtifact;

• Stack to deploy

property tags

readonly tags?: Tag[];

• Stack tags (pass through to CloudFormation)

property toolkitStackName

readonly toolkitStackName?: string;

• Name of the toolkit stack, if not the default name

  'CDKToolkit'

property usePreviousParameters

readonly usePreviousParameters?: boolean;

• Use previous values for unspecified parameters

  If not set, all parameters must be specified for every deployment.

  true

property deployName

deployName?: string;

property roleArn

roleArn?: string;

property stack

stack: cxapi.CloudFormationStackArtifact;

property method

readonly method: 'direct';

property endpoint

endpoint: string;

property password

password: string;

property username

username: string;

property repositoryUri

repositoryUri: string;