Documentation
¶
Index ¶
- func AwsLoggingStack_IsConstruct(x interface{}) *bool
- func AwsLoggingStack_IsStack(x interface{}) *bool
- func AwsLoggingStack_Of(construct constructs.IConstruct) awscdk.Stack
- func NewAwsLoggingStack_Override(a AwsLoggingStack, scope constructs.Construct, id *string, ...)
- type AwsLoggingStack
- type AwsLoggingStackProps
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func AwsLoggingStack_IsConstruct ¶
func AwsLoggingStack_IsConstruct(x interface{}) *bool
Checks if `x` is a construct.
Returns: true if `x` is an object created from a class which extends `Construct`. Deprecated: use `x instanceof Construct` instead.
func AwsLoggingStack_IsStack ¶
func AwsLoggingStack_IsStack(x interface{}) *bool
Return whether the given object is a Stack.
We do attribute detection since we can't reliably use 'instanceof'.
func AwsLoggingStack_Of ¶
func AwsLoggingStack_Of(construct constructs.IConstruct) awscdk.Stack
Looks up the first stack scope in which `construct` is defined.
Fails if there is no stack up the tree.
func NewAwsLoggingStack_Override ¶
func NewAwsLoggingStack_Override(a AwsLoggingStack, scope constructs.Construct, id *string, props *AwsLoggingStackProps)
Types ¶
type AwsLoggingStack ¶
type AwsLoggingStack interface {
awscdk.Stack
// The AWS account into which this stack will be deployed.
//
// This value is resolved according to the following rules:
//
// 1. The value provided to `env.account` when the stack is defined. This can
// either be a concrete account (e.g. `585695031111`) or the
// `Aws.ACCOUNT_ID` token.
// 3. `Aws.ACCOUNT_ID`, which represents the CloudFormation intrinsic reference
// `{ "Ref": "AWS::AccountId" }` encoded as a string token.
//
// Preferably, you should use the return value as an opaque string and not
// attempt to parse it to implement your logic. If you do, you must first
// check that it is a concerete value an not an unresolved token. If this
// value is an unresolved token (`Token.isUnresolved(stack.account)` returns
// `true`), this implies that the user wishes that this stack will synthesize
// into a **account-agnostic template**. In this case, your code should either
// fail (throw an error, emit a synth error using `Annotations.of(construct).addError()`) or
// implement some other region-agnostic behavior.
Account() *string
AlbLogsBucket() s3buckets.AlbLogsBucket
// The ID of the cloud assembly artifact for this stack.
ArtifactId() *string
// Returns the list of AZs that are available in the AWS environment (account/region) associated with this stack.
//
// If the stack is environment-agnostic (either account and/or region are
// tokens), this property will return an array with 2 tokens that will resolve
// at deploy-time to the first two availability zones returned from CloudFormation's
// `Fn::GetAZs` intrinsic function.
//
// If they are not available in the context, returns a set of dummy values and
// reports them as missing, and let the CLI resolve them by calling EC2
// `DescribeAvailabilityZones` on the target environment.
//
// To specify a different strategy for selecting availability zones override this method.
AvailabilityZones() *[]*string
// Indicates whether the stack requires bundling or not.
BundlingRequired() *bool
CloudfrontLogsBucket() s3buckets.CloudfrontLogsBucket
CloudtrailLogsBucket() s3buckets.CloudtrailBucket
Database() glue.Database
DatabaseName() *string
// Return the stacks this stack depends on.
Dependencies() *[]awscdk.Stack
// The environment coordinates in which this stack is deployed.
//
// In the form
// `aws://account/region`. Use `stack.account` and `stack.region` to obtain
// the specific values, no need to parse.
//
// You can use this value to determine if two stacks are targeting the same
// environment.
//
// If either `stack.account` or `stack.region` are not concrete values (e.g.
// `Aws.ACCOUNT_ID` or `Aws.REGION`) the special strings `unknown-account` and/or
// `unknown-region` will be used respectively to indicate this stack is
// region/account-agnostic.
Environment() *string
FlowLogsBucket() s3buckets.FlowLogsBucket
FlowLogsFormat() ec2.FlowLogFormat
FriendlyQueryNames() *bool
// Indicates if this is a nested stack, in which case `parentStack` will include a reference to it's parent.
Nested() *bool
// If this is a nested stack, returns it's parent stack.
NestedStackParent() awscdk.Stack
// If this is a nested stack, this represents its `AWS::CloudFormation::Stack` resource.
//
// `undefined` for top-level (non-nested) stacks.
NestedStackResource() awscdk.CfnResource
// The tree node.
Node() constructs.Node
// Returns the list of notification Amazon Resource Names (ARNs) for the current stack.
NotificationArns() *[]*string
// The partition in which this stack is defined.
Partition() *string
// The AWS region into which this stack will be deployed (e.g. `us-west-2`).
//
// This value is resolved according to the following rules:
//
// 1. The value provided to `env.region` when the stack is defined. This can
// either be a concerete region (e.g. `us-west-2`) or the `Aws.REGION`
// token.
// 3. `Aws.REGION`, which is represents the CloudFormation intrinsic reference
// `{ "Ref": "AWS::Region" }` encoded as a string token.
//
// Preferably, you should use the return value as an opaque string and not
// attempt to parse it to implement your logic. If you do, you must first
// check that it is a concerete value an not an unresolved token. If this
// value is an unresolved token (`Token.isUnresolved(stack.region)` returns
// `true`), this implies that the user wishes that this stack will synthesize
// into a **region-agnostic template**. In this case, your code should either
// fail (throw an error, emit a synth error using `Annotations.of(construct).addError()`) or
// implement some other region-agnostic behavior.
Region() *string
S3AccessLogsBucket() s3buckets.S3AccessLogsBucket
SesLogsBucket() s3buckets.SesLogsBucket
// The ID of the stack.
//
// Example:
// // After resolving, looks like
// 'arn:aws:cloudformation:us-west-2:123456789012:stack/teststack/51af3dc0-da77-11e4-872e-1234567db123'
//
StackId() *string
// The concrete CloudFormation physical stack name.
//
// This is either the name defined explicitly in the `stackName` prop or
// allocated based on the stack's location in the construct tree. Stacks that
// are directly defined under the app use their construct `id` as their stack
// name. Stacks that are defined deeper within the tree will use a hashed naming
// scheme based on the construct path to ensure uniqueness.
//
// If you wish to obtain the deploy-time AWS::StackName intrinsic,
// you can use `Aws.STACK_NAME` directly.
StackName() *string
StandardizeNames() *bool
// Synthesis method for this stack.
Synthesizer() awscdk.IStackSynthesizer
// Tags to be applied to the stack.
Tags() awscdk.TagManager
// The name of the CloudFormation template file emitted to the output directory during synthesis.
//
// Example value: `MyStack.template.json`
TemplateFile() *string
// Options for CloudFormation template (like version, transform, description).
TemplateOptions() awscdk.ITemplateOptions
// Whether termination protection is enabled for this stack.
TerminationProtection() *bool
// The Amazon domain suffix for the region in which this stack is defined.
UrlSuffix() *string
WafLogsBucket() s3buckets.WafLogsBucket
// Add a dependency between this stack and another stack.
//
// This can be used to define dependencies between any two stacks within an
// app, and also supports nested stacks.
AddDependency(target awscdk.Stack, reason *string)
// Adds an arbitary key-value pair, with information you want to record about the stack.
//
// These get translated to the Metadata section of the generated template.
// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/metadata-section-structure.html
//
AddMetadata(key *string, value interface{})
// Add a Transform to this stack. A Transform is a macro that AWS CloudFormation uses to process your template.
//
// Duplicate values are removed when stack is synthesized.
//
// Example:
// declare const stack: Stack;
//
// stack.addTransform('AWS::Serverless-2016-10-31')
//
// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-section-structure.html
//
AddTransform(transform *string)
// Returns the naming scheme used to allocate logical IDs.
//
// By default, uses
// the `HashedAddressingScheme` but this method can be overridden to customize
// this behavior.
//
// In order to make sure logical IDs are unique and stable, we hash the resource
// construct tree path (i.e. toplevel/secondlevel/.../myresource) and add it as
// a suffix to the path components joined without a separator (CloudFormation
// IDs only allow alphanumeric characters).
//
// The result will be:
//
// <path.join(”)><md5(path.join('/')>
// "human" "hash"
//
// If the "human" part of the ID exceeds 240 characters, we simply trim it so
// the total ID doesn't exceed CloudFormation's 255 character limit.
//
// We only take 8 characters from the md5 hash (0.000005 chance of collision).
//
// Special cases:
//
// - If the path only contains a single component (i.e. it's a top-level
// resource), we won't add the hash to it. The hash is not needed for
// disamiguation and also, it allows for a more straightforward migration an
// existing CloudFormation template to a CDK stack without logical ID changes
// (or renames).
// - For aesthetic reasons, if the last components of the path are the same
// (i.e. `L1/L2/Pipeline/Pipeline`), they will be de-duplicated to make the
// resulting human portion of the ID more pleasing: `L1L2Pipeline<HASH>`
// instead of `L1L2PipelinePipeline<HASH>`
// - If a component is named "Default" it will be omitted from the path. This
// allows refactoring higher level abstractions around constructs without affecting
// the IDs of already deployed resources.
// - If a component is named "Resource" it will be omitted from the user-visible
// path, but included in the hash. This reduces visual noise in the human readable
// part of the identifier.
AllocateLogicalId(cfnElement awscdk.CfnElement) *string
// Create a CloudFormation Export for a value.
//
// Returns a string representing the corresponding `Fn.importValue()`
// expression for this Export. You can control the name for the export by
// passing the `name` option.
//
// If you don't supply a value for `name`, the value you're exporting must be
// a Resource attribute (for example: `bucket.bucketName`) and it will be
// given the same name as the automatic cross-stack reference that would be created
// if you used the attribute in another Stack.
//
// One of the uses for this method is to *remove* the relationship between
// two Stacks established by automatic cross-stack references. It will
// temporarily ensure that the CloudFormation Export still exists while you
// remove the reference from the consuming stack. After that, you can remove
// the resource and the manual export.
//
// ## Example
//
// Here is how the process works. Let's say there are two stacks,
// `producerStack` and `consumerStack`, and `producerStack` has a bucket
// called `bucket`, which is referenced by `consumerStack` (perhaps because
// an AWS Lambda Function writes into it, or something like that).
//
// It is not safe to remove `producerStack.bucket` because as the bucket is being
// deleted, `consumerStack` might still be using it.
//
// Instead, the process takes two deployments:
//
// ### Deployment 1: break the relationship
//
// - Make sure `consumerStack` no longer references `bucket.bucketName` (maybe the consumer
// stack now uses its own bucket, or it writes to an AWS DynamoDB table, or maybe you just
// remove the Lambda Function altogether).
// - In the `ProducerStack` class, call `this.exportValue(this.bucket.bucketName)`. This
// will make sure the CloudFormation Export continues to exist while the relationship
// between the two stacks is being broken.
// - Deploy (this will effectively only change the `consumerStack`, but it's safe to deploy both).
//
// ### Deployment 2: remove the bucket resource
//
// - You are now free to remove the `bucket` resource from `producerStack`.
// - Don't forget to remove the `exportValue()` call as well.
// - Deploy again (this time only the `producerStack` will be changed -- the bucket will be deleted).
ExportValue(exportedValue interface{}, options *awscdk.ExportValueOptions) *string
// Creates an ARN from components.
//
// If `partition`, `region` or `account` are not specified, the stack's
// partition, region and account will be used.
//
// If any component is the empty string, an empty string will be inserted
// into the generated ARN at the location that component corresponds to.
//
// The ARN will be formatted as follows:
//
// arn:{partition}:{service}:{region}:{account}:{resource}{sep}{resource-name}
//
// The required ARN pieces that are omitted will be taken from the stack that
// the 'scope' is attached to. If all ARN pieces are supplied, the supplied scope
// can be 'undefined'.
FormatArn(components *awscdk.ArnComponents) *string
// Allocates a stack-unique CloudFormation-compatible logical identity for a specific resource.
//
// This method is called when a `CfnElement` is created and used to render the
// initial logical identity of resources. Logical ID renames are applied at
// this stage.
//
// This method uses the protected method `allocateLogicalId` to render the
// logical ID for an element. To modify the naming scheme, extend the `Stack`
// class and override this method.
GetLogicalId(element awscdk.CfnElement) *string
// Look up a fact value for the given fact for the region of this stack.
//
// Will return a definite value only if the region of the current stack is resolved.
// If not, a lookup map will be added to the stack and the lookup will be done at
// CDK deployment time.
//
// What regions will be included in the lookup map is controlled by the
// `@aws-cdk/core:target-partitions` context value: it must be set to a list
// of partitions, and only regions from the given partitions will be included.
// If no such context key is set, all regions will be included.
//
// This function is intended to be used by construct library authors. Application
// builders can rely on the abstractions offered by construct libraries and do
// not have to worry about regional facts.
//
// If `defaultValue` is not given, it is an error if the fact is unknown for
// the given region.
RegionalFact(factName *string, defaultValue *string) *string
// Rename a generated logical identities.
//
// To modify the naming scheme strategy, extend the `Stack` class and
// override the `allocateLogicalId` method.
RenameLogicalId(oldId *string, newId *string)
// Indicate that a context key was expected.
//
// Contains instructions which will be emitted into the cloud assembly on how
// the key should be supplied.
ReportMissingContextKey(report *cloudassemblyschema.MissingContext)
// Resolve a tokenized value in the context of the current stack.
Resolve(obj interface{}) interface{}
// Splits the provided ARN into its components.
//
// Works both if 'arn' is a string like 'arn:aws:s3:::bucket',
// and a Token representing a dynamic CloudFormation expression
// (in which case the returned components will also be dynamic CloudFormation expressions,
// encoded as Tokens).
SplitArn(arn *string, arnFormat awscdk.ArnFormat) *awscdk.ArnComponents
// Convert an object, potentially containing tokens, to a JSON string.
ToJsonString(obj interface{}, space *float64) *string
// Returns a string representation of this construct.
ToString() *string
}
Creates a demo web service running in Fargate that is accessible through an application load balancer.
The demo service serves a generic "Welcome to nginx" page.
The service can be accessed remotely using ECS Exec. For details see the documentation at: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-exec.html#ecs-exec-running-commands
func NewAwsLoggingStack ¶
func NewAwsLoggingStack(scope constructs.Construct, id *string, props *AwsLoggingStackProps) AwsLoggingStack
type AwsLoggingStackProps ¶
type AwsLoggingStackProps struct {
// Include runtime versioning information in this Stack.
AnalyticsReporting *bool `field:"optional" json:"analyticsReporting" yaml:"analyticsReporting"`
// A description of the stack.
Description *string `field:"optional" json:"description" yaml:"description"`
// The AWS environment (account/region) where this stack will be deployed.
//
// Set the `region`/`account` fields of `env` to either a concrete value to
// select the indicated environment (recommended for production stacks), or to
// the values of environment variables
// `CDK_DEFAULT_REGION`/`CDK_DEFAULT_ACCOUNT` to let the target environment
// depend on the AWS credentials/configuration that the CDK CLI is executed
// under (recommended for development stacks).
//
// If the `Stack` is instantiated inside a `Stage`, any undefined
// `region`/`account` fields from `env` will default to the same field on the
// encompassing `Stage`, if configured there.
//
// If either `region` or `account` are not set nor inherited from `Stage`, the
// Stack will be considered "*environment-agnostic*"". Environment-agnostic
// stacks can be deployed to any environment but may not be able to take
// advantage of all features of the CDK. For example, they will not be able to
// use environmental context lookups such as `ec2.Vpc.fromLookup` and will not
// automatically translate Service Principals to the right format based on the
// environment's AWS partition, and other such enhancements.
//
// Example:
// // Use a concrete account and region to deploy this stack to:
// // `.account` and `.region` will simply return these values.
// new Stack(app, 'Stack1', {
// env: {
// account: '123456789012',
// region: 'us-east-1'
// },
// });
//
// // Use the CLI's current credentials to determine the target environment:
// // `.account` and `.region` will reflect the account+region the CLI
// // is configured to use (based on the user CLI credentials)
// new Stack(app, 'Stack2', {
// env: {
// account: process.env.CDK_DEFAULT_ACCOUNT,
// region: process.env.CDK_DEFAULT_REGION
// },
// });
//
// // Define multiple stacks stage associated with an environment
// const myStage = new Stage(app, 'MyStage', {
// env: {
// account: '123456789012',
// region: 'us-east-1'
// }
// });
//
// // both of these stacks will use the stage's account/region:
// // `.account` and `.region` will resolve to the concrete values as above
// new MyStack(myStage, 'Stack1');
// new YourStack(myStage, 'Stack2');
//
// // Define an environment-agnostic stack:
// // `.account` and `.region` will resolve to `{ "Ref": "AWS::AccountId" }` and `{ "Ref": "AWS::Region" }` respectively.
// // which will only resolve to actual values by CloudFormation during deployment.
// new MyStack(app, 'Stack1');
//
Env *awscdk.Environment `field:"optional" json:"env" yaml:"env"`
// Name to deploy the stack with.
StackName *string `field:"optional" json:"stackName" yaml:"stackName"`
// Synthesis method to use while deploying this stack.
Synthesizer awscdk.IStackSynthesizer `field:"optional" json:"synthesizer" yaml:"synthesizer"`
// Stack tags that will be applied to all the taggable resources and the stack itself.
Tags *map[string]*string `field:"optional" json:"tags" yaml:"tags"`
// Whether to enable termination protection for this stack.
TerminationProtection *bool `field:"optional" json:"terminationProtection" yaml:"terminationProtection"`
AlbLogsBucket s3buckets.AlbLogsBucket `field:"optional" json:"albLogsBucket" yaml:"albLogsBucket"`
CloudfrontLogsBucket s3buckets.CloudfrontLogsBucket `field:"optional" json:"cloudfrontLogsBucket" yaml:"cloudfrontLogsBucket"`
CloudtrailLogsBucket s3buckets.CloudtrailBucket `field:"optional" json:"cloudtrailLogsBucket" yaml:"cloudtrailLogsBucket"`
DatabaseName *string `field:"optional" json:"databaseName" yaml:"databaseName"`
FlowLogsBucket s3buckets.FlowLogsBucket `field:"optional" json:"flowLogsBucket" yaml:"flowLogsBucket"`
FlowLogsFormat ec2.FlowLogFormat `field:"optional" json:"flowLogsFormat" yaml:"flowLogsFormat"`
FriendlyQueryNames *bool `field:"optional" json:"friendlyQueryNames" yaml:"friendlyQueryNames"`
SesLogsBucket s3buckets.SesLogsBucket `field:"optional" json:"sesLogsBucket" yaml:"sesLogsBucket"`
StandardizeNames *bool `field:"optional" json:"standardizeNames" yaml:"standardizeNames"`
WafLogsBucket s3buckets.WafLogsBucket `field:"optional" json:"wafLogsBucket" yaml:"wafLogsBucket"`
}
Configuration for the demo service stack.
Source Files
¶
Directories
Click to show internal directories.
Click to hide internal directories.