cxapi

package
v2.94.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 1, 2023 License: Apache-2.0 Imports: 5 Imported by: 4

README

Cloud Executable API

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

V2 Feature Flags

  • @aws-cdk/aws-s3:createDefaultLoggingPolicy

Enable this feature flag to create an S3 bucket policy by default in cases where an AWS service would automatically create the Policy if one does not exist.

For example, in order to send VPC flow logs to an S3 bucket, there is a specific Bucket Policy that needs to be attached to the bucket. If you create the bucket without a policy and then add the bucket as the flow log destination, the service will automatically create the bucket policy with the necessary permissions. If you were to then try and add your own bucket policy CloudFormation will throw and error indicating that a bucket policy already exists.

In cases where we know what the required policy is we can go ahead and create the policy so we can remain in control of it.

https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html#AWS-logs-infrastructure-S3

cdk.json

{
  "context": {
    "@aws-cdk/aws-s3:createDefaultLoggingPolicy": true
  }
}
  • @aws-cdk/aws-sns-subscriptions:restrictSqsDescryption

Enable this feature flag to restrict the decryption of a SQS queue, which is subscribed to a SNS topic, to only the topic which it is subscribed to and not the whole SNS service of an account.

Previously the decryption was only restricted to the SNS service principal. To make the SQS subscription more secure, it is a good practice to restrict the decryption further and only allow the connected SNS topic to decryption the subscribed queue.

cdk.json

{
  "context": {
    "@aws-cdk/aws-sns-subscriptions:restrictSqsDescryption": true
  }
}
  • @aws-cdk/aws-apigateway:disableCloudWatchRole

Enable this feature flag to change the default behavior for aws-apigateway.RestApi and aws-apigateway.SpecRestApi to not create a CloudWatch role and Account. There is only a single ApiGateway account per AWS environment which means that each time you create a RestApi in your account the ApiGateway account is overwritten. If at some point the newest RestApi is deleted, the ApiGateway Account and CloudWatch role will also be deleted, breaking any existing ApiGateways that were depending on them.

When this flag is enabled you should either create the ApiGateway account and CloudWatch role separately or only enable the cloudWatchRole on a single RestApi.

cdk.json

{
  "context": {
    "@aws-cdk/aws-apigateway:disableCloudWatchRole": true
  }
}
  • @aws-cdk/core:enablePartitionLiterals

Enable this feature flag to have Stack.partition return a literal string for a stack's partition when the stack has a known region configured. If the region is undefined, or set to an unknown value, the Stack.partition will be the CloudFormation intrinsic value AWS::Partition. Without this feature flag, Stack.partition always returns the CloudFormation intrinsic value AWS::Partition.

This feature will often simplify ARN strings in CDK generated templates, for example:

 Principal:
   AWS:
     Fn::Join:
       - ""
       - - "arn:"
         - Ref: AWS::Partition
         - :iam::123456789876:root

becomes:

 Principal:
   AWS: "arn:aws:iam::123456789876:root"
  • @aws-cdk/aws-ecs:disableExplicitDeploymentControllerForCircuitBreaker

Enable this feature flag to avoid setting the "ECS" deployment controller when adding a circuit breaker to an ECS Service, as this will trigger a full replacement which fails to deploy when using set service names. This does not change any behaviour as the default deployment controller when it is not defined is ECS.

cdk.json

{
  "context": {
    "@aws-cdk/aws-ecs:disableExplicitDeploymentControllerForCircuitBreaker": true
  }
}
  • @aws-cdk/aws-s3:serverAccessLogsUseBucketPolicy

Enable this feature flag to use S3 Bucket Policy for granting permission fo Server Access Logging rather than using the canned LogDeliveryWrite ACL. ACLs do not work when Object Ownership is enabled on the bucket.

This flag uses a Bucket Policy statement to allow Server Access Log delivery, following best practices for S3.

https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-server-access-logging.html

{
  "context": {
    "@aws-cdk/aws-s3:serverAccessLogsUseBucketPolicy": true
  }
}
  • @aws-cdk/aws-rds:databaseProxyUniqueResourceName

Enable this feature flag to use unique resource names for each DatabaseProxy.

Previously, the default behavior for DatabaseProxy was to use id of the constructor for dbProxyName. In this case, users couldn't deploy DatabaseProxys that have the same id in the same region.

This is a feature flag as the old behavior was technically incorrect, but users may have come to depend on it.

{
  "context": {
    "@aws-cdk/aws-rds:databaseProxyUniqueResourceName": true
  }
}
  • @aws-cdk/aws-redshift:columnId

Enable this feature flag to allow the CDK to track changes in Redshift columns through their id attribute. This is a breaking change, as the name attribute was currently being used to track changes to Redshift columns.

Enabling this feature flag comes at a risk for existing Redshift columns, as the name attribute of a redshift column was currently being used. Therefore, to change a Redshift columns' name will essentially create a new column and delete the old one. This will cause data loss. If you choose to enable this flag, ensure that upon intial deployment (the first deployment after setting this feature flag), the name attribute of every column is not changed. After the intial deployment, you can freely change the name attribute of a column.

cdk.json

{
  "context": {
    "@aws-cdk/aws-redshift:columnId": true
  }
}
  • @aws-cdk/aws-stepfunctions-tasks:enableEmrServicePolicyV2

Enable this feature flag to use the AmazonEMRServicePolicy_v2 managed policies for the EMR service role.

This is a feature flag as the old behavior will be deprecated, but some resources may require manual intervention since they might not have the appropriate tags propagated automatically.

https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-managed-iam-policies.html

cdk.json

{
  "context": {
    "@aws-cdk/aws-stepfunctions-tasks:enableEmrServicePolicyV2": true
  }
}
  • @aws-cdk/core:includePrefixInUniqueNameGeneration

Enable this feature flag to include the stack's prefixes to the name generation process.

Not doing so can cause the name of stack to exceed 128 characters:

  • The name generation ensures it doesn't exceed 128 characters
  • Without this feature flag, the prefix is prepended to the generated name, which result can exceed 128 characters

This is a feature flag as it changes the name generated for stacks. Any CDK application deployed prior this fix will most likely be generated with a new name, causing the stack to be recreated with the new name, and then deleting the old one. For applications running on production environments this can be unmanageable.

cdk.json

{
  "context": {
    "@aws-cdk/core:includePrefixInUniqueNameGeneration": true
  }
}
  • @aws-cdk/aws-lambda-nodejs:useLatestRuntimeVersion

Enable this feature flag to automatically use the latest available NodeJS version in the aws-lambda-nodejse.Function construct.

This allows creation of new functions using a version that will automatically stay up to date without breaking bundling of existing functions that externalize packages included in their environemnt such as aws-sdk.

Functions defined previously will continue to function correctly as long as they pass an explicit runtime version, or do not exclude packages during bundling.

cdk.json

{
  "context": {
    "@aws-cdk/aws-lambda-nodejs:useLatestRuntimeVersion": true
  }
}

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func AssetManifestArtifact_IsAssetManifestArtifact added in v2.19.0 

