pipelines

package
v2.0.0-rc.19 Latest Latest
Warning

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

 Go to latest Published: Aug 25, 2021 License: Apache-2.0 Imports: 18 Imported by: 5

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func CdkPipeline_IsConstruct 

func CdkPipeline_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 CdkStage_IsConstruct 

func CdkStage_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 CodePipeline_IsConstruct 

func CodePipeline_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 NewArtifactMap_Override 

func NewArtifactMap_Override(a ArtifactMap)

Experimental.

func NewCdkPipeline_Override 

func NewCdkPipeline_Override(c CdkPipeline, scope constructs.Construct, id *string, props *CdkPipelineProps)

Experimental.

func NewCdkStage_Override 

func NewCdkStage_Override(c CdkStage, scope constructs.Construct, id *string, props *CdkStageProps)

Experimental.

func NewCodeBuildStep_Override 

func NewCodeBuildStep_Override(c CodeBuildStep, id *string, props *CodeBuildStepProps)

Experimental.

func NewCodePipelineSource_Override 

func NewCodePipelineSource_Override(c CodePipelineSource, id *string)

Experimental.

func NewCodePipeline_Override 

func NewCodePipeline_Override(c CodePipeline, scope constructs.Construct, id *string, props *CodePipelineProps)

Experimental.

func NewConfirmPermissionsBroadening_Override 

func NewConfirmPermissionsBroadening_Override(c ConfirmPermissionsBroadening, id *string, props *PermissionsBroadeningCheckProps)

Experimental.

func NewDeployCdkStackAction_Override 

func NewDeployCdkStackAction_Override(d DeployCdkStackAction, props *DeployCdkStackActionProps)

Experimental.

func NewDockerCredential_Override 

func NewDockerCredential_Override(d DockerCredential, usages *[]DockerCredentialUsage)

Experimental.

func NewFileSet_Override 

func NewFileSet_Override(f FileSet, id *string, producer Step)

Experimental.

func NewManualApprovalStep_Override 

func NewManualApprovalStep_Override(m ManualApprovalStep, id *string, props *ManualApprovalStepProps)

Experimental.

func NewPipelineBase_Override 

func NewPipelineBase_Override(p PipelineBase, scope constructs.Construct, id *string, props *PipelineBaseProps)

Experimental.

func NewPublishAssetsAction_Override 

func NewPublishAssetsAction_Override(p PublishAssetsAction, scope constructs.Construct, id *string, props *PublishAssetsActionProps)

Experimental.

func NewShellScriptAction_Override 

func NewShellScriptAction_Override(s ShellScriptAction, props *ShellScriptActionProps)

Experimental.

func NewShellStep_Override 

func NewShellStep_Override(s ShellStep, id *string, props *ShellStepProps)

Experimental.

func NewSimpleSynthAction_Override 

func NewSimpleSynthAction_Override(s SimpleSynthAction, props *SimpleSynthActionProps)

Experimental.

func NewStackOutput_Override 

func NewStackOutput_Override(s StackOutput, artifactFile awscodepipeline.ArtifactPath, outputName *string)

Build a StackOutput from a known artifact and an output name. Experimental.

func NewStep_Override 

func NewStep_Override(s Step, id *string)

Experimental.

func NewUpdatePipelineAction_Override 

func NewUpdatePipelineAction_Override(u UpdatePipelineAction, scope constructs.Construct, id *string, props *UpdatePipelineActionProps)

Experimental.

func NewWave_Override 

func NewWave_Override(w Wave, id *string, props *WaveProps)

Experimental.

func PipelineBase_IsConstruct 

func PipelineBase_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 PublishAssetsAction_IsConstruct 

func PublishAssetsAction_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 UpdatePipelineAction_IsConstruct 

func UpdatePipelineAction_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

Types

type AddManualApprovalOptions 

type AddManualApprovalOptions struct {
	// The name of the manual approval action.
	// Experimental.
	ActionName *string `json:"actionName"`
	// The runOrder for this action.
	// Experimental.
	RunOrder *float64 `json:"runOrder"`
}

Options for addManualApproval. Experimental.

type AddStackOptions 

type AddStackOptions struct {
	// Base runorder.
	// Experimental.
	ExecuteRunOrder *float64 `json:"executeRunOrder"`
	// Base runorder.
	// Experimental.
	RunOrder *float64 `json:"runOrder"`
}

Additional options for adding a stack deployment. Experimental.

type AddStageOptions 

type AddStageOptions struct {
	// Runs a `cdk diff --security-only --fail` to pause the pipeline if there are any security changes.
	//
	// If the stage is configured with `confirmBroadeningPermissions` enabled, you can use this
	// property to override the stage configuration. For example, Pipeline Stage
	// "Prod" has confirmBroadeningPermissions enabled, with applications "A", "B", "C". All three
	// applications will run a security check, but if we want to disable the one for "C",
	// we run `stage.addApplication(C, { confirmBroadeningPermissions: false })` to override the pipeline
	// stage behavior.
	//
	// Adds 1 to the run order space.
	// Experimental.
	ConfirmBroadeningPermissions *bool `json:"confirmBroadeningPermissions"`
	// Optional SNS topic to send notifications to when the security check registers changes within the application.
	// Experimental.
	SecurityNotificationTopic awssns.ITopic `json:"securityNotificationTopic"`
	// Add room for extra actions.
	//
	// You can use this to make extra room in the runOrder sequence between the
	// changeset 'prepare' and 'execute' actions and insert your own actions there.
	// Experimental.
	ExtraRunOrderSpace *float64 `json:"extraRunOrderSpace"`
	// Add manual approvals before executing change sets.
	//
	// This gives humans the opportunity to confirm the change set looks alright
	// before deploying it.
	// Experimental.
	ManualApprovals *bool `json:"manualApprovals"`
}

Options for adding an application stage to a pipeline. Experimental.

type AddStageOpts 

type AddStageOpts struct {
	// Additional steps to run after all of the stacks in the stage.
	// Experimental.
	Post *[]Step `json:"post"`
	// Additional steps to run before any of the stacks in the stage.
	// Experimental.
	Pre *[]Step `json:"pre"`
}

Options to pass to `addStage`. Experimental.

type AdditionalArtifact 

type AdditionalArtifact struct {
	// Artifact to represent the build directory in the pipeline.
	// Experimental.
	Artifact awscodepipeline.Artifact `json:"artifact"`
	// Directory to be packaged.
	// Experimental.
	Directory *string `json:"directory"`
}

Specification of an additional artifact to generate. Experimental.

type ArtifactMap 

type ArtifactMap interface {
	ToCodePipeline(x FileSet) awscodepipeline.Artifact
}

Translate FileSets to CodePipeline Artifacts. Experimental.

func NewArtifactMap 

func NewArtifactMap() ArtifactMap

Experimental.

type AssetPublishingCommand 

type AssetPublishingCommand struct {
	// Asset identifier.
	// Experimental.
	AssetId *string `json:"assetId"`
	// Asset manifest path.
	// Experimental.
	AssetManifestPath *string `json:"assetManifestPath"`
	// ARN of the IAM Role used to publish this asset.
	// Experimental.
	AssetPublishingRoleArn *string `json:"assetPublishingRoleArn"`
	// Asset selector to pass to `cdk-assets`.
	// Experimental.
	AssetSelector *string `json:"assetSelector"`
	// Type of asset to publish.
	// Experimental.
	AssetType AssetType `json:"assetType"`
}

Instructions to publish certain assets. Experimental.

type AssetType 

type AssetType string

Type of the asset that is being published. Experimental. 

const (
	AssetType_FILE         AssetType = "FILE"
	AssetType_DOCKER_IMAGE AssetType = "DOCKER_IMAGE"
)

type BaseStageOptions 

type BaseStageOptions struct {
	// Runs a `cdk diff --security-only --fail` to pause the pipeline if there are any security changes.
	//
	// If the stage is configured with `confirmBroadeningPermissions` enabled, you can use this
	// property to override the stage configuration. For example, Pipeline Stage
	// "Prod" has confirmBroadeningPermissions enabled, with applications "A", "B", "C". All three
	// applications will run a security check, but if we want to disable the one for "C",
	// we run `stage.addApplication(C, { confirmBroadeningPermissions: false })` to override the pipeline
	// stage behavior.
	//
	// Adds 1 to the run order space.
	// Experimental.
	ConfirmBroadeningPermissions *bool `json:"confirmBroadeningPermissions"`
	// Optional SNS topic to send notifications to when the security check registers changes within the application.
	// Experimental.
	SecurityNotificationTopic awssns.ITopic `json:"securityNotificationTopic"`
}

Base options for a pipelines stage. Experimental.

type CdkPipeline 

type CdkPipeline interface {
	constructs.Construct
	CodePipeline() awscodepipeline.Pipeline
	Node() constructs.Node
	AddApplicationStage(appStage awscdk.Stage, options *AddStageOptions) CdkStage
	AddStage(stageName *string, options *BaseStageOptions) CdkStage
	StackOutput(cfnOutput awscdk.CfnOutput) StackOutput
	Stage(stageName *string) awscodepipeline.IStage
	ToString() *string
}

A Pipeline to deploy CDK apps.

Defines an AWS CodePipeline-based Pipeline to deploy CDK applications.

Automatically manages the following:

- Stack dependency order. - Asset publishing. - Keeping the pipeline up-to-date as the CDK apps change. - Using stack outputs later on in the pipeline. Experimental.

func NewCdkPipeline 

func NewCdkPipeline(scope constructs.Construct, id *string, props *CdkPipelineProps) CdkPipeline

Experimental.

type CdkPipelineProps 