func AssetManifestArtifact_IsAssetManifestArtifact(art interface{}) *bool

Checks if `art` is an instance of this class.

Use this method instead of `instanceof` to properly detect `AssetManifestArtifact` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `cx-api` library on disk are seen as independent, completely different libraries. As a consequence, the class `AssetManifestArtifact` in each copy of the `cx-api` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `cx-api` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

func CloudFormationStackArtifact_IsCloudFormationStackArtifact added in v2.80.0 

func CloudFormationStackArtifact_IsCloudFormationStackArtifact(art interface{}) *bool

Checks if `art` is an instance of this class.

Use this method instead of `instanceof` to properly detect `CloudFormationStackArtifact` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `cx-api` library on disk are seen as independent, completely different libraries. As a consequence, the class `CloudFormationStackArtifact` in each copy of the `cx-api` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `cx-api` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

func EnvironmentPlaceholders_CURRENT_ACCOUNT 

func EnvironmentPlaceholders_CURRENT_ACCOUNT() *string

func EnvironmentPlaceholders_CURRENT_PARTITION 

func EnvironmentPlaceholders_CURRENT_PARTITION() *string

func EnvironmentPlaceholders_CURRENT_REGION 

func EnvironmentPlaceholders_CURRENT_REGION() *string

func EnvironmentPlaceholders_Replace 

func EnvironmentPlaceholders_Replace(object interface{}, values *EnvironmentPlaceholderValues) interface{}

Replace the environment placeholders in all strings found in a complex object.

Duplicated between cdk-assets and aws-cdk CLI because we don't have a good single place to put it (they're nominally independent tools).

func EnvironmentPlaceholders_ReplaceAsync 

func EnvironmentPlaceholders_ReplaceAsync(object interface{}, provider IEnvironmentPlaceholderProvider) interface{}

Like 'replace', but asynchronous.

func EnvironmentUtils_Format 

func EnvironmentUtils_Format(account *string, region *string) *string

Format an environment string from an account and region.

func NestedCloudAssemblyArtifact_IsNestedCloudAssemblyArtifact added in v2.80.0 

func NestedCloudAssemblyArtifact_IsNestedCloudAssemblyArtifact(art interface{}) *bool

Checks if `art` is an instance of this class.

Use this method instead of `instanceof` to properly detect `NestedCloudAssemblyArtifact` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `cx-api` library on disk are seen as independent, completely different libraries. As a consequence, the class `NestedCloudAssemblyArtifact` in each copy of the `cx-api` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `cx-api` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

func NewAssetManifestArtifact_Override 

func NewAssetManifestArtifact_Override(a AssetManifestArtifact, assembly CloudAssembly, name *string, artifact *cloudassemblyschema.ArtifactManifest)

func NewCloudArtifact_Override 

func NewCloudArtifact_Override(c CloudArtifact, assembly CloudAssembly, id *string, manifest *cloudassemblyschema.ArtifactManifest)

func NewCloudAssemblyBuilder_Override 

func NewCloudAssemblyBuilder_Override(c CloudAssemblyBuilder, outdir *string, props *CloudAssemblyBuilderProps)

Initializes a cloud assembly builder.

func NewCloudAssembly_Override 

func NewCloudAssembly_Override(c CloudAssembly, directory *string, loadOptions *cloudassemblyschema.LoadManifestOptions)

Reads a cloud assembly from the specified directory.

func NewCloudFormationStackArtifact_Override 

func NewCloudFormationStackArtifact_Override(c CloudFormationStackArtifact, assembly CloudAssembly, artifactId *string, artifact *cloudassemblyschema.ArtifactManifest)

func NewEnvironmentPlaceholders_Override 

func NewEnvironmentPlaceholders_Override(e EnvironmentPlaceholders)

func NewEnvironmentUtils_Override 

func NewEnvironmentUtils_Override(e EnvironmentUtils)

func NewNestedCloudAssemblyArtifact_Override 

func NewNestedCloudAssemblyArtifact_Override(n NestedCloudAssemblyArtifact, assembly CloudAssembly, name *string, artifact *cloudassemblyschema.ArtifactManifest)

func NewTreeCloudArtifact_Override 

func NewTreeCloudArtifact_Override(t TreeCloudArtifact, assembly CloudAssembly, name *string, artifact *cloudassemblyschema.ArtifactManifest)

func TreeCloudArtifact_IsTreeCloudArtifact added in v2.80.0 

func TreeCloudArtifact_IsTreeCloudArtifact(art interface{}) *bool

Checks if `art` is an instance of this class.

Use this method instead of `instanceof` to properly detect `TreeCloudArtifact` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `cx-api` library on disk are seen as independent, completely different libraries. As a consequence, the class `TreeCloudArtifact` in each copy of the `cx-api` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `cx-api` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Types

type AssemblyBuildOptions 

type AssemblyBuildOptions struct {
}

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

assemblyBuildOptions := &AssemblyBuildOptions{
}

type AssetManifestArtifact 

type AssetManifestArtifact interface {
	CloudArtifact
	Assembly() CloudAssembly
	// Name of SSM parameter with bootstrap stack version.
	// Default: - Discover SSM parameter by reading stack.
	//
	BootstrapStackVersionSsmParameter() *string
	// The Asset Manifest contents.
	Contents() *cloudassemblyschema.AssetManifest
	// Returns all the artifacts that this artifact depends on.
	Dependencies() *[]CloudArtifact
	// The file name of the asset manifest.
	File() *string
	// An identifier that shows where this artifact is located in the tree of nested assemblies, based on their manifests.
	//
	// Defaults to the normal
	// id. Should only be used in user interfaces.
	HierarchicalId() *string
	Id() *string
	// The artifact's manifest.
	Manifest() *cloudassemblyschema.ArtifactManifest
	// The set of messages extracted from the artifact's metadata.
	Messages() *[]*SynthesisMessage
	// Version of bootstrap stack required to deploy this stack.
	RequiresBootstrapStackVersion() *float64
	// Returns: all the metadata entries of a specific type in this artifact.
	FindMetadataByType(type_ *string) *[]*MetadataEntryResult
}

Asset manifest is a description of a set of assets which need to be built and published.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var cloudAssembly cloudAssembly

assetManifestArtifact := awscdk.Cx_api.NewAssetManifestArtifact(cloudAssembly, jsii.String("name"), &ArtifactManifest{
	Type: awscdk.Cloud_assembly_schema.ArtifactType_NONE,

	// the properties below are optional
	Dependencies: []*string{
		jsii.String("dependencies"),
	},
	DisplayName: jsii.String("displayName"),
	Environment: jsii.String("environment"),
	Metadata: map[string][]metadataEntry{
		"metadataKey": []*metadataEntry{
			&metadataEntry{
				"type": jsii.String("type"),

				// the properties below are optional
				"data": jsii.String("data"),
				"trace": []*string{
					jsii.String("trace"),
				},
			},
		},
	},
	Properties: &AwsCloudFormationStackProperties{
		TemplateFile: jsii.String("templateFile"),

		// the properties below are optional
		AssumeRoleArn: jsii.String("assumeRoleArn"),
		AssumeRoleExternalId: jsii.String("assumeRoleExternalId"),
		BootstrapStackVersionSsmParameter: jsii.String("bootstrapStackVersionSsmParameter"),
		CloudFormationExecutionRoleArn: jsii.String("cloudFormationExecutionRoleArn"),
		LookupRole: &BootstrapRole{
			Arn: jsii.String("arn"),

			// the properties below are optional
			AssumeRoleExternalId: jsii.String("assumeRoleExternalId"),
			BootstrapStackVersionSsmParameter: jsii.String("bootstrapStackVersionSsmParameter"),
			RequiresBootstrapStackVersion: jsii.Number(123),
		},
		Parameters: map[string]*string{
			"parametersKey": jsii.String("parameters"),
		},
		RequiresBootstrapStackVersion: jsii.Number(123),
		StackName: jsii.String("stackName"),
		StackTemplateAssetObjectUrl: jsii.String("stackTemplateAssetObjectUrl"),
		Tags: map[string]*string{
			"tagsKey": jsii.String("tags"),
		},
		TerminationProtection: jsii.Boolean(false),
		ValidateOnSynth: jsii.Boolean(false),
	},
})

func NewAssetManifestArtifact 

func NewAssetManifestArtifact(assembly CloudAssembly, name *string, artifact *cloudassemblyschema.ArtifactManifest) AssetManifestArtifact

type AwsCloudFormationStackProperties 

type AwsCloudFormationStackProperties struct {
	// A file relative to the assembly root which contains the CloudFormation template for this stack.
	TemplateFile *string `field:"required" json:"templateFile" yaml:"templateFile"`
	// Values for CloudFormation stack parameters that should be passed when the stack is deployed.
	Parameters *map[string]*string `field:"optional" json:"parameters" yaml:"parameters"`
	// The name to use for the CloudFormation stack.
	// Default: - name derived from artifact ID.
	//
	StackName *string `field:"optional" json:"stackName" yaml:"stackName"`
	// Whether to enable termination protection for this stack.
	// Default: false.
	//
	TerminationProtection *bool `field:"optional" json:"terminationProtection" yaml:"terminationProtection"`
}

Artifact properties for CloudFormation stacks.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

awsCloudFormationStackProperties := &AwsCloudFormationStackProperties{
	TemplateFile: jsii.String("templateFile"),

	// the properties below are optional
	Parameters: map[string]*string{
		"parametersKey": jsii.String("parameters"),
	},
	StackName: jsii.String("stackName"),
	TerminationProtection: jsii.Boolean(false),
}

type CloudArtifact 

type CloudArtifact interface {
	Assembly() CloudAssembly
	// Returns all the artifacts that this artifact depends on.
	Dependencies() *[]CloudArtifact
	// An identifier that shows where this artifact is located in the tree of nested assemblies, based on their manifests.
	//
	// Defaults to the normal
	// id. Should only be used in user interfaces.
	HierarchicalId() *string
	Id() *string
	// The artifact's manifest.
	Manifest() *cloudassemblyschema.ArtifactManifest
	// The set of messages extracted from the artifact's metadata.
	Messages() *[]*SynthesisMessage
	// Returns: all the metadata entries of a specific type in this artifact.
	FindMetadataByType(type_ *string) *[]*MetadataEntryResult
}

Represents an artifact within a cloud assembly.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var cloudAssembly cloudAssembly

cloudArtifact := awscdk.Cx_api.CloudArtifact_FromManifest(cloudAssembly, jsii.String("MyCloudArtifact"), &ArtifactManifest{
	Type: awscdk.Cloud_assembly_schema.ArtifactType_NONE,

	// the properties below are optional
	Dependencies: []*string{
		jsii.String("dependencies"),
	},
	DisplayName: jsii.String("displayName"),
	Environment: jsii.String("environment"),
	Metadata: map[string][]metadataEntry{
		"metadataKey": []*metadataEntry{
			&metadataEntry{
				"type": jsii.String("type"),

				// the properties below are optional
				"data": jsii.String("data"),
				"trace": []*string{
					jsii.String("trace"),
				},
			},
		},
	},
	Properties: &AwsCloudFormationStackProperties{
		TemplateFile: jsii.String("templateFile"),

		// the properties below are optional
		AssumeRoleArn: jsii.String("assumeRoleArn"),
		AssumeRoleExternalId: jsii.String("assumeRoleExternalId"),
		BootstrapStackVersionSsmParameter: jsii.String("bootstrapStackVersionSsmParameter"),
		CloudFormationExecutionRoleArn: jsii.String("cloudFormationExecutionRoleArn"),
		LookupRole: &BootstrapRole{
			Arn: jsii.String("arn"),

			// the properties below are optional
			AssumeRoleExternalId: jsii.String("assumeRoleExternalId"),
			BootstrapStackVersionSsmParameter: jsii.String("bootstrapStackVersionSsmParameter"),
			RequiresBootstrapStackVersion: jsii.Number(123),
		},
		Parameters: map[string]*string{
			"parametersKey": jsii.String("parameters"),
		},
		RequiresBootstrapStackVersion: jsii.Number(123),
		StackName: jsii.String("stackName"),
		StackTemplateAssetObjectUrl: jsii.String("stackTemplateAssetObjectUrl"),
		Tags: map[string]*string{
			"tagsKey": jsii.String("tags"),
		},
		TerminationProtection: jsii.Boolean(false),
		ValidateOnSynth: jsii.Boolean(false),
	},
})

func AssetManifestArtifact_FromManifest 

func AssetManifestArtifact_FromManifest(assembly CloudAssembly, id *string, artifact *cloudassemblyschema.ArtifactManifest) CloudArtifact

Returns a subclass of `CloudArtifact` based on the artifact type defined in the artifact manifest.

Returns: the `CloudArtifact` that matches the artifact type or `undefined` if it's an artifact type that is unrecognized by this module.

func CloudArtifact_FromManifest 

func CloudArtifact_FromManifest(assembly CloudAssembly, id *string, artifact *cloudassemblyschema.ArtifactManifest) CloudArtifact

Returns a subclass of `CloudArtifact` based on the artifact type defined in the artifact manifest.

Returns: the `CloudArtifact` that matches the artifact type or `undefined` if it's an artifact type that is unrecognized by this module.

func CloudFormationStackArtifact_FromManifest 

func CloudFormationStackArtifact_FromManifest(assembly CloudAssembly, id *string, artifact *cloudassemblyschema.ArtifactManifest) CloudArtifact

Returns a subclass of `CloudArtifact` based on the artifact type defined in the artifact manifest.

Returns: the `CloudArtifact` that matches the artifact type or `undefined` if it's an artifact type that is unrecognized by this module.

func NestedCloudAssemblyArtifact_FromManifest 