type CdkPipelineProps struct {
	// The artifact you have defined to be the artifact to hold the cloudAssemblyArtifact for the synth action.
	// Experimental.
	CloudAssemblyArtifact awscodepipeline.Artifact `json:"cloudAssemblyArtifact"`
	// Custom BuildSpec that is merged with generated one (for asset publishing actions).
	// Experimental.
	AssetBuildSpec awscodebuild.BuildSpec `json:"assetBuildSpec"`
	// Additional commands to run before installing cdk-assets during the asset publishing step Use this to setup proxies or npm mirrors.
	// Experimental.
	AssetPreInstallCommands *[]*string `json:"assetPreInstallCommands"`
	// CDK CLI version to use in pipeline.
	//
	// Some Actions in the pipeline will download and run a version of the CDK
	// CLI. Specify the version here.
	// Experimental.
	CdkCliVersion *string `json:"cdkCliVersion"`
	// Existing CodePipeline to add deployment stages to.
	//
	// Use this if you want more control over the CodePipeline that gets created.
	// You can choose to not pass this value, in which case a new CodePipeline is
	// created with default settings.
	//
	// If you pass an existing CodePipeline, it should should have been created
	// with `restartExecutionOnUpdate: true`.
	//
	// [disable-awslint:ref-via-interface]
	// Experimental.
	CodePipeline awscodepipeline.Pipeline `json:"codePipeline"`
	// Create KMS keys for cross-account deployments.
	//
	// This controls whether the pipeline is enabled for cross-account deployments.
	//
	// Can only be set if `codePipeline` is not set.
	//
	// By default cross-account deployments are enabled, but this feature requires
	// that KMS Customer Master Keys are created which have a cost of $1/month.
	//
	// If you do not need cross-account deployments, you can set this to `false` to
	// not create those keys and save on that cost (the artifact bucket will be
	// encrypted with an AWS-managed key). However, cross-account deployments will
	// no longer be possible.
	// Experimental.
	CrossAccountKeys *bool `json:"crossAccountKeys"`
	// A list of credentials used to authenticate to Docker registries.
	//
	// Specify any credentials necessary within the pipeline to build, synth, update, or publish assets.
	// Experimental.
	DockerCredentials *[]DockerCredential `json:"dockerCredentials"`
	// Name of the pipeline.
	//
	// Can only be set if `codePipeline` is not set.
	// Experimental.
	PipelineName *string `json:"pipelineName"`
	// Whether the pipeline will update itself.
	//
	// This needs to be set to `true` to allow the pipeline to reconfigure
	// itself when assets or stages are being added to it, and `true` is the
	// recommended setting.
	//
	// You can temporarily set this to `false` while you are iterating
	// on the pipeline itself and prefer to deploy changes using `cdk deploy`.
	// Experimental.
	SelfMutating *bool `json:"selfMutating"`
	// Custom BuildSpec that is merged with generated one (for self-mutation stage).
	// Experimental.
	SelfMutationBuildSpec awscodebuild.BuildSpec `json:"selfMutationBuildSpec"`
	// Whether this pipeline creates one asset upload action per asset type or one asset upload per asset.
	// Experimental.
	SinglePublisherPerType *bool `json:"singlePublisherPerType"`
	// The CodePipeline action used to retrieve the CDK app's source.
	// Experimental.
	SourceAction awscodepipeline.IAction `json:"sourceAction"`
	// Which subnets to use.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SubnetSelection *awsec2.SubnetSelection `json:"subnetSelection"`
	// Whether the pipeline needs to build Docker images in the UpdatePipeline stage.
	//
	// If the UpdatePipeline stage tries to build a Docker image and this flag is not
	// set to `true`, the build step will run in non-privileged mode and consequently
	// will fail with a message like:
	//
	// > Cannot connect to the Docker daemon at unix:///var/run/docker.sock.
	// > Is the docker daemon running?
	//
	// This flag has an effect only if `selfMutating` is also `true`.
	// Experimental.
	SupportDockerAssets *bool `json:"supportDockerAssets"`
	// The CodePipeline action build and synthesis step of the CDK app.
	// Experimental.
	SynthAction awscodepipeline.IAction `json:"synthAction"`
	// The VPC where to execute the CdkPipeline actions.
	// Experimental.
	Vpc awsec2.IVpc `json:"vpc"`
}

Properties for a CdkPipeline. Experimental.

type CdkStackActionFromArtifactOptions 

type CdkStackActionFromArtifactOptions struct {
	// The CodePipeline artifact that holds the Cloud Assembly.
	// Experimental.
	CloudAssemblyInput awscodepipeline.Artifact `json:"cloudAssemblyInput"`
	// Base name of the action.
	// Experimental.
	BaseActionName *string `json:"baseActionName"`
	// Name of the change set to create and deploy.
	// Experimental.
	ChangeSetName *string `json:"changeSetName"`
	// Run order for the Execute action.
	// Experimental.
	ExecuteRunOrder *float64 `json:"executeRunOrder"`
	// Artifact to write Stack Outputs to.
	// Experimental.
	Output awscodepipeline.Artifact `json:"output"`
	// Filename in output to write Stack outputs to.
	// Experimental.
	OutputFileName *string `json:"outputFileName"`
	// Run order for the Prepare action.
	// Experimental.
	PrepareRunOrder *float64 `json:"prepareRunOrder"`
	// The name of the stack that should be created/updated.
	// Experimental.
	StackName *string `json:"stackName"`
}

Options for the 'fromStackArtifact' operation. Experimental.

type CdkStage 

type CdkStage interface {
	constructs.Construct
	Node() constructs.Node
	AddActions(actions ...awscodepipeline.IAction)
	AddApplication(appStage awscdk.Stage, options *AddStageOptions)
	AddManualApprovalAction(options *AddManualApprovalOptions)
	AddStackArtifactDeployment(stackArtifact cxapi.CloudFormationStackArtifact, options *AddStackOptions)
	DeploysStack(artifactId *string) *bool
	NextSequentialRunOrder(count *float64) *float64
	ToString() *string
}

Stage in a CdkPipeline.

You don't need to instantiate this class directly. Use `cdkPipeline.addStage()` instead. Experimental.

func NewCdkStage 

func NewCdkStage(scope constructs.Construct, id *string, props *CdkStageProps) CdkStage

Experimental.

type CdkStageProps 

type CdkStageProps struct {
	// The CodePipeline Artifact with the Cloud Assembly.
	// Experimental.
	CloudAssemblyArtifact awscodepipeline.Artifact `json:"cloudAssemblyArtifact"`
	// Features the Stage needs from its environment.
	// Experimental.
	Host IStageHost `json:"host"`
	// The underlying Pipeline Stage associated with thisCdkStage.
	// Experimental.
	PipelineStage awscodepipeline.IStage `json:"pipelineStage"`
	// Name of the stage that should be created.
	// Experimental.
	StageName *string `json:"stageName"`
	// Run a security check before every application prepare/deploy actions.
	//
	// Note: Stage level security check can be overriden per application as follows:
	//    `stage.addApplication(app, { confirmBroadeningPermissions: false })`
	// Experimental.
	ConfirmBroadeningPermissions *bool `json:"confirmBroadeningPermissions"`
	// Optional SNS topic to send notifications to when any security check registers changes within a application.
	//
	// Note: The Stage Notification Topic can be overriden per application as follows:
	//    `stage.addApplication(app, { securityNotificationTopic: newTopic })`
	// Experimental.
	SecurityNotificationTopic awssns.ITopic `json:"securityNotificationTopic"`
}

Construction properties for a CdkStage. Experimental.

type CodeBuildOptions 

type CodeBuildOptions struct {
	// Partial build environment, will be combined with other build environments that apply.
	// Experimental.
	BuildEnvironment *awscodebuild.BuildEnvironment `json:"buildEnvironment"`
	// Partial buildspec, will be combined with other buildspecs that apply.
	//
	// The BuildSpec must be available inline--it cannot reference a file
	// on disk.
	// Experimental.
	PartialBuildSpec awscodebuild.BuildSpec `json:"partialBuildSpec"`
	// Policy statements to add to role.
	// Experimental.
	RolePolicy *[]awsiam.PolicyStatement `json:"rolePolicy"`
	// Which security group(s) to associate with the project network interfaces.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SecurityGroups *[]awsec2.ISecurityGroup `json:"securityGroups"`
	// Which subnets to use.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SubnetSelection *awsec2.SubnetSelection `json:"subnetSelection"`
	// The VPC where to create the CodeBuild network interfaces in.
	// Experimental.
	Vpc awsec2.IVpc `json:"vpc"`
}

Options for customizing a single CodeBuild project. Experimental.

type CodeBuildStep 

type CodeBuildStep interface {
	ShellStep
	BuildEnvironment() *awscodebuild.BuildEnvironment
	Commands() *[]*string
	Dependencies() *[]Step
	DependencyFileSets() *[]FileSet
	Env() *map[string]*string
	EnvFromCfnOutputs() *map[string]StackOutputReference
	GrantPrincipal() awsiam.IPrincipal
	Id() *string
	Inputs() *[]*FileSetLocation
	InstallCommands() *[]*string
	IsSource() *bool
	Outputs() *[]*FileSetLocation
	PartialBuildSpec() awscodebuild.BuildSpec
	PrimaryOutput() FileSet
	Project() awscodebuild.IProject
	ProjectName() *string
	Role() awsiam.IRole
	RolePolicyStatements() *[]awsiam.PolicyStatement
	SecurityGroups() *[]awsec2.ISecurityGroup
	SubnetSelection() *awsec2.SubnetSelection
	Vpc() awsec2.IVpc
	AddDependencyFileSet(fs FileSet)
	AddOutputDirectory(directory *string) FileSet
	ConfigurePrimaryOutput(fs FileSet)
	PrimaryOutputDirectory(directory *string) FileSet
	ToString() *string
}

Run a script as a CodeBuild Project. Experimental.

func NewCodeBuildStep 

func NewCodeBuildStep(id *string, props *CodeBuildStepProps) CodeBuildStep

Experimental.

type CodeBuildStepProps 