func NestedCloudAssemblyArtifact_FromManifest(assembly CloudAssembly, id *string, artifact *cloudassemblyschema.ArtifactManifest) CloudArtifact

Returns a subclass of `CloudArtifact` based on the artifact type defined in the artifact manifest.

Returns: the `CloudArtifact` that matches the artifact type or `undefined` if it's an artifact type that is unrecognized by this module.

func NewCloudArtifact 

func NewCloudArtifact(assembly CloudAssembly, id *string, manifest *cloudassemblyschema.ArtifactManifest) CloudArtifact

func TreeCloudArtifact_FromManifest 

func TreeCloudArtifact_FromManifest(assembly CloudAssembly, id *string, artifact *cloudassemblyschema.ArtifactManifest) CloudArtifact

Returns a subclass of `CloudArtifact` based on the artifact type defined in the artifact manifest.

Returns: the `CloudArtifact` that matches the artifact type or `undefined` if it's an artifact type that is unrecognized by this module.

type CloudAssembly 

type CloudAssembly interface {
	// All artifacts included in this assembly.
	Artifacts() *[]CloudArtifact
	// The root directory of the cloud assembly.
	Directory() *string
	// The raw assembly manifest.
	Manifest() *cloudassemblyschema.AssemblyManifest
	// The nested assembly artifacts in this assembly.
	NestedAssemblies() *[]NestedCloudAssemblyArtifact
	// Runtime information such as module versions used to synthesize this assembly.
	Runtime() *cloudassemblyschema.RuntimeInfo
	// Returns: all the CloudFormation stack artifacts that are included in this assembly.
	Stacks() *[]CloudFormationStackArtifact
	// Returns all the stacks, including the ones in nested assemblies.
	StacksRecursively() *[]CloudFormationStackArtifact
	// The schema version of the assembly manifest.
	Version() *string
	// Returns a nested assembly.
	GetNestedAssembly(artifactId *string) CloudAssembly
	// Returns a nested assembly artifact.
	GetNestedAssemblyArtifact(artifactId *string) NestedCloudAssemblyArtifact
	// Returns a CloudFormation stack artifact from this assembly.
	//
	// Returns: a `CloudFormationStackArtifact` object.
	GetStackArtifact(artifactId *string) CloudFormationStackArtifact
	// Returns a CloudFormation stack artifact from this assembly.
	//
	// Will only search the current assembly.
	//
	// Returns: a `CloudFormationStackArtifact` object.
	GetStackByName(stackName *string) CloudFormationStackArtifact
	// Returns the tree metadata artifact from this assembly.
	//
	// Returns: a `TreeCloudArtifact` object if there is one defined in the manifest, `undefined` otherwise.
	Tree() TreeCloudArtifact
	// Attempts to find an artifact with a specific identity.
	//
	// Returns: A `CloudArtifact` object or `undefined` if the artifact does not exist in this assembly.
	TryGetArtifact(id *string) CloudArtifact
}

Represents a deployable cloud application.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

cloudAssembly := awscdk.Cx_api.NewCloudAssembly(jsii.String("directory"), &LoadManifestOptions{
	SkipEnumCheck: jsii.Boolean(false),
	SkipVersionCheck: jsii.Boolean(false),
	TopoSort: jsii.Boolean(false),
})

func NewCloudAssembly 

func NewCloudAssembly(directory *string, loadOptions *cloudassemblyschema.LoadManifestOptions) CloudAssembly

Reads a cloud assembly from the specified directory.

type CloudAssemblyBuilder 

type CloudAssemblyBuilder interface {
	// The directory where assets of this Cloud Assembly should be stored.
	AssetOutdir() *string
	// The root directory of the resulting cloud assembly.
	Outdir() *string
	// Adds an artifact into the cloud assembly.
	AddArtifact(id *string, manifest *cloudassemblyschema.ArtifactManifest)
	// Reports that some context is missing in order for this cloud assembly to be fully synthesized.
	AddMissing(missing *cloudassemblyschema.MissingContext)
	// Finalizes the cloud assembly into the output directory returns a `CloudAssembly` object that can be used to inspect the assembly.
	BuildAssembly(options *AssemblyBuildOptions) CloudAssembly
	// Creates a nested cloud assembly.
	CreateNestedAssembly(artifactId *string, displayName *string) CloudAssemblyBuilder
	// Delete the cloud assembly directory.
	Delete()
}

Can be used to build a cloud assembly.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

var cloudAssemblyBuilder_ cloudAssemblyBuilder

cloudAssemblyBuilder := awscdk.Cx_api.NewCloudAssemblyBuilder(jsii.String("outdir"), &CloudAssemblyBuilderProps{
	AssetOutdir: jsii.String("assetOutdir"),
	ParentBuilder: cloudAssemblyBuilder_,
})

func NewCloudAssemblyBuilder 

func NewCloudAssemblyBuilder(outdir *string, props *CloudAssemblyBuilderProps) CloudAssemblyBuilder

Initializes a cloud assembly builder.

type CloudAssemblyBuilderProps 

type CloudAssemblyBuilderProps struct {
	// Use the given asset output directory.
	// Default: - Same as the manifest outdir.
	//
	AssetOutdir *string `field:"optional" json:"assetOutdir" yaml:"assetOutdir"`
	// If this builder is for a nested assembly, the parent assembly builder.
	// Default: - This is a root assembly.
	//
	ParentBuilder CloudAssemblyBuilder `field:"optional" json:"parentBuilder" yaml:"parentBuilder"`
}

Construction properties for CloudAssemblyBuilder.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

var cloudAssemblyBuilder cloudAssemblyBuilder

cloudAssemblyBuilderProps := &CloudAssemblyBuilderProps{
	AssetOutdir: jsii.String("assetOutdir"),
	ParentBuilder: cloudAssemblyBuilder,
}

type CloudFormationStackArtifact 

type CloudFormationStackArtifact interface {
	CloudArtifact
	Assembly() CloudAssembly
	// Any assets associated with this stack.
	Assets() *[]interface{}
	// The role that needs to be assumed to deploy the stack.
	// Default: - No role is assumed (current credentials are used).
	//
	AssumeRoleArn() *string
	// External ID to use when assuming role for cloudformation deployments.
	// Default: - No external ID.
	//
	AssumeRoleExternalId() *string
	// Name of SSM parameter with bootstrap stack version.
	// Default: - Discover SSM parameter by reading stack.
	//
	BootstrapStackVersionSsmParameter() *string
	// The role that is passed to CloudFormation to execute the change set.
	// Default: - No role is passed (currently assumed role/credentials are used).
	//
	CloudFormationExecutionRoleArn() *string
	// Returns all the artifacts that this artifact depends on.
	Dependencies() *[]CloudArtifact
	// A string that represents this stack.
	//
	// Should only be used in user
	// interfaces. If the stackName has not been set explicitly, or has been set
	// to artifactId, it will return the hierarchicalId of the stack. Otherwise,
	// it will return something like "<hierarchicalId> (<stackName>)".
	DisplayName() *string
	// The environment into which to deploy this artifact.
	Environment() *Environment
	// An identifier that shows where this artifact is located in the tree of nested assemblies, based on their manifests.
	//
	// Defaults to the normal
	// id. Should only be used in user interfaces.
	HierarchicalId() *string
	Id() *string
	// The role to use to look up values from the target AWS account.
	// Default: - No role is assumed (current credentials are used).
	//
	LookupRole() *cloudassemblyschema.BootstrapRole
	// The artifact's manifest.
	Manifest() *cloudassemblyschema.ArtifactManifest
	// The set of messages extracted from the artifact's metadata.
	Messages() *[]*SynthesisMessage
	// The original name as defined in the CDK app.
	OriginalName() *string
	// CloudFormation parameters to pass to the stack.
	Parameters() *map[string]*string
	// Version of bootstrap stack required to deploy this stack.
	// Default: - No bootstrap stack required.
	//
	RequiresBootstrapStackVersion() *float64
	// The physical name of this stack.
	StackName() *string
	// If the stack template has already been included in the asset manifest, its asset URL.
	// Default: - Not uploaded yet, upload just before deploying.
	//
	StackTemplateAssetObjectUrl() *string
	// CloudFormation tags to pass to the stack.
	Tags() *map[string]*string
	// The CloudFormation template for this stack.
	Template() interface{}
	// The file name of the template.
	TemplateFile() *string
	// Full path to the template file.
	TemplateFullPath() *string
	// Whether termination protection is enabled for this stack.
	TerminationProtection() *bool
	// Whether this stack should be validated by the CLI after synthesis.
	// Default: - false.
	//
	ValidateOnSynth() *bool
	// Returns: all the metadata entries of a specific type in this artifact.
	FindMetadataByType(type_ *string) *[]*MetadataEntryResult
}

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var cloudAssembly cloudAssembly

cloudFormationStackArtifact := awscdk.Cx_api.NewCloudFormationStackArtifact(cloudAssembly, jsii.String("artifactId"), &ArtifactManifest{
	Type: awscdk.Cloud_assembly_schema.ArtifactType_NONE,

	// the properties below are optional
	Dependencies: []*string{
		jsii.String("dependencies"),
	},
	DisplayName: jsii.String("displayName"),
	Environment: jsii.String("environment"),
	Metadata: map[string][]metadataEntry{
		"metadataKey": []*metadataEntry{
			&metadataEntry{
				"type": jsii.String("type"),

				// the properties below are optional
				"data": jsii.String("data"),
				"trace": []*string{
					jsii.String("trace"),
				},
			},
		},
	},
	Properties: &AwsCloudFormationStackProperties{
		TemplateFile: jsii.String("templateFile"),

		// the properties below are optional
		AssumeRoleArn: jsii.String("assumeRoleArn"),
		AssumeRoleExternalId: jsii.String("assumeRoleExternalId"),
		BootstrapStackVersionSsmParameter: jsii.String("bootstrapStackVersionSsmParameter"),
		CloudFormationExecutionRoleArn: jsii.String("cloudFormationExecutionRoleArn"),
		LookupRole: &BootstrapRole{
			Arn: jsii.String("arn"),

			// the properties below are optional
			AssumeRoleExternalId: jsii.String("assumeRoleExternalId"),
			BootstrapStackVersionSsmParameter: jsii.String("bootstrapStackVersionSsmParameter"),
			RequiresBootstrapStackVersion: jsii.Number(123),
		},
		Parameters: map[string]*string{
			"parametersKey": jsii.String("parameters"),
		},
		RequiresBootstrapStackVersion: jsii.Number(123),
		StackName: jsii.String("stackName"),
		StackTemplateAssetObjectUrl: jsii.String("stackTemplateAssetObjectUrl"),
		Tags: map[string]*string{
			"tagsKey": jsii.String("tags"),
		},
		TerminationProtection: jsii.Boolean(false),
		ValidateOnSynth: jsii.Boolean(false),
	},
})

func NewCloudFormationStackArtifact 

func NewCloudFormationStackArtifact(assembly CloudAssembly, artifactId *string, artifact *cloudassemblyschema.ArtifactManifest) CloudFormationStackArtifact

type EndpointServiceAvailabilityZonesContextQuery 

type EndpointServiceAvailabilityZonesContextQuery struct {
	// Query account.
	Account *string `field:"optional" json:"account" yaml:"account"`
	// Query region.
	Region *string `field:"optional" json:"region" yaml:"region"`
	// Query service name.
	ServiceName *string `field:"optional" json:"serviceName" yaml:"serviceName"`
}

Query to hosted zone context provider.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

endpointServiceAvailabilityZonesContextQuery := &EndpointServiceAvailabilityZonesContextQuery{
	Account: jsii.String("account"),
	Region: jsii.String("region"),
	ServiceName: jsii.String("serviceName"),
}

type Environment 

type Environment struct {
	// The AWS account this environment deploys into.
	Account *string `field:"required" json:"account" yaml:"account"`
	// The arbitrary name of this environment (user-set, or at least user-meaningful).
	Name *string `field:"required" json:"name" yaml:"name"`
	// The AWS region name where this environment deploys into.
	Region *string `field:"required" json:"region" yaml:"region"`
}

Models an AWS execution environment, for use within the CDK toolkit.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

environment := &Environment{
	Account: jsii.String("account"),
	Name: jsii.String("name"),
	Region: jsii.String("region"),
}

func EnvironmentUtils_Make 

func EnvironmentUtils_Make(account *string, region *string) *Environment

Build an environment object from an account and region.

func EnvironmentUtils_Parse 

func EnvironmentUtils_Parse(environment *string) *Environment

type EnvironmentPlaceholderValues 

type EnvironmentPlaceholderValues struct {
	// Return the account.
	AccountId *string `field:"required" json:"accountId" yaml:"accountId"`
	// Return the partition.
	Partition *string `field:"required" json:"partition" yaml:"partition"`
	// Return the region.
	Region *string `field:"required" json:"region" yaml:"region"`
}

Return the appropriate values for the environment placeholders.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

environmentPlaceholderValues := &EnvironmentPlaceholderValues{
	AccountId: jsii.String("accountId"),
	Partition: jsii.String("partition"),
	Region: jsii.String("region"),
}

type EnvironmentPlaceholders 

type EnvironmentPlaceholders interface {
}

Placeholders which can be used manifests.

These can occur both in the Asset Manifest as well as the general Cloud Assembly manifest.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

environmentPlaceholders := awscdk.Cx_api.NewEnvironmentPlaceholders()

func NewEnvironmentPlaceholders 

func NewEnvironmentPlaceholders() EnvironmentPlaceholders

type EnvironmentUtils 

type EnvironmentUtils interface {
}

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

environmentUtils := awscdk.Cx_api.NewEnvironmentUtils()

func NewEnvironmentUtils 

func NewEnvironmentUtils() EnvironmentUtils

type IEnvironmentPlaceholderProvider 