type CodeBuildStepProps struct {
	// Commands to run.
	// Experimental.
	Commands *[]*string `json:"commands"`
	// Additional FileSets to put in other directories.
	//
	// Specifies a mapping from directory name to FileSets. During the
	// script execution, the FileSets will be available in the directories
	// indicated.
	//
	// The directory names may be relative. For example, you can put
	// the main input and an additional input side-by-side with the
	// following configuration:
	//
	// “`ts
	// const script = new ShellStep('MainScript', {
	//    // ...
	//    input: MyEngineSource.gitHub('org/source1'),
	//    additionalInputs: {
	//      '../siblingdir': MyEngineSource.gitHub('org/source2'),
	//    }
	// });
	// “`
	// Experimental.
	AdditionalInputs *map[string]IFileSetProducer `json:"additionalInputs"`
	// Environment variables to set.
	// Experimental.
	Env *map[string]*string `json:"env"`
	// Set environment variables based on Stack Outputs.
	//
	// `ShellStep`s following stack or stage deployments may
	// access the `CfnOutput`s of those stacks to get access to
	// --for example--automatically generated resource names or
	// endpoint URLs.
	// Experimental.
	EnvFromCfnOutputs *map[string]awscdk.CfnOutput `json:"envFromCfnOutputs"`
	// FileSet to run these scripts on.
	//
	// The files in the FileSet will be placed in the working directory when
	// the script is executed. Use `additionalInputs` to download file sets
	// to other directories as well.
	// Experimental.
	Input IFileSetProducer `json:"input"`
	// Installation commands to run before the regular commands.
	//
	// For deployment engines that support it, install commands will be classified
	// differently in the job history from the regular `commands`.
	// Experimental.
	InstallCommands *[]*string `json:"installCommands"`
	// The directory that will contain the primary output fileset.
	//
	// After running the script, the contents of the given directory
	// will be treated as the primary output of this Step.
	// Experimental.
	PrimaryOutputDirectory *string `json:"primaryOutputDirectory"`
	// Changes to environment.
	//
	// This environment will be combined with the pipeline's default
	// environment.
	// Experimental.
	BuildEnvironment *awscodebuild.BuildEnvironment `json:"buildEnvironment"`
	// Additional configuration that can only be configured via BuildSpec.
	//
	// You should not use this to specify output artifacts; those
	// should be supplied via the other properties of this class, otherwise
	// CDK Pipelines won't be able to inspect the artifacts.
	//
	// Set the `commands` to an empty array if you want to fully specify
	// the BuildSpec using this field.
	//
	// The BuildSpec must be available inline--it cannot reference a file
	// on disk.
	// Experimental.
	PartialBuildSpec awscodebuild.BuildSpec `json:"partialBuildSpec"`
	// Name for the generated CodeBuild project.
	// Experimental.
	ProjectName *string `json:"projectName"`
	// Custom execution role to be used for the CodeBuild project.
	// Experimental.
	Role awsiam.IRole `json:"role"`
	// Policy statements to add to role used during the synth.
	//
	// Can be used to add acces to a CodeArtifact repository etc.
	// Experimental.
	RolePolicyStatements *[]awsiam.PolicyStatement `json:"rolePolicyStatements"`
	// Which security group to associate with the script's project network interfaces.
	//
	// If no security group is identified, one will be created automatically.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SecurityGroups *[]awsec2.ISecurityGroup `json:"securityGroups"`
	// Which subnets to use.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SubnetSelection *awsec2.SubnetSelection `json:"subnetSelection"`
	// The VPC where to execute the SimpleSynth.
	// Experimental.
	Vpc awsec2.IVpc `json:"vpc"`
}

Construction props for a CodeBuildStep. Experimental.

type CodeCommitSourceOptions 

type CodeCommitSourceOptions struct {
	// Whether the output should be the contents of the repository (which is the default), or a link that allows CodeBuild to clone the repository before building.
	//
	// **Note**: if this option is true,
	// then only CodeBuild actions can use the resulting {@link output}.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference-CodeCommit.html
	//
	// Experimental.
	CodeBuildCloneOutput *bool `json:"codeBuildCloneOutput"`
	// Role to be used by on commit event rule.
	//
	// Used only when trigger value is CodeCommitTrigger.EVENTS.
	// Experimental.
	EventRole awsiam.IRole `json:"eventRole"`
	// How should CodePipeline detect source changes for this Action.
	// Experimental.
	Trigger awscodepipelineactions.CodeCommitTrigger `json:"trigger"`
}

Configuration options for a CodeCommit source. Experimental.

type CodePipeline 

type CodePipeline interface {
	PipelineBase
	CloudAssemblyFileSet() FileSet
	Node() constructs.Node
	Pipeline() awscodepipeline.Pipeline
	Synth() IFileSetProducer
	SynthProject() awscodebuild.IProject
	Waves() *[]Wave
	AddStage(stage awscdk.Stage, options *AddStageOpts) StageDeployment
	AddWave(id *string, options *WaveOptions) Wave
	BuildPipeline()
	DoBuildPipeline()
	ToString() *string
}

A CDK Pipeline that uses CodePipeline to deploy CDK apps.

This is a `Pipeline` with its `engine` property set to `CodePipelineEngine`, and exists for nicer ergonomics for users that don't need to switch out engines. Experimental.

func NewCodePipeline 

func NewCodePipeline(scope constructs.Construct, id *string, props *CodePipelineProps) CodePipeline

Experimental.

type CodePipelineActionFactoryResult 

type CodePipelineActionFactoryResult struct {
	// How many RunOrders were consumed.
	// Experimental.
	RunOrdersConsumed *float64 `json:"runOrdersConsumed"`
	// If a CodeBuild project got created, the project.
	// Experimental.
	Project awscodebuild.IProject `json:"project"`
}

The result of adding actions to the pipeline. Experimental.

type CodePipelineFileSet 

type CodePipelineFileSet interface {
	FileSet
	Id() *string
	PrimaryOutput() FileSet
	Producer() Step
	ProducedBy(producer Step)
	ToString() *string
}

A FileSet created from a CodePipeline artifact.

You only need to use this if you want to add CDK Pipeline stages add the end of an existing CodePipeline, which should be very rare. Experimental.

func CodePipelineFileSet_FromArtifact 

func CodePipelineFileSet_FromArtifact(artifact awscodepipeline.Artifact) CodePipelineFileSet

Turn a CodePipeline Artifact into a FileSet. Experimental.

type CodePipelineProps 

type CodePipelineProps struct {
	// The build step that produces the CDK Cloud Assembly.
	//
	// The primary output of this step needs to be the `cdk.out` directory
	// generated by the `cdk synth` command.
	//
	// If you use a `ShellStep` here and you don't configure an output directory,
	// the output directory will automatically be assumed to be `cdk.out`.
	// Experimental.
	Synth IFileSetProducer `json:"synth"`
	// Additional customizations to apply to the asset publishing CodeBuild projects.
	// Experimental.
	AssetPublishingCodeBuildDefaults *CodeBuildOptions `json:"assetPublishingCodeBuildDefaults"`
	// CDK CLI version to use in self-mutation and asset publishing steps.
	//
	// If you want to lock the CDK CLI version used in the pipeline, by steps
	// that are automatically generated for you, specify the version here.
	//
	// You should not typically need to specify this value.
	// Experimental.
	CliVersion *string `json:"cliVersion"`
	// Customize the CodeBuild projects created for this pipeline.
	// Experimental.
	CodeBuildDefaults *CodeBuildOptions `json:"codeBuildDefaults"`
	// An existing Pipeline to be reused and built upon.
	//
	// [disable-awslint:ref-via-interface]
	// Experimental.
	CodePipeline awscodepipeline.Pipeline `json:"codePipeline"`
	// Create KMS keys for the artifact buckets, allowing cross-account deployments.
	//
	// The artifact buckets have to be encrypted to support deploying CDK apps to
	// another account, so if you want to do that or want to have your artifact
	// buckets encrypted, be sure to set this value to `true`.
	//
	// Be aware there is a cost associated with maintaining the KMS keys.
	// Experimental.
	CrossAccountKeys *bool `json:"crossAccountKeys"`
	// A list of credentials used to authenticate to Docker registries.
	//
	// Specify any credentials necessary within the pipeline to build, synth, update, or publish assets.
	// Experimental.
	DockerCredentials *[]DockerCredential `json:"dockerCredentials"`
	// Enable Docker for the self-mutate step.
	//
	// Set this to true if the pipeline itself uses Docker container assets
	// (for example, if you use `LinuxBuildImage.fromAsset()` as the build
	// image of a CodeBuild step in the pipeline).
	//
	// You do not need to set it if you build Docker image assets in the
	// application Stages and Stacks that are *deployed* by this pipeline.
	//
	// Configures privileged mode for the self-mutation CodeBuild action.
	//
	// If you are about to turn this on in an already-deployed Pipeline,
	// set the value to `true` first, commit and allow the pipeline to
	// self-update, and only then use the Docker asset in the pipeline.
	// Experimental.
	DockerEnabledForSelfMutation *bool `json:"dockerEnabledForSelfMutation"`
	// Enable Docker for the 'synth' step.
	//
	// Set this to true if you are using file assets that require
	// "bundling" anywhere in your application (meaning an asset
	// compilation step will be run with the tools provided by
	// a Docker image), both for the Pipeline stack as well as the
	// application stacks.
	//
	// A common way to use bundling assets in your application is by
	// using the `@aws-cdk/aws-lambda-nodejs` library.
	//
	// Configures privileged mode for the synth CodeBuild action.
	//
	// If you are about to turn this on in an already-deployed Pipeline,
	// set the value to `true` first, commit and allow the pipeline to
	// self-update, and only then use the bundled asset.
	// Experimental.
	DockerEnabledForSynth *bool `json:"dockerEnabledForSynth"`
	// The name of the CodePipeline pipeline.
	// Experimental.
	PipelineName *string `json:"pipelineName"`
	// Publish assets in multiple CodeBuild projects.
	//
	// If set to false, use one Project per type to publish all assets.
	//
	// Publishing in parallel improves concurrency and may reduce publishing
	// latency, but may also increase overall provisioning time of the CodeBuild
	// projects.
	//
	// Experiment and see what value works best for you.
	// Experimental.
	PublishAssetsInParallel *bool `json:"publishAssetsInParallel"`
	// Whether the pipeline will update itself.
	//
	// This needs to be set to `true` to allow the pipeline to reconfigure
	// itself when assets or stages are being added to it, and `true` is the
	// recommended setting.
	//
	// You can temporarily set this to `false` while you are iterating
	// on the pipeline itself and prefer to deploy changes using `cdk deploy`.
	// Experimental.
	SelfMutation *bool `json:"selfMutation"`
	// Additional customizations to apply to the self mutation CodeBuild projects.
	// Experimental.
	SelfMutationCodeBuildDefaults *CodeBuildOptions `json:"selfMutationCodeBuildDefaults"`
	// Additional customizations to apply to the synthesize CodeBuild projects.
	// Experimental.
	SynthCodeBuildDefaults *CodeBuildOptions `json:"synthCodeBuildDefaults"`
}