type IEnvironmentPlaceholderProvider interface {
	// Return the account.
	AccountId() *string
	// Return the partition.
	Partition() *string
	// Return the region.
	Region() *string
}

Return the appropriate values for the environment placeholders.

type KeyContextResponse 

type KeyContextResponse struct {
	// Id of the key.
	KeyId *string `field:"required" json:"keyId" yaml:"keyId"`
}

Properties of a discovered key.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

keyContextResponse := &KeyContextResponse{
	KeyId: jsii.String("keyId"),
}

type LoadBalancerContextResponse 

type LoadBalancerContextResponse struct {
	// Type of IP address.
	IpAddressType LoadBalancerIpAddressType `field:"required" json:"ipAddressType" yaml:"ipAddressType"`
	// The ARN of the load balancer.
	LoadBalancerArn *string `field:"required" json:"loadBalancerArn" yaml:"loadBalancerArn"`
	// The hosted zone ID of the load balancer's name.
	LoadBalancerCanonicalHostedZoneId *string `field:"required" json:"loadBalancerCanonicalHostedZoneId" yaml:"loadBalancerCanonicalHostedZoneId"`
	// Load balancer's DNS name.
	LoadBalancerDnsName *string `field:"required" json:"loadBalancerDnsName" yaml:"loadBalancerDnsName"`
	// Load balancer's security groups.
	SecurityGroupIds *[]*string `field:"required" json:"securityGroupIds" yaml:"securityGroupIds"`
	// Load balancer's VPC.
	VpcId *string `field:"required" json:"vpcId" yaml:"vpcId"`
}

Properties of a discovered load balancer.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

loadBalancerContextResponse := &LoadBalancerContextResponse{
	IpAddressType: awscdk.Cx_api.LoadBalancerIpAddressType_IPV4,
	LoadBalancerArn: jsii.String("loadBalancerArn"),
	LoadBalancerCanonicalHostedZoneId: jsii.String("loadBalancerCanonicalHostedZoneId"),
	LoadBalancerDnsName: jsii.String("loadBalancerDnsName"),
	SecurityGroupIds: []*string{
		jsii.String("securityGroupIds"),
	},
	VpcId: jsii.String("vpcId"),
}

type LoadBalancerIpAddressType 

type LoadBalancerIpAddressType string

Load balancer ip address type. 

const (
	// IPV4 ip address.
	LoadBalancerIpAddressType_IPV4 LoadBalancerIpAddressType = "IPV4"
	// Dual stack address.
	LoadBalancerIpAddressType_DUAL_STACK LoadBalancerIpAddressType = "DUAL_STACK"
)

type LoadBalancerListenerContextResponse 

type LoadBalancerListenerContextResponse struct {
	// The ARN of the listener.
	ListenerArn *string `field:"required" json:"listenerArn" yaml:"listenerArn"`
	// The port the listener is listening on.
	ListenerPort *float64 `field:"required" json:"listenerPort" yaml:"listenerPort"`
	// The security groups of the load balancer.
	SecurityGroupIds *[]*string `field:"required" json:"securityGroupIds" yaml:"securityGroupIds"`
}

Properties of a discovered load balancer listener.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

loadBalancerListenerContextResponse := &LoadBalancerListenerContextResponse{
	ListenerArn: jsii.String("listenerArn"),
	ListenerPort: jsii.Number(123),
	SecurityGroupIds: []*string{
		jsii.String("securityGroupIds"),
	},
}

type MetadataEntryResult 

type MetadataEntryResult struct {
	// The type of the metadata entry.
	Type *string `field:"required" json:"type" yaml:"type"`
	// The data.
	// Default: - no data.
	//
	Data interface{} `field:"optional" json:"data" yaml:"data"`
	// A stack trace for when the entry was created.
	// Default: - no trace.
	//
	Trace *[]*string `field:"optional" json:"trace" yaml:"trace"`
	// The path in which this entry was defined.
	Path *string `field:"required" json:"path" yaml:"path"`
}

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

metadataEntryResult := &MetadataEntryResult{
	Path: jsii.String("path"),
	Type: jsii.String("type"),

	// the properties below are optional
	Data: jsii.String("data"),
	Trace: []*string{
		jsii.String("trace"),
	},
}

type NestedCloudAssemblyArtifact 

type NestedCloudAssemblyArtifact interface {
	CloudArtifact
	Assembly() CloudAssembly
	// Returns all the artifacts that this artifact depends on.
	Dependencies() *[]CloudArtifact
	// The relative directory name of the asset manifest.
	DirectoryName() *string
	// Display name.
	DisplayName() *string
	// Full path to the nested assembly directory.
	FullPath() *string
	// An identifier that shows where this artifact is located in the tree of nested assemblies, based on their manifests.
	//
	// Defaults to the normal
	// id. Should only be used in user interfaces.
	HierarchicalId() *string
	Id() *string
	// The artifact's manifest.
	Manifest() *cloudassemblyschema.ArtifactManifest
	// The set of messages extracted from the artifact's metadata.
	Messages() *[]*SynthesisMessage
	// The nested Assembly.
	NestedAssembly() CloudAssembly
	// Returns: all the metadata entries of a specific type in this artifact.
	FindMetadataByType(type_ *string) *[]*MetadataEntryResult
}

Asset manifest is a description of a set of assets which need to be built and published.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var cloudAssembly cloudAssembly

nestedCloudAssemblyArtifact := awscdk.Cx_api.NewNestedCloudAssemblyArtifact(cloudAssembly, jsii.String("name"), &ArtifactManifest{
	Type: awscdk.Cloud_assembly_schema.ArtifactType_NONE,

	// the properties below are optional
	Dependencies: []*string{
		jsii.String("dependencies"),
	},
	DisplayName: jsii.String("displayName"),
	Environment: jsii.String("environment"),
	Metadata: map[string][]metadataEntry{
		"metadataKey": []*metadataEntry{
			&metadataEntry{
				"type": jsii.String("type"),

				// the properties below are optional
				"data": jsii.String("data"),
				"trace": []*string{
					jsii.String("trace"),
				},
			},
		},
	},
	Properties: &AwsCloudFormationStackProperties{
		TemplateFile: jsii.String("templateFile"),

		// the properties below are optional
		AssumeRoleArn: jsii.String("assumeRoleArn"),
		AssumeRoleExternalId: jsii.String("assumeRoleExternalId"),
		BootstrapStackVersionSsmParameter: jsii.String("bootstrapStackVersionSsmParameter"),
		CloudFormationExecutionRoleArn: jsii.String("cloudFormationExecutionRoleArn"),
		LookupRole: &BootstrapRole{
			Arn: jsii.String("arn"),

			// the properties below are optional
			AssumeRoleExternalId: jsii.String("assumeRoleExternalId"),
			BootstrapStackVersionSsmParameter: jsii.String("bootstrapStackVersionSsmParameter"),
			RequiresBootstrapStackVersion: jsii.Number(123),
		},
		Parameters: map[string]*string{
			"parametersKey": jsii.String("parameters"),
		},
		RequiresBootstrapStackVersion: jsii.Number(123),
		StackName: jsii.String("stackName"),
		StackTemplateAssetObjectUrl: jsii.String("stackTemplateAssetObjectUrl"),
		Tags: map[string]*string{
			"tagsKey": jsii.String("tags"),
		},
		TerminationProtection: jsii.Boolean(false),
		ValidateOnSynth: jsii.Boolean(false),
	},
})

func NewNestedCloudAssemblyArtifact 

func NewNestedCloudAssemblyArtifact(assembly CloudAssembly, name *string, artifact *cloudassemblyschema.ArtifactManifest) NestedCloudAssemblyArtifact

type SecurityGroupContextResponse 

type SecurityGroupContextResponse struct {
	// Whether the security group allows all outbound traffic.
	//
	// This will be true
	// when the security group has all-protocol egress permissions to access both
	// `0.0.0.0/0` and `::/0`.
	AllowAllOutbound *bool `field:"required" json:"allowAllOutbound" yaml:"allowAllOutbound"`
	// The security group's id.
	SecurityGroupId *string `field:"required" json:"securityGroupId" yaml:"securityGroupId"`
}

Properties of a discovered SecurityGroup.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

securityGroupContextResponse := &SecurityGroupContextResponse{
	AllowAllOutbound: jsii.Boolean(false),
	SecurityGroupId: jsii.String("securityGroupId"),
}

type SynthesisMessage 

type SynthesisMessage struct {
	Entry *cloudassemblyschema.MetadataEntry `field:"required" json:"entry" yaml:"entry"`
	Id    *string                            `field:"required" json:"id" yaml:"id"`
	Level SynthesisMessageLevel              `field:"required" json:"level" yaml:"level"`
}

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

synthesisMessage := &SynthesisMessage{
	Entry: &MetadataEntry{
		Type: jsii.String("type"),

		// the properties below are optional
		Data: jsii.String("data"),
		Trace: []*string{
			jsii.String("trace"),
		},
	},
	Id: jsii.String("id"),
	Level: awscdk.Cx_api.SynthesisMessageLevel_INFO,
}

type SynthesisMessageLevel 

type SynthesisMessageLevel string
const (
	SynthesisMessageLevel_INFO    SynthesisMessageLevel = "INFO"
	SynthesisMessageLevel_WARNING SynthesisMessageLevel = "WARNING"
	SynthesisMessageLevel_ERROR   SynthesisMessageLevel = "ERROR"
)

type TreeCloudArtifact 

type TreeCloudArtifact interface {
	CloudArtifact
	Assembly() CloudAssembly
	// Returns all the artifacts that this artifact depends on.
	Dependencies() *[]CloudArtifact
	File() *string
	// An identifier that shows where this artifact is located in the tree of nested assemblies, based on their manifests.
	//
	// Defaults to the normal
	// id. Should only be used in user interfaces.
	HierarchicalId() *string
	Id() *string
	// The artifact's manifest.
	Manifest() *cloudassemblyschema.ArtifactManifest
	// The set of messages extracted from the artifact's metadata.
	Messages() *[]*SynthesisMessage
	// Returns: all the metadata entries of a specific type in this artifact.
	FindMetadataByType(type_ *string) *[]*MetadataEntryResult
}

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var cloudAssembly cloudAssembly

treeCloudArtifact := awscdk.Cx_api.NewTreeCloudArtifact(cloudAssembly, jsii.String("name"), &ArtifactManifest{
	Type: awscdk.Cloud_assembly_schema.ArtifactType_NONE,

	// the properties below are optional
	Dependencies: []*string{
		jsii.String("dependencies"),
	},
	DisplayName: jsii.String("displayName"),
	Environment: jsii.String("environment"),
	Metadata: map[string][]metadataEntry{
		"metadataKey": []*metadataEntry{
			&metadataEntry{
				"type": jsii.String("type"),

				// the properties below are optional
				"data": jsii.String("data"),
				"trace": []*string{
					jsii.String("trace"),
				},
			},
		},
	},
	Properties: &AwsCloudFormationStackProperties{
		TemplateFile: jsii.String("templateFile"),

		// the properties below are optional
		AssumeRoleArn: jsii.String("assumeRoleArn"),
		AssumeRoleExternalId: jsii.String("assumeRoleExternalId"),
		BootstrapStackVersionSsmParameter: jsii.String("bootstrapStackVersionSsmParameter"),
		CloudFormationExecutionRoleArn: jsii.String("cloudFormationExecutionRoleArn"),
		LookupRole: &BootstrapRole{
			Arn: jsii.String("arn"),

			// the properties below are optional
			AssumeRoleExternalId: jsii.String("assumeRoleExternalId"),
			BootstrapStackVersionSsmParameter: jsii.String("bootstrapStackVersionSsmParameter"),
			RequiresBootstrapStackVersion: jsii.Number(123),
		},
		Parameters: map[string]*string{
			"parametersKey": jsii.String("parameters"),
		},
		RequiresBootstrapStackVersion: jsii.Number(123),
		StackName: jsii.String("stackName"),
		StackTemplateAssetObjectUrl: jsii.String("stackTemplateAssetObjectUrl"),
		Tags: map[string]*string{
			"tagsKey": jsii.String("tags"),
		},
		TerminationProtection: jsii.Boolean(false),
		ValidateOnSynth: jsii.Boolean(false),
	},
})

func NewTreeCloudArtifact 

func NewTreeCloudArtifact(assembly CloudAssembly, name *string, artifact *cloudassemblyschema.ArtifactManifest) TreeCloudArtifact

type VpcContextResponse 

type VpcContextResponse struct {
	// AZs.
	AvailabilityZones *[]*string `field:"required" json:"availabilityZones" yaml:"availabilityZones"`
	// VPC id.
	VpcId *string `field:"required" json:"vpcId" yaml:"vpcId"`
	// IDs of all isolated subnets.
	//
	// Element count: #(availabilityZones) · #(isolatedGroups).
	IsolatedSubnetIds *[]*string `field:"optional" json:"isolatedSubnetIds" yaml:"isolatedSubnetIds"`
	// Name of isolated subnet groups.
	//
	// Element count: #(isolatedGroups).
	IsolatedSubnetNames *[]*string `field:"optional" json:"isolatedSubnetNames" yaml:"isolatedSubnetNames"`
	// Route Table IDs of isolated subnet groups.
	//
	// Element count: #(availabilityZones) · #(isolatedGroups).
	IsolatedSubnetRouteTableIds *[]*string `field:"optional" json:"isolatedSubnetRouteTableIds" yaml:"isolatedSubnetRouteTableIds"`
	// The ID of the AWS account that owns the VPC.
	// Default: the account id of the parent stack.
	//
	OwnerAccountId *string `field:"optional" json:"ownerAccountId" yaml:"ownerAccountId"`
	// IDs of all private subnets.
	//
	// Element count: #(availabilityZones) · #(privateGroups).
	PrivateSubnetIds *[]*string `field:"optional" json:"privateSubnetIds" yaml:"privateSubnetIds"`
	// Name of private subnet groups.
	//
	// Element count: #(privateGroups).
	PrivateSubnetNames *[]*string `field:"optional" json:"privateSubnetNames" yaml:"privateSubnetNames"`
	// Route Table IDs of private subnet groups.
	//
	// Element count: #(availabilityZones) · #(privateGroups).
	PrivateSubnetRouteTableIds *[]*string `field:"optional" json:"privateSubnetRouteTableIds" yaml:"privateSubnetRouteTableIds"`
	// IDs of all public subnets.
	//
	// Element count: #(availabilityZones) · #(publicGroups).
	PublicSubnetIds *[]*string `field:"optional" json:"publicSubnetIds" yaml:"publicSubnetIds"`
	// Name of public subnet groups.
	//
	// Element count: #(publicGroups).
	PublicSubnetNames *[]*string `field:"optional" json:"publicSubnetNames" yaml:"publicSubnetNames"`
	// Route Table IDs of public subnet groups.
	//
	// Element count: #(availabilityZones) · #(publicGroups).
	PublicSubnetRouteTableIds *[]*string `field:"optional" json:"publicSubnetRouteTableIds" yaml:"publicSubnetRouteTableIds"`
	// The region in which the VPC is in.
	// Default: - Region of the parent stack.
	//
	Region *string `field:"optional" json:"region" yaml:"region"`
	// The subnet groups discovered for the given VPC.
	//
	// Unlike the above properties, this will include asymmetric subnets,
	// if the VPC has any.
	// This property will only be populated if `VpcContextQuery.returnAsymmetricSubnets`
	// is true.
	// Default: - no subnet groups will be returned unless `VpcContextQuery.returnAsymmetricSubnets` is true
	//
	SubnetGroups *[]*VpcSubnetGroup `field:"optional" json:"subnetGroups" yaml:"subnetGroups"`
	// VPC cidr.
	// Default: - CIDR information not available.
	//
	VpcCidrBlock *string `field:"optional" json:"vpcCidrBlock" yaml:"vpcCidrBlock"`
	// The VPN gateway ID.
	VpnGatewayId *string `field:"optional" json:"vpnGatewayId" yaml:"vpnGatewayId"`
}

Properties of a discovered VPC.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

vpcContextResponse := &VpcContextResponse{
	AvailabilityZones: []*string{
		jsii.String("availabilityZones"),
	},
	VpcId: jsii.String("vpcId"),

	// the properties below are optional
	IsolatedSubnetIds: []*string{
		jsii.String("isolatedSubnetIds"),
	},
	IsolatedSubnetNames: []*string{
		jsii.String("isolatedSubnetNames"),
	},
	IsolatedSubnetRouteTableIds: []*string{
		jsii.String("isolatedSubnetRouteTableIds"),
	},
	OwnerAccountId: jsii.String("ownerAccountId"),
	PrivateSubnetIds: []*string{
		jsii.String("privateSubnetIds"),
	},
	PrivateSubnetNames: []*string{
		jsii.String("privateSubnetNames"),
	},
	PrivateSubnetRouteTableIds: []*string{
		jsii.String("privateSubnetRouteTableIds"),
	},
	PublicSubnetIds: []*string{
		jsii.String("publicSubnetIds"),
	},
	PublicSubnetNames: []*string{
		jsii.String("publicSubnetNames"),
	},
	PublicSubnetRouteTableIds: []*string{
		jsii.String("publicSubnetRouteTableIds"),
	},
	Region: jsii.String("region"),
	SubnetGroups: []vpcSubnetGroup{
		&vpcSubnetGroup{
			Name: jsii.String("name"),
			Subnets: []vpcSubnet{
				&vpcSubnet{
					AvailabilityZone: jsii.String("availabilityZone"),
					RouteTableId: jsii.String("routeTableId"),
					SubnetId: jsii.String("subnetId"),

					// the properties below are optional
					Cidr: jsii.String("cidr"),
				},
			},
			Type: awscdk.Cx_api.VpcSubnetGroupType_PUBLIC,
		},
	},
	VpcCidrBlock: jsii.String("vpcCidrBlock"),
	VpnGatewayId: jsii.String("vpnGatewayId"),
}

type VpcSubnet 

type VpcSubnet struct {
	// The code of the availability zone this subnet is in (for example, 'us-west-2a').
	AvailabilityZone *string `field:"required" json:"availabilityZone" yaml:"availabilityZone"`
	// The identifier of the route table for this subnet.
	RouteTableId *string `field:"required" json:"routeTableId" yaml:"routeTableId"`
	// The identifier of the subnet.
	SubnetId *string `field:"required" json:"subnetId" yaml:"subnetId"`
	// CIDR range of the subnet.
	// Default: - CIDR information not available.
	//
	Cidr *string `field:"optional" json:"cidr" yaml:"cidr"`
}

A subnet representation that the VPC provider uses.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

vpcSubnet := &VpcSubnet{
	AvailabilityZone: jsii.String("availabilityZone"),
	RouteTableId: jsii.String("routeTableId"),
	SubnetId: jsii.String("subnetId"),

	// the properties below are optional
	Cidr: jsii.String("cidr"),
}

type VpcSubnetGroup 

type VpcSubnetGroup struct {
	// The name of the subnet group, determined by looking at the tags of of the subnets that belong to it.
	Name *string `field:"required" json:"name" yaml:"name"`
	// The subnets that are part of this group.
	//
	// There is no condition that the subnets have to be symmetric
	// in the group.
	Subnets *[]*VpcSubnet `field:"required" json:"subnets" yaml:"subnets"`
	// The type of the subnet group.
	Type VpcSubnetGroupType `field:"required" json:"type" yaml:"type"`
}

A group of subnets returned by the VPC provider.

The included subnets do NOT have to be symmetric!

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

vpcSubnetGroup := &VpcSubnetGroup{
	Name: jsii.String("name"),
	Subnets: []vpcSubnet{
		&vpcSubnet{
			AvailabilityZone: jsii.String("availabilityZone"),
			RouteTableId: jsii.String("routeTableId"),
			SubnetId: jsii.String("subnetId"),

			// the properties below are optional
			Cidr: jsii.String("cidr"),
		},
	},
	Type: awscdk.Cx_api.VpcSubnetGroupType_PUBLIC,
}

type VpcSubnetGroupType 

type VpcSubnetGroupType string

The type of subnet group.

Same as SubnetType in the aws-cdk-lib/aws-ec2 package, but we can't use that because of cyclical dependencies. 

const (
	// Public subnet group type.
	VpcSubnetGroupType_PUBLIC VpcSubnetGroupType = "PUBLIC"
	// Private subnet group type.
	VpcSubnetGroupType_PRIVATE VpcSubnetGroupType = "PRIVATE"
	// Isolated subnet group type.
	VpcSubnetGroupType_ISOLATED VpcSubnetGroupType = "ISOLATED"
)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.