Properties for a `CodePipeline`. Experimental.

type CodePipelineSource 

type CodePipelineSource interface {
	Step
	ICodePipelineActionFactory
	Dependencies() *[]Step
	DependencyFileSets() *[]FileSet
	Id() *string
	IsSource() *bool
	PrimaryOutput() FileSet
	AddDependencyFileSet(fs FileSet)
	ConfigurePrimaryOutput(fs FileSet)
	GetAction(output awscodepipeline.Artifact, actionName *string, runOrder *float64) awscodepipelineactions.Action
	ProduceAction(stage awscodepipeline.IStage, options *ProduceActionOptions) *CodePipelineActionFactoryResult
	ToString() *string
}

CodePipeline source steps.

This class contains a number of factory methods for the different types of sources that CodePipeline supports. Experimental.

func CodePipelineSource_CodeCommit 

func CodePipelineSource_CodeCommit(repository awscodecommit.IRepository, branch *string, props *CodeCommitSourceOptions) CodePipelineSource

Returns a CodeCommit source. Experimental.

func CodePipelineSource_Connection 

func CodePipelineSource_Connection(repoString *string, branch *string, props *ConnectionSourceOptions) CodePipelineSource

Returns a CodeStar connection source.

A CodeStar connection allows AWS CodePipeline to access external resources, such as repositories in GitHub, GitHub Enterprise or BitBucket.

To use this method, you first need to create a CodeStar connection using the AWS console. In the process, you may have to sign in to the external provider -- GitHub, for example -- to authorize AWS to read and modify your repository. Once you have done this, copy the connection ARN and use it to create the source.

Example:

```ts 

CodePipelineSource.connection('owner/repo', 'main', {
   connectionArn: 'arn:aws:codestar-connections:us-east-1:222222222222:connection/7d2469ff-514a-4e4f-9003-5ca4a43cdc41', // Created using the AWS console
});

``` See: https://docs.aws.amazon.com/dtconsole/latest/userguide/welcome-connections.html

Experimental.

func CodePipelineSource_GitHub 

func CodePipelineSource_GitHub(repoString *string, branch *string, props *GitHubSourceOptions) CodePipelineSource

Returns a GitHub source, using OAuth tokens to authenticate with GitHub and a separate webhook to detect changes.

This is no longer the recommended method. Please consider using `connection()` instead.

Pass in the owner and repository in a single string, like this:

```ts CodePipelineSource.gitHub('owner/repo', 'main'); ```

Authentication will be done by a secret called `github-token` in AWS Secrets Manager (unless specified otherwise).

The token should have these permissions:

* **repo** - to read the repository * **admin:repo_hook** - if you plan to use webhooks (true by default) Experimental.

func CodePipelineSource_S3 

func CodePipelineSource_S3(bucket awss3.IBucket, objectKey *string, props *S3SourceOptions) CodePipelineSource

Returns an S3 source. Experimental.

type ConfirmPermissionsBroadening 

type ConfirmPermissionsBroadening interface {
	Step
	ICodePipelineActionFactory
	Dependencies() *[]Step
	DependencyFileSets() *[]FileSet
	Id() *string
	IsSource() *bool
	PrimaryOutput() FileSet
	AddDependencyFileSet(fs FileSet)
	ConfigurePrimaryOutput(fs FileSet)
	ProduceAction(stage awscodepipeline.IStage, options *ProduceActionOptions) *CodePipelineActionFactoryResult
	ToString() *string
}

Pause the pipeline if a deployment would add IAM permissions or Security Group rules.

This step is only supported in CodePipeline pipelines. Experimental.

func NewConfirmPermissionsBroadening 

func NewConfirmPermissionsBroadening(id *string, props *PermissionsBroadeningCheckProps) ConfirmPermissionsBroadening

Experimental.

type ConnectionSourceOptions 

type ConnectionSourceOptions struct {
	// The ARN of the CodeStar Connection created in the AWS console that has permissions to access this GitHub or BitBucket repository.
	//
	// TODO: EXAMPLE
	//
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/connections-create.html
	//
	// Experimental.
	ConnectionArn *string `json:"connectionArn"`
	// Whether the output should be the contents of the repository (which is the default), or a link that allows CodeBuild to clone the repository before building.
	//
	// **Note**: if this option is true,
	// then only CodeBuild actions can use the resulting {@link output}.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference-CodestarConnectionSource.html#action-reference-CodestarConnectionSource-config
	//
	// Experimental.
	CodeBuildCloneOutput *bool `json:"codeBuildCloneOutput"`
	// Controls automatically starting your pipeline when a new commit is made on the configured repository and branch.
	//
	// If unspecified,
	// the default value is true, and the field does not display by default.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference-CodestarConnectionSource.html
	//
	// Experimental.
	TriggerOnPush *bool `json:"triggerOnPush"`
}

Configuration options for CodeStar source. Experimental.

type DeployCdkStackAction 

type DeployCdkStackAction interface {
	awscodepipeline.IAction
	ActionProperties() *awscodepipeline.ActionProperties
	DependencyStackArtifactIds() *[]*string
	ExecuteRunOrder() *float64
	PrepareRunOrder() *float64
	StackArtifactId() *string
	StackName() *string
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
}

Action to deploy a CDK Stack.

Adds two CodePipeline Actions to the pipeline: one to create a ChangeSet and one to execute it.

You do not need to instantiate this action yourself -- it will automatically be added by the pipeline when you add stack artifacts or entire stages. Experimental.

func DeployCdkStackAction_FromStackArtifact 

func DeployCdkStackAction_FromStackArtifact(scope constructs.Construct, artifact cxapi.CloudFormationStackArtifact, options *CdkStackActionFromArtifactOptions) DeployCdkStackAction

Construct a DeployCdkStackAction from a Stack artifact. Experimental.

func NewDeployCdkStackAction 

func NewDeployCdkStackAction(props *DeployCdkStackActionProps) DeployCdkStackAction

Experimental.

type DeployCdkStackActionOptions 

type DeployCdkStackActionOptions struct {
	// The CodePipeline artifact that holds the Cloud Assembly.
	// Experimental.
	CloudAssemblyInput awscodepipeline.Artifact `json:"cloudAssemblyInput"`
	// Base name of the action.
	// Experimental.
	BaseActionName *string `json:"baseActionName"`
	// Name of the change set to create and deploy.
	// Experimental.
	ChangeSetName *string `json:"changeSetName"`
	// Run order for the Execute action.
	// Experimental.
	ExecuteRunOrder *float64 `json:"executeRunOrder"`
	// Artifact to write Stack Outputs to.
	// Experimental.
	Output awscodepipeline.Artifact `json:"output"`
	// Filename in output to write Stack outputs to.
	// Experimental.
	OutputFileName *string `json:"outputFileName"`
	// Run order for the Prepare action.
	// Experimental.
	PrepareRunOrder *float64 `json:"prepareRunOrder"`
}

Customization options for a DeployCdkStackAction. Experimental.

type DeployCdkStackActionProps 

type DeployCdkStackActionProps struct {
	// The CodePipeline artifact that holds the Cloud Assembly.
	// Experimental.
	CloudAssemblyInput awscodepipeline.Artifact `json:"cloudAssemblyInput"`
	// Base name of the action.
	// Experimental.
	BaseActionName *string `json:"baseActionName"`
	// Name of the change set to create and deploy.
	// Experimental.
	ChangeSetName *string `json:"changeSetName"`
	// Run order for the Execute action.
	// Experimental.
	ExecuteRunOrder *float64 `json:"executeRunOrder"`
	// Artifact to write Stack Outputs to.
	// Experimental.
	Output awscodepipeline.Artifact `json:"output"`
	// Filename in output to write Stack outputs to.
	// Experimental.
	OutputFileName *string `json:"outputFileName"`
	// Run order for the Prepare action.
	// Experimental.
	PrepareRunOrder *float64 `json:"prepareRunOrder"`
	// Role for the action to assume.
	//
	// This controls the account to deploy into
	// Experimental.
	ActionRole awsiam.IRole `json:"actionRole"`
	// The name of the stack that should be created/updated.
	// Experimental.
	StackName *string `json:"stackName"`
	// Relative path of template in the input artifact.
	// Experimental.
	TemplatePath *string `json:"templatePath"`
	// Role to execute CloudFormation under.
	// Experimental.
	CloudFormationExecutionRole awsiam.IRole `json:"cloudFormationExecutionRole"`
	// Artifact ID for the stacks this stack depends on.
	//
	// Used for pipeline order checking.
	// Experimental.
	DependencyStackArtifactIds *[]*string `json:"dependencyStackArtifactIds"`
	// Region to deploy into.
	// Experimental.
	Region *string `json:"region"`
	// Artifact ID for the stack deployed here.
	//
	// Used for pipeline order checking.
	// Experimental.
	StackArtifactId *string `json:"stackArtifactId"`
	// Template configuration path relative to the input artifact.
	// Experimental.
	TemplateConfigurationPath *string `json:"templateConfigurationPath"`
}

Properties for a DeployCdkStackAction. Experimental.

type DockerCredential 

type DockerCredential interface {
	Usages() *[]DockerCredentialUsage
	GrantRead(grantee awsiam.IGrantable, usage DockerCredentialUsage)
}

Represents credentials used to access a Docker registry. Experimental.

func DockerCredential_CustomRegistry 

func DockerCredential_CustomRegistry(registryDomain *string, secret awssecretsmanager.ISecret, opts *ExternalDockerCredentialOptions) DockerCredential

Creates a DockerCredential for a registry, based on its domain name (e.g., 'www.example.com'). Experimental.

func DockerCredential_DockerHub 

func DockerCredential_DockerHub(secret awssecretsmanager.ISecret, opts *ExternalDockerCredentialOptions) DockerCredential

Creates a DockerCredential for DockerHub.

Convenience method for `fromCustomRegistry('index.docker.io', opts)`. Experimental.

func DockerCredential_Ecr 

func DockerCredential_Ecr(repositories *[]awsecr.IRepository, opts *EcrDockerCredentialOptions) DockerCredential

Creates a DockerCredential for one or more ECR repositories.

NOTE - All ECR repositories in the same account and region share a domain name (e.g., 0123456789012.dkr.ecr.eu-west-1.amazonaws.com), and can only have one associated set of credentials (and DockerCredential). Attempting to associate one set of credentials with one ECR repo and another with another ECR repo in the same account and region will result in failures when using these credentials in the pipeline. Experimental.

type DockerCredentialUsage 

type DockerCredentialUsage string

Defines which stages of a pipeline require the specified credentials. Experimental. 

const (
	DockerCredentialUsage_SYNTH            DockerCredentialUsage = "SYNTH"
	DockerCredentialUsage_SELF_UPDATE      DockerCredentialUsage = "SELF_UPDATE"
	DockerCredentialUsage_ASSET_PUBLISHING DockerCredentialUsage = "ASSET_PUBLISHING"
)

type EcrDockerCredentialOptions 

type EcrDockerCredentialOptions struct {
	// An IAM role to assume prior to accessing the secret.
	// Experimental.
	AssumeRole awsiam.IRole `json:"assumeRole"`
	// Defines which stages of the pipeline should be granted access to these credentials.
	// Experimental.
	Usages *[]DockerCredentialUsage `json:"usages"`
}

Options for defining access for a Docker Credential composed of ECR repos. Experimental.

type ExternalDockerCredentialOptions 

type ExternalDockerCredentialOptions struct {
	// An IAM role to assume prior to accessing the secret.
	// Experimental.
	AssumeRole awsiam.IRole `json:"assumeRole"`
	// The name of the JSON field of the secret which contains the secret/password.
	// Experimental.
	SecretPasswordField *string `json:"secretPasswordField"`
	// The name of the JSON field of the secret which contains the user/login name.
	// Experimental.
	SecretUsernameField *string `json:"secretUsernameField"`
	// Defines which stages of the pipeline should be granted access to these credentials.
	// Experimental.
	Usages *[]DockerCredentialUsage `json:"usages"`
}

Options for defining credentials for a Docker Credential. Experimental.

type FileSet 

type FileSet interface {
	IFileSetProducer
	Id() *string
	PrimaryOutput() FileSet
	Producer() Step
	ProducedBy(producer Step)
	ToString() *string
}

A set of files traveling through the deployment pipeline.

Individual steps in the pipeline produce or consume `FileSet`s. Experimental.

func NewFileSet 

func NewFileSet(id *string, producer Step) FileSet

Experimental.

type FileSetLocation 

type FileSetLocation struct {
	// The (relative) directory where the FileSet is found.
	// Experimental.
	Directory *string `json:"directory"`
	// The FileSet object.
	// Experimental.
	FileSet FileSet `json:"fileSet"`
}

Location of a FileSet consumed or produced by a ShellStep. Experimental.

type FromStackArtifactOptions 

type FromStackArtifactOptions struct {
	// The CodePipeline artifact that holds the Cloud Assembly.
	// Experimental.
	CloudAssemblyInput awscodepipeline.Artifact `json:"cloudAssemblyInput"`
	// Run order for the Execute action.
	// Experimental.
	ExecuteRunOrder *float64 `json:"executeRunOrder"`
	// Artifact to write Stack Outputs to.
	// Experimental.
	Output awscodepipeline.Artifact `json:"output"`
	// Filename in output to write Stack outputs to.
	// Experimental.
	OutputFileName *string `json:"outputFileName"`
	// Run order for the 2 actions that will be created.
	// Experimental.
	PrepareRunOrder *float64 `json:"prepareRunOrder"`
}

Options for CdkDeployAction.fromStackArtifact. Experimental.

type GitHubSourceOptions 

type GitHubSourceOptions struct {
	// A GitHub OAuth token to use for authentication.
	//
	// It is recommended to use a Secrets Manager `Secret` to obtain the token:
	//
	// “`ts
	// const oauth = cdk.SecretValue.secretsManager('my-github-token');
	// new GitHubSource(this, 'GitHubSource', { authentication: oauth, ... });
	// “`
	//
	// The GitHub Personal Access Token should have these scopes:
	//
	// * **repo** - to read the repository
	// * **admin:repo_hook** - if you plan to use webhooks (true by default)
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/GitHub-create-personal-token-CLI.html
	//
	// Experimental.
	Authentication awscdk.SecretValue `json:"authentication"`
	// How AWS CodePipeline should be triggered.
	//
	// With the default value "WEBHOOK", a webhook is created in GitHub that triggers the action.
	// With "POLL", CodePipeline periodically checks the source for changes.
	// With "None", the action is not triggered through changes in the source.
	//
	// To use `WEBHOOK`, your GitHub Personal Access Token should have
	// **admin:repo_hook** scope (in addition to the regular **repo** scope).
	// Experimental.
	Trigger awscodepipelineactions.GitHubTrigger `json:"trigger"`
}

Options for GitHub sources. Experimental.

type ICodePipelineActionFactory 

type ICodePipelineActionFactory interface {
	// Create the desired Action and add it to the pipeline.
	// Experimental.
	ProduceAction(stage awscodepipeline.IStage, options *ProduceActionOptions) *CodePipelineActionFactoryResult
}

Factory for explicit CodePipeline Actions.

If you have specific types of Actions you want to add to a CodePipeline, write a subclass of `Step` that implements this interface, and add the action or actions you want in the `produce` method.

There needs to be a level of indirection here, because some aspects of the Action creation need to be controlled by the workflow engine (name and runOrder). All the rest of the properties are controlled by the factory. Experimental.

type IFileSetProducer 

type IFileSetProducer interface {
	// The `FileSet` produced by this file set producer.
	// Experimental.
	PrimaryOutput() FileSet
}

Any class that produces, or is itself, a `FileSet`.

Steps implicitly produce a primary FileSet as an output. Experimental.

type IStageHost 

type IStageHost interface {
	// Make sure all the assets from the given manifest are published.
	// Experimental.
	PublishAsset(command *AssetPublishingCommand)
	// Return the Artifact the given stack has to emit its outputs into, if any.
	// Experimental.
	StackOutputArtifact(stackArtifactId *string) awscodepipeline.Artifact
}

Features that the Stage needs from its environment. Experimental.

type ManualApprovalStep 

type ManualApprovalStep interface {
	Step
	Comment() *string
	Dependencies() *[]Step
	DependencyFileSets() *[]FileSet
	Id() *string
	IsSource() *bool
	PrimaryOutput() FileSet
	AddDependencyFileSet(fs FileSet)
	ConfigurePrimaryOutput(fs FileSet)
	ToString() *string
}

A manual approval step.

If this step is added to a Pipeline, the Pipeline will be paused waiting for a human to resume it

Only engines that support pausing the deployment will support this step type. Experimental.

func NewManualApprovalStep 

func NewManualApprovalStep(id *string, props *ManualApprovalStepProps) ManualApprovalStep

Experimental.

type ManualApprovalStepProps 

type ManualApprovalStepProps struct {
	// The comment to display with this manual approval.
	// Experimental.
	Comment *string `json:"comment"`
}

Construction properties for a `ManualApprovalStep`. Experimental.

type PermissionsBroadeningCheckProps 

type PermissionsBroadeningCheckProps struct {
	// The CDK Stage object to check the stacks of.
	//
	// This should be the same Stage object you are passing to `addStage()`.
	// Experimental.
	Stage awscdk.Stage `json:"stage"`
	// Topic to send notifications when a human needs to give manual confirmation.
	// Experimental.
	NotificationTopic awssns.ITopic `json:"notificationTopic"`
}

Properties for a `PermissionsBroadeningCheck`. Experimental.

type PipelineBase 

type PipelineBase interface {
	constructs.Construct
	CloudAssemblyFileSet() FileSet
	Node() constructs.Node
	Synth() IFileSetProducer
	Waves() *[]Wave
	AddStage(stage awscdk.Stage, options *AddStageOpts) StageDeployment
	AddWave(id *string, options *WaveOptions) Wave
	BuildPipeline()
	DoBuildPipeline()
	ToString() *string
}

A generic CDK Pipelines pipeline.

Different deployment systems will provide subclasses of `Pipeline` that generate the deployment infrastructure necessary to deploy CDK apps, specific to that system.

This library comes with the `CodePipeline` class, which uses AWS CodePipeline to deploy CDK apps.

The actual pipeline infrastructure is constructed (by invoking the engine) when `buildPipeline()` is called, or when `app.synth()` is called (whichever happens first). Experimental.

type PipelineBaseProps 

type PipelineBaseProps struct {
	// The build step that produces the CDK Cloud Assembly.
	//
	// The primary output of this step needs to be the `cdk.out` directory
	// generated by the `cdk synth` command.
	//
	// If you use a `ShellStep` here and you don't configure an output directory,
	// the output directory will automatically be assumed to be `cdk.out`.
	// Experimental.
	Synth IFileSetProducer `json:"synth"`
}

Properties for a `Pipeline`. Experimental.

type ProduceActionOptions 

type ProduceActionOptions struct {
	// Name the action should get.
	// Experimental.
	ActionName *string `json:"actionName"`
	// Helper object to translate FileSets to CodePipeline Artifacts.
	// Experimental.
	Artifacts ArtifactMap `json:"artifacts"`
	// The pipeline the action is being generated for.
	// Experimental.
	Pipeline CodePipeline `json:"pipeline"`
	// RunOrder the action should get.
	// Experimental.
	RunOrder *float64 `json:"runOrder"`
	// Scope in which to create constructs.
	// Experimental.
	Scope constructs.Construct `json:"scope"`
	// Whether or not this action is inserted before self mutation.
	//
	// If it is, the action should take care to reflect some part of
	// its own definition in the pipeline action definition, to
	// trigger a restart after self-mutation (if necessary).
	// Experimental.
	BeforeSelfMutation *bool `json:"beforeSelfMutation"`
	// If this action factory creates a CodeBuild step, default options to inherit.
	// Experimental.
	CodeBuildDefaults *CodeBuildOptions `json:"codeBuildDefaults"`
	// An input artifact that CodeBuild projects that don't actually need an input artifact can use.
	//
	// CodeBuild Projects MUST have an input artifact in order to be added to the Pipeline. If
	// the Project doesn't actually care about its input (it can be anything), it can use the
	// Artifact passed here.
	// Experimental.
	FallbackArtifact awscodepipeline.Artifact `json:"fallbackArtifact"`
}

Options for the `CodePipelineActionFactory.produce()` method. Experimental.

type PublishAssetsAction 

type PublishAssetsAction interface {
	constructs.Construct
	awscodepipeline.IAction
	ActionProperties() *awscodepipeline.ActionProperties
	Node() constructs.Node
	AddPublishCommand(relativeManifestPath *string, assetSelector *string)
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	ToString() *string
}

Action to publish an asset in the pipeline.

Creates a CodeBuild project which will use the CDK CLI to prepare and publish the asset.

You do not need to instantiate this action -- it will automatically be added by the pipeline when you add stacks that use assets. Experimental.

func NewPublishAssetsAction 

func NewPublishAssetsAction(scope constructs.Construct, id *string, props *PublishAssetsActionProps) PublishAssetsAction

Experimental.

type PublishAssetsActionProps 

type PublishAssetsActionProps struct {
	// Name of publishing action.
	// Experimental.
	ActionName *string `json:"actionName"`
	// AssetType we're publishing.
	// Experimental.
	AssetType AssetType `json:"assetType"`
	// The CodePipeline artifact that holds the Cloud Assembly.
	// Experimental.
	CloudAssemblyInput awscodepipeline.Artifact `json:"cloudAssemblyInput"`
	// Custom BuildSpec that is merged with generated one.
	// Experimental.
	BuildSpec awscodebuild.BuildSpec `json:"buildSpec"`
	// Version of CDK CLI to 'npm install'.
	// Experimental.
	CdkCliVersion *string `json:"cdkCliVersion"`
	// Use a file buildspec written to the cloud assembly instead of an inline buildspec.
	//
	// This prevents size limitation errors as inline specs have a max length of 25600 characters
	// Experimental.
	CreateBuildspecFile *bool `json:"createBuildspecFile"`
	// Any Dependable construct that the CodeBuild project needs to take a dependency on.
	// Experimental.
	Dependable constructs.IDependable `json:"dependable"`
	// Additional commands to run before installing cdk-assert Use this to setup proxies or npm mirrors.
	// Experimental.
	PreInstallCommands *[]*string `json:"preInstallCommands"`
	// Name of the CodeBuild project.
	// Experimental.
	ProjectName *string `json:"projectName"`
	// Role to use for CodePipeline and CodeBuild to build and publish the assets.
	// Experimental.
	Role awsiam.IRole `json:"role"`
	// Which subnets to use.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SubnetSelection *awsec2.SubnetSelection `json:"subnetSelection"`
	// The VPC where to execute the PublishAssetsAction.
	// Experimental.
	Vpc awsec2.IVpc `json:"vpc"`
}

Props for a PublishAssetsAction. Experimental.

type S3SourceOptions 

type S3SourceOptions struct {
	// The action name used for this source in the CodePipeline.
	// Experimental.
	ActionName *string `json:"actionName"`
	// How should CodePipeline detect source changes for this Action.
	//
	// Note that if this is S3Trigger.EVENTS, you need to make sure to include the source Bucket in a CloudTrail Trail,
	// as otherwise the CloudWatch Events will not be emitted.
	// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/log-s3-data-events.html
	//
	// Experimental.
	Trigger awscodepipelineactions.S3Trigger `json:"trigger"`
}

Options for S3 sources. Experimental.

type ShellScriptAction 

type ShellScriptAction interface {
	awscodepipeline.IAction
	awsiam.IGrantable
	ActionProperties() *awscodepipeline.ActionProperties
	GrantPrincipal() awsiam.IPrincipal
	Project() awscodebuild.IProject
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
}

Validate a revision using shell commands. Experimental.

func NewShellScriptAction 

func NewShellScriptAction(props *ShellScriptActionProps) ShellScriptAction

Experimental.

type ShellScriptActionProps 

type ShellScriptActionProps struct {
	// Name of the validation action in the pipeline.
	// Experimental.
	ActionName *string `json:"actionName"`
	// Commands to run.
	// Experimental.
	Commands *[]*string `json:"commands"`
	// Additional artifacts to use as input for the CodeBuild project.
	//
	// You can use these files to load more complex test sets into the
	// shellscript build environment.
	//
	// The files artifact given here will be unpacked into the current
	// working directory, the other ones will be unpacked into directories
	// which are available through the environment variables
	// $CODEBUILD_SRC_DIR_<artifactName>.
	//
	// The CodeBuild job must have at least one input artifact, so you
	// must provide either at least one additional artifact here or one
	// stack output using `useOutput`.
	// Experimental.
	AdditionalArtifacts *[]awscodepipeline.Artifact `json:"additionalArtifacts"`
	// Bash options to set at the start of the script.
	// Experimental.
	BashOptions *string `json:"bashOptions"`
	// The CodeBuild environment where scripts are executed.
	// Experimental.
	Environment *awscodebuild.BuildEnvironment `json:"environment"`
	// Environment variables to send into build.
	// Experimental.
	EnvironmentVariables *map[string]*awscodebuild.BuildEnvironmentVariable `json:"environmentVariables"`
	// Additional policy statements to add to the execution role.
	// Experimental.
	RolePolicyStatements *[]awsiam.PolicyStatement `json:"rolePolicyStatements"`
	// RunOrder for this action.
	//
	// Use this to sequence the shell script after the deployments.
	//
	// The default value is 100 so you don't have to supply the value if you just
	// want to run this after the application stacks have been deployed, and you
	// don't have more than 100 stacks.
	// Experimental.
	RunOrder *float64 `json:"runOrder"`
	// Which security group to associate with the script's project network interfaces.
	//
	// If no security group is identified, one will be created automatically.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SecurityGroups *[]awsec2.ISecurityGroup `json:"securityGroups"`
	// Which subnets to use.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SubnetSelection *awsec2.SubnetSelection `json:"subnetSelection"`
	// Stack outputs to make available as environment variables.
	// Experimental.
	UseOutputs *map[string]StackOutput `json:"useOutputs"`
	// The VPC where to execute the specified script.
	// Experimental.
	Vpc awsec2.IVpc `json:"vpc"`
}

Properties for ShellScriptAction. Experimental.

type ShellStep 

type ShellStep interface {
	Step
	Commands() *[]*string
	Dependencies() *[]Step
	DependencyFileSets() *[]FileSet
	Env() *map[string]*string
	EnvFromCfnOutputs() *map[string]StackOutputReference
	Id() *string
	Inputs() *[]*FileSetLocation
	InstallCommands() *[]*string
	IsSource() *bool
	Outputs() *[]*FileSetLocation
	PrimaryOutput() FileSet
	AddDependencyFileSet(fs FileSet)
	AddOutputDirectory(directory *string) FileSet
	ConfigurePrimaryOutput(fs FileSet)
	PrimaryOutputDirectory(directory *string) FileSet
	ToString() *string
}

Run shell script commands in the pipeline. Experimental.

func NewShellStep 

func NewShellStep(id *string, props *ShellStepProps) ShellStep

Experimental.

type ShellStepProps 

type ShellStepProps struct {
	// Commands to run.
	// Experimental.
	Commands *[]*string `json:"commands"`
	// Additional FileSets to put in other directories.
	//
	// Specifies a mapping from directory name to FileSets. During the
	// script execution, the FileSets will be available in the directories
	// indicated.
	//
	// The directory names may be relative. For example, you can put
	// the main input and an additional input side-by-side with the
	// following configuration:
	//
	// “`ts
	// const script = new ShellStep('MainScript', {
	//    // ...
	//    input: MyEngineSource.gitHub('org/source1'),
	//    additionalInputs: {
	//      '../siblingdir': MyEngineSource.gitHub('org/source2'),
	//    }
	// });
	// “`
	// Experimental.
	AdditionalInputs *map[string]IFileSetProducer `json:"additionalInputs"`
	// Environment variables to set.
	// Experimental.
	Env *map[string]*string `json:"env"`
	// Set environment variables based on Stack Outputs.
	//
	// `ShellStep`s following stack or stage deployments may
	// access the `CfnOutput`s of those stacks to get access to
	// --for example--automatically generated resource names or
	// endpoint URLs.
	// Experimental.
	EnvFromCfnOutputs *map[string]awscdk.CfnOutput `json:"envFromCfnOutputs"`
	// FileSet to run these scripts on.
	//
	// The files in the FileSet will be placed in the working directory when
	// the script is executed. Use `additionalInputs` to download file sets
	// to other directories as well.
	// Experimental.
	Input IFileSetProducer `json:"input"`
	// Installation commands to run before the regular commands.
	//
	// For deployment engines that support it, install commands will be classified
	// differently in the job history from the regular `commands`.
	// Experimental.
	InstallCommands *[]*string `json:"installCommands"`
	// The directory that will contain the primary output fileset.
	//
	// After running the script, the contents of the given directory
	// will be treated as the primary output of this Step.
	// Experimental.
	PrimaryOutputDirectory *string `json:"primaryOutputDirectory"`
}

Construction properties for a `ShellStep`. Experimental.

type SimpleSynthAction 

type SimpleSynthAction interface {
	awscodepipeline.IAction
	awsiam.IGrantable
	ActionProperties() *awscodepipeline.ActionProperties
	GrantPrincipal() awsiam.IPrincipal
	Project() awscodebuild.IProject
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
}

A standard synth with a generated buildspec. Experimental.

func NewSimpleSynthAction 

func NewSimpleSynthAction(props *SimpleSynthActionProps) SimpleSynthAction

Experimental.

func SimpleSynthAction_StandardNpmSynth 

func SimpleSynthAction_StandardNpmSynth(options *StandardNpmSynthOptions) SimpleSynthAction

Create a standard NPM synth action.

Uses `npm ci` to install dependencies and `npx cdk synth` to synthesize.

If you need a build step, add `buildCommand: 'npm run build'`. Experimental.

func SimpleSynthAction_StandardYarnSynth 

func SimpleSynthAction_StandardYarnSynth(options *StandardYarnSynthOptions) SimpleSynthAction

Create a standard Yarn synth action.

Uses `yarn install --frozen-lockfile` to install dependencies and `npx cdk synth` to synthesize.

If you need a build step, add `buildCommand: 'yarn build'`. Experimental.

type SimpleSynthActionProps 

type SimpleSynthActionProps struct {
	// The artifact where the CloudAssembly should be emitted.
	// Experimental.
	CloudAssemblyArtifact awscodepipeline.Artifact `json:"cloudAssemblyArtifact"`
	// The source artifact of the CodePipeline.
	// Experimental.
	SourceArtifact awscodepipeline.Artifact `json:"sourceArtifact"`
	// Name of the build action.
	// Experimental.
	ActionName *string `json:"actionName"`
	// Produce additional output artifacts after the build based on the given directories.
	//
	// Can be used to produce additional artifacts during the build step,
	// separate from the cloud assembly, which can be used further on in the
	// pipeline.
	//
	// Directories are evaluated with respect to `subdirectory`.
	// Experimental.
	AdditionalArtifacts *[]*AdditionalArtifact `json:"additionalArtifacts"`
	// custom BuildSpec that is merged with the generated one.
	// Experimental.
	BuildSpec awscodebuild.BuildSpec `json:"buildSpec"`
	// Environment variables to copy over from parent env.
	//
	// These are environment variables that are being used by the build.
	// Experimental.
	CopyEnvironmentVariables *[]*string `json:"copyEnvironmentVariables"`
	// Build environment to use for CodeBuild job.
	// Experimental.
	Environment *awscodebuild.BuildEnvironment `json:"environment"`
	// Environment variables to send into build.
	//
	// NOTE: You may run into the 1000-character limit for the Action configuration if you have a large
	// number of variables or if their names or values are very long.
	// If you do, pass them to the underlying CodeBuild project directly in `environment` instead.
	// However, you will not be able to use CodePipeline Variables in this case.
	// Experimental.
	EnvironmentVariables *map[string]*awscodebuild.BuildEnvironmentVariable `json:"environmentVariables"`
	// Name of the CodeBuild project.
	// Experimental.
	ProjectName *string `json:"projectName"`
	// Policy statements to add to role used during the synth.
	//
	// Can be used to add acces to a CodeArtifact repository etc.
	// Experimental.
	RolePolicyStatements *[]awsiam.PolicyStatement `json:"rolePolicyStatements"`
	// Directory inside the source where package.json and cdk.json are located.
	// Experimental.
	Subdirectory *string `json:"subdirectory"`
	// Which subnets to use.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SubnetSelection *awsec2.SubnetSelection `json:"subnetSelection"`
	// The VPC where to execute the SimpleSynth.
	// Experimental.
	Vpc awsec2.IVpc `json:"vpc"`
	// The synth command.
	// Experimental.
	SynthCommand *string `json:"synthCommand"`
	// The build commands.
	//
	// If your programming language requires a compilation step, put the
	// compilation command here.
	// Experimental.
	BuildCommands *[]*string `json:"buildCommands"`
	// Install commands.
	//
	// If not provided by the build image or another dependency
	// management tool, at least install the CDK CLI here using
	// `npm install -g aws-cdk`.
	// Experimental.
	InstallCommands *[]*string `json:"installCommands"`
	// Test commands.
	//
	// These commands are run after the build commands but before the
	// synth command.
	// Experimental.
	TestCommands *[]*string `json:"testCommands"`
}

Construction props for SimpleSynthAction. Experimental.

type SimpleSynthOptions 

type SimpleSynthOptions struct {
	// The artifact where the CloudAssembly should be emitted.
	// Experimental.
	CloudAssemblyArtifact awscodepipeline.Artifact `json:"cloudAssemblyArtifact"`
	// The source artifact of the CodePipeline.
	// Experimental.
	SourceArtifact awscodepipeline.Artifact `json:"sourceArtifact"`
	// Name of the build action.
	// Experimental.
	ActionName *string `json:"actionName"`
	// Produce additional output artifacts after the build based on the given directories.
	//
	// Can be used to produce additional artifacts during the build step,
	// separate from the cloud assembly, which can be used further on in the
	// pipeline.
	//
	// Directories are evaluated with respect to `subdirectory`.
	// Experimental.
	AdditionalArtifacts *[]*AdditionalArtifact `json:"additionalArtifacts"`
	// custom BuildSpec that is merged with the generated one.
	// Experimental.
	BuildSpec awscodebuild.BuildSpec `json:"buildSpec"`
	// Environment variables to copy over from parent env.
	//
	// These are environment variables that are being used by the build.
	// Experimental.
	CopyEnvironmentVariables *[]*string `json:"copyEnvironmentVariables"`
	// Build environment to use for CodeBuild job.
	// Experimental.
	Environment *awscodebuild.BuildEnvironment `json:"environment"`
	// Environment variables to send into build.
	//
	// NOTE: You may run into the 1000-character limit for the Action configuration if you have a large
	// number of variables or if their names or values are very long.
	// If you do, pass them to the underlying CodeBuild project directly in `environment` instead.
	// However, you will not be able to use CodePipeline Variables in this case.
	// Experimental.
	EnvironmentVariables *map[string]*awscodebuild.BuildEnvironmentVariable `json:"environmentVariables"`
	// Name of the CodeBuild project.
	// Experimental.
	ProjectName *string `json:"projectName"`
	// Policy statements to add to role used during the synth.
	//
	// Can be used to add acces to a CodeArtifact repository etc.
	// Experimental.
	RolePolicyStatements *[]awsiam.PolicyStatement `json:"rolePolicyStatements"`
	// Directory inside the source where package.json and cdk.json are located.
	// Experimental.
	Subdirectory *string `json:"subdirectory"`
	// Which subnets to use.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SubnetSelection *awsec2.SubnetSelection `json:"subnetSelection"`
	// The VPC where to execute the SimpleSynth.
	// Experimental.
	Vpc awsec2.IVpc `json:"vpc"`
}

Configuration options for a SimpleSynth. Experimental.

type StackAsset 

type StackAsset struct {
	// Asset identifier.
	// Experimental.
	AssetId *string `json:"assetId"`
	// Absolute asset manifest path.
	//
	// This needs to be made relative at a later point in time, but when this
	// information is parsed we don't know about the root cloud assembly yet.
	// Experimental.
	AssetManifestPath *string `json:"assetManifestPath"`
	// Asset selector to pass to `cdk-assets`.
	// Experimental.
	AssetSelector *string `json:"assetSelector"`
	// Type of asset to publish.
	// Experimental.
	AssetType AssetType `json:"assetType"`
	// Does this asset represent the CloudFormation template for the stack.
	// Experimental.
	IsTemplate *bool `json:"isTemplate"`
	// Role ARN to assume to publish.
	// Experimental.
	AssetPublishingRoleArn *string `json:"assetPublishingRoleArn"`
}

An asset used by a Stack. Experimental.

type StackDeployment 

type StackDeployment interface {
	AbsoluteTemplatePath() *string
	Account() *string
	Assets() *[]*StackAsset
	AssumeRoleArn() *string
	ConstructPath() *string
	ExecutionRoleArn() *string
	Region() *string
	StackArtifactId() *string
	StackDependencies() *[]StackDeployment
	StackName() *string
	Tags() *map[string]*string
	TemplateAsset() *StackAsset
	TemplateUrl() *string
	AddStackDependency(stackDeployment StackDeployment)
}

Deployment of a single Stack.

You don't need to instantiate this class -- it will be automatically instantiated as necessary when you add a `Stage` to a pipeline. Experimental.

func StackDeployment_FromArtifact 

func StackDeployment_FromArtifact(stackArtifact cxapi.CloudFormationStackArtifact) StackDeployment

Build a `StackDeployment` from a Stack Artifact in a Cloud Assembly. Experimental.

type StackDeploymentProps 

type StackDeploymentProps struct {
	// Template path on disk to cloud assembly (cdk.out).
	// Experimental.
	AbsoluteTemplatePath *string `json:"absoluteTemplatePath"`
	// Construct path for this stack.
	// Experimental.
	ConstructPath *string `json:"constructPath"`
	// Artifact ID for this stack.
	// Experimental.
	StackArtifactId *string `json:"stackArtifactId"`
	// Name for this stack.
	// Experimental.
	StackName *string `json:"stackName"`
	// Account where the stack should be deployed.
	// Experimental.
	Account *string `json:"account"`
	// Assets referenced by this stack.
	// Experimental.
	Assets *[]*StackAsset `json:"assets"`
	// Role to assume before deploying this stack.
	// Experimental.
	AssumeRoleArn *string `json:"assumeRoleArn"`
	// Execution role to pass to CloudFormation.
	// Experimental.
	ExecutionRoleArn *string `json:"executionRoleArn"`
	// Region where the stack should be deployed.
	// Experimental.
	Region *string `json:"region"`
	// Tags to apply to the stack.
	// Experimental.
	Tags *map[string]*string `json:"tags"`
	// The S3 URL which points to the template asset location in the publishing bucket.
	// Experimental.
	TemplateS3Uri *string `json:"templateS3Uri"`
}

Properties for a `StackDeployment`. Experimental.

type StackOutput 

type StackOutput interface {
	ArtifactFile() awscodepipeline.ArtifactPath
	OutputName() *string
}

A single output of a Stack. Experimental.

func NewStackOutput 

func NewStackOutput(artifactFile awscodepipeline.ArtifactPath, outputName *string) StackOutput

Build a StackOutput from a known artifact and an output name. Experimental.

type StackOutputReference 

type StackOutputReference interface {
	OutputName() *string
	StackDescription() *string
	IsProducedBy(stack StackDeployment) *bool
}

A Reference to a Stack Output. Experimental.

func StackOutputReference_FromCfnOutput 

func StackOutputReference_FromCfnOutput(output awscdk.CfnOutput) StackOutputReference

Create a StackOutputReference that references the given CfnOutput. Experimental.

type StageDeployment 

type StageDeployment interface {
	Post() *[]Step
	Pre() *[]Step
	Stacks() *[]StackDeployment
	StageName() *string
	AddPost(steps ...Step)
	AddPre(steps ...Step)
}

Deployment of a single `Stage`.

A `Stage` consists of one or more `Stacks`, which will be deployed in dependency order. Experimental.

func StageDeployment_FromStage 

func StageDeployment_FromStage(stage awscdk.Stage, props *StageDeploymentProps) StageDeployment

Create a new `StageDeployment` from a `Stage`.

Synthesizes the target stage, and deployes the stacks found inside in dependency order. Experimental.

type StageDeploymentProps 

type StageDeploymentProps struct {
	// Additional steps to run after all of the stacks in the stage.
	// Experimental.
	Post *[]Step `json:"post"`
	// Additional steps to run before any of the stacks in the stage.
	// Experimental.
	Pre *[]Step `json:"pre"`
	// Stage name to use in the pipeline.
	// Experimental.
	StageName *string `json:"stageName"`
}

Properties for a `StageDeployment`. Experimental.

type StandardNpmSynthOptions 

type StandardNpmSynthOptions struct {
	// The artifact where the CloudAssembly should be emitted.
	// Experimental.
	CloudAssemblyArtifact awscodepipeline.Artifact `json:"cloudAssemblyArtifact"`
	// The source artifact of the CodePipeline.
	// Experimental.
	SourceArtifact awscodepipeline.Artifact `json:"sourceArtifact"`
	// Name of the build action.
	// Experimental.
	ActionName *string `json:"actionName"`
	// Produce additional output artifacts after the build based on the given directories.
	//
	// Can be used to produce additional artifacts during the build step,
	// separate from the cloud assembly, which can be used further on in the
	// pipeline.
	//
	// Directories are evaluated with respect to `subdirectory`.
	// Experimental.
	AdditionalArtifacts *[]*AdditionalArtifact `json:"additionalArtifacts"`
	// custom BuildSpec that is merged with the generated one.
	// Experimental.
	BuildSpec awscodebuild.BuildSpec `json:"buildSpec"`
	// Environment variables to copy over from parent env.
	//
	// These are environment variables that are being used by the build.
	// Experimental.
	CopyEnvironmentVariables *[]*string `json:"copyEnvironmentVariables"`
	// Build environment to use for CodeBuild job.
	// Experimental.
	Environment *awscodebuild.BuildEnvironment `json:"environment"`
	// Environment variables to send into build.
	//
	// NOTE: You may run into the 1000-character limit for the Action configuration if you have a large
	// number of variables or if their names or values are very long.
	// If you do, pass them to the underlying CodeBuild project directly in `environment` instead.
	// However, you will not be able to use CodePipeline Variables in this case.
	// Experimental.
	EnvironmentVariables *map[string]*awscodebuild.BuildEnvironmentVariable `json:"environmentVariables"`
	// Name of the CodeBuild project.
	// Experimental.
	ProjectName *string `json:"projectName"`
	// Policy statements to add to role used during the synth.
	//
	// Can be used to add acces to a CodeArtifact repository etc.
	// Experimental.
	RolePolicyStatements *[]awsiam.PolicyStatement `json:"rolePolicyStatements"`
	// Directory inside the source where package.json and cdk.json are located.
	// Experimental.
	Subdirectory *string `json:"subdirectory"`
	// Which subnets to use.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SubnetSelection *awsec2.SubnetSelection `json:"subnetSelection"`
	// The VPC where to execute the SimpleSynth.
	// Experimental.
	Vpc awsec2.IVpc `json:"vpc"`
	// The build command.
	//
	// By default, we assume NPM projects are either written in JavaScript or are
	// using `ts-node`, so don't need a build command.
	//
	// Otherwise, put the build command here, for example `npm run build`.
	// Experimental.
	BuildCommand *string `json:"buildCommand"`
	// The install command.
	// Experimental.
	InstallCommand *string `json:"installCommand"`
	// The synth command.
	// Experimental.
	SynthCommand *string `json:"synthCommand"`
	// Test commands.
	//
	// These commands are run after the build commands but before the
	// synth command.
	// Experimental.
	TestCommands *[]*string `json:"testCommands"`
}

Options for a convention-based synth using NPM. Experimental.

type StandardYarnSynthOptions 

type StandardYarnSynthOptions struct {
	// The artifact where the CloudAssembly should be emitted.
	// Experimental.
	CloudAssemblyArtifact awscodepipeline.Artifact `json:"cloudAssemblyArtifact"`
	// The source artifact of the CodePipeline.
	// Experimental.
	SourceArtifact awscodepipeline.Artifact `json:"sourceArtifact"`
	// Name of the build action.
	// Experimental.
	ActionName *string `json:"actionName"`
	// Produce additional output artifacts after the build based on the given directories.
	//
	// Can be used to produce additional artifacts during the build step,
	// separate from the cloud assembly, which can be used further on in the
	// pipeline.
	//
	// Directories are evaluated with respect to `subdirectory`.
	// Experimental.
	AdditionalArtifacts *[]*AdditionalArtifact `json:"additionalArtifacts"`
	// custom BuildSpec that is merged with the generated one.
	// Experimental.
	BuildSpec awscodebuild.BuildSpec `json:"buildSpec"`
	// Environment variables to copy over from parent env.
	//
	// These are environment variables that are being used by the build.
	// Experimental.
	CopyEnvironmentVariables *[]*string `json:"copyEnvironmentVariables"`
	// Build environment to use for CodeBuild job.
	// Experimental.
	Environment *awscodebuild.BuildEnvironment `json:"environment"`
	// Environment variables to send into build.
	//
	// NOTE: You may run into the 1000-character limit for the Action configuration if you have a large
	// number of variables or if their names or values are very long.
	// If you do, pass them to the underlying CodeBuild project directly in `environment` instead.
	// However, you will not be able to use CodePipeline Variables in this case.
	// Experimental.
	EnvironmentVariables *map[string]*awscodebuild.BuildEnvironmentVariable `json:"environmentVariables"`
	// Name of the CodeBuild project.
	// Experimental.
	ProjectName *string `json:"projectName"`
	// Policy statements to add to role used during the synth.
	//
	// Can be used to add acces to a CodeArtifact repository etc.
	// Experimental.
	RolePolicyStatements *[]awsiam.PolicyStatement `json:"rolePolicyStatements"`
	// Directory inside the source where package.json and cdk.json are located.
	// Experimental.
	Subdirectory *string `json:"subdirectory"`
	// Which subnets to use.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SubnetSelection *awsec2.SubnetSelection `json:"subnetSelection"`
	// The VPC where to execute the SimpleSynth.
	// Experimental.
	Vpc awsec2.IVpc `json:"vpc"`
	// The build command.
	//
	// By default, we assume NPM projects are either written in JavaScript or are
	// using `ts-node`, so don't need a build command.
	//
	// Otherwise, put the build command here, for example `npm run build`.
	// Experimental.
	BuildCommand *string `json:"buildCommand"`
	// The install command.
	// Experimental.
	InstallCommand *string `json:"installCommand"`
	// The synth command.
	// Experimental.
	SynthCommand *string `json:"synthCommand"`
	// Test commands.
	//
	// These commands are run after the build commands but before the
	// synth command.
	// Experimental.
	TestCommands *[]*string `json:"testCommands"`
}

Options for a convention-based synth using Yarn. Experimental.

type Step 

type Step interface {
	IFileSetProducer
	Dependencies() *[]Step
	DependencyFileSets() *[]FileSet
	Id() *string
	IsSource() *bool
	PrimaryOutput() FileSet
	AddDependencyFileSet(fs FileSet)
	ConfigurePrimaryOutput(fs FileSet)
	ToString() *string
}

A generic Step which can be added to a Pipeline.

Steps can be used to add Sources, Build Actions and Validations to your pipeline.

This class is abstract. See specific subclasses of Step for useful steps to add to your Pipeline Experimental.

type UpdatePipelineAction 

type UpdatePipelineAction interface {
	constructs.Construct
	awscodepipeline.IAction
	ActionProperties() *awscodepipeline.ActionProperties
	Node() constructs.Node
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	ToString() *string
}

Action to self-mutate the pipeline.

Creates a CodeBuild project which will use the CDK CLI to deploy the pipeline stack.

You do not need to instantiate this action -- it will automatically be added by the pipeline. Experimental.

func NewUpdatePipelineAction 

func NewUpdatePipelineAction(scope constructs.Construct, id *string, props *UpdatePipelineActionProps) UpdatePipelineAction

Experimental.

type UpdatePipelineActionProps 

type UpdatePipelineActionProps struct {
	// The CodePipeline artifact that holds the Cloud Assembly.
	// Experimental.
	CloudAssemblyInput awscodepipeline.Artifact `json:"cloudAssemblyInput"`
	// Hierarchical id of the pipeline stack.
	// Experimental.
	PipelineStackHierarchicalId *string `json:"pipelineStackHierarchicalId"`
	// Custom BuildSpec that is merged with generated one.
	// Experimental.
	BuildSpec awscodebuild.BuildSpec `json:"buildSpec"`
	// Version of CDK CLI to 'npm install'.
	// Experimental.
	CdkCliVersion *string `json:"cdkCliVersion"`
	// Docker registries and associated credentials necessary during the pipeline self-update stage.
	// Experimental.
	DockerCredentials *[]DockerCredential `json:"dockerCredentials"`
	// Whether the build step should run in privileged mode.
	// Experimental.
	Privileged *bool `json:"privileged"`
	// Name of the CodeBuild project.
	// Experimental.
	ProjectName *string `json:"projectName"`
}

Props for the UpdatePipelineAction. Experimental.

type Wave 

type Wave interface {
	Id() *string
	Post() *[]Step
	Pre() *[]Step
	Stages() *[]StageDeployment
	AddPost(steps ...Step)
	AddPre(steps ...Step)
	AddStage(stage awscdk.Stage, options *AddStageOpts) StageDeployment
}

Multiple stages that are deployed in parallel. Experimental.

func NewWave 

func NewWave(id *string, props *WaveProps) Wave

Experimental.

type WaveOptions 

type WaveOptions struct {
	// Additional steps to run after all of the stages in the wave.
	// Experimental.
	Post *[]Step `json:"post"`
	// Additional steps to run before any of the stages in the wave.
	// Experimental.
	Pre *[]Step `json:"pre"`
}

Options to pass to `addWave`. Experimental.

type WaveProps 

type WaveProps struct {
	// Additional steps to run after all of the stages in the wave.
	// Experimental.
	Post *[]Step `json:"post"`
	// Additional steps to run before any of the stages in the wave.
	// Experimental.
	Pre *[]Step `json:"pre"`
}

Construction properties for a `Wave`. Experimental.

Source Files

View all Source files

Directories

Path Synopsis

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.