Module types

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that AWS CodeDeploy can respond with.

Structs

Alarm

Information about an alarm.

AlarmConfiguration

Information about alarms associated with a deployment or deployment group.

AppSpecContent

A revision for an Lambda or Amazon ECS deployment that is a YAML-formatted or JSON-formatted string. For Lambda and Amazon ECS deployments, the revision is the same as the AppSpec file. This method replaces the deprecated RawString data type.

ApplicationInfo

Information about an application.

AutoRollbackConfiguration

Information about a configuration for automatically rolling back to a previous version of an application revision when a deployment is not completed successfully.

AutoScalingGroup

Information about an Auto Scaling group.

BlueGreenDeploymentConfiguration

Information about blue/green deployment options for a deployment group.

BlueInstanceTerminationOption

Information about whether instances in the original environment are terminated when a blue/green deployment is successful. BlueInstanceTerminationOption does not apply to Lambda deployments.

CloudFormationTarget

Information about the target to be updated by an CloudFormation blue/green deployment. This target type is used for all deployments initiated by a CloudFormation stack update.

DeploymentConfigInfo

Information about a deployment configuration.

DeploymentGroupInfo

Information about a deployment group.

DeploymentInfo

Information about a deployment.

DeploymentOverview

Information about the deployment status of the instances in the deployment.

DeploymentReadyOption

Information about how traffic is rerouted to instances in a replacement environment in a blue/green deployment.

DeploymentStyle

Information about the type of deployment, either in-place or blue/green, you want to run and whether to route deployment traffic behind a load balancer.

DeploymentTarget

Information about the deployment target.

Diagnostics

Diagnostic information about executable scripts that are part of a deployment.

Ec2TagFilter

Information about an EC2 tag filter.

Ec2TagSet

Information about groups of Amazon EC2 instance tags.

EcsService

Contains the service and cluster names used to identify an Amazon ECS deployment's target.

EcsTarget

Information about the target of an Amazon ECS deployment.

EcsTaskSet

Information about a set of Amazon ECS tasks in an CodeDeploy deployment. An Amazon ECS task set includes details such as the desired number of tasks, how many tasks are running, and whether the task set serves production traffic. An CodeDeploy application that uses the Amazon ECS compute platform deploys a containerized application in an Amazon ECS service as a task set.

ElbInfo

Information about a Classic Load Balancer in Elastic Load Balancing to use in a deployment. Instances are registered directly with a load balancer, and traffic is routed to the load balancer.

ErrorInformation

Information about a deployment error.

GenericRevisionInfo

Information about an application revision.

GitHubLocation

Information about the location of application artifacts stored in GitHub.

GreenFleetProvisioningOption

Information about the instances that belong to the replacement environment in a blue/green deployment.

InstanceInfo

Information about an on-premises instance.

InstanceSummaryDeprecated

Information about an instance in a deployment.

InstanceTarget

A target Amazon EC2 or on-premises instance during a deployment that uses the EC2/On-premises compute platform.

LambdaFunctionInfo

Information about a Lambda function specified in a deployment.

LambdaTarget

Information about the target Lambda function during an Lambda deployment.

LastDeploymentInfo

Information about the most recent attempted or successful deployment to a deployment group.

LifecycleEvent

Information about a deployment lifecycle event.

LoadBalancerInfo

Information about the Elastic Load Balancing load balancer or target group used in a deployment.

You can use load balancers and target groups in combination. For example, if you have two Classic Load Balancers, and five target groups tied to an Application Load Balancer, you can specify the two Classic Load Balancers in elbInfoList, and the five target groups in targetGroupInfoList.

MinimumHealthyHosts

Information about the minimum number of healthy instances.

MinimumHealthyHostsPerZone

Information about the minimum number of healthy instances per Availability Zone.

OnPremisesTagSet

Information about groups of on-premises instance tags.

RawStringDeprecated

A revision for an Lambda deployment that is a YAML-formatted or JSON-formatted string. For Lambda deployments, the revision is the same as the AppSpec file.

RelatedDeployments

Information about deployments related to the specified deployment.

RevisionInfo

Information about an application revision.

RevisionLocation

Information about the location of an application revision.

RollbackInfo

Information about a deployment rollback.

S3Location

Information about the location of application artifacts stored in Amazon S3.

Tag

Information about a tag.

TagFilter

Information about an on-premises instance tag filter.

TargetGroupInfo

Information about a target group in Elastic Load Balancing to use in a deployment. Instances are registered as targets in a target group, and traffic is routed to the target group.

TargetGroupPairInfo

Information about two target groups and how traffic is routed during an Amazon ECS deployment. An optional test traffic route can be specified.

TargetInstances

Information about the instances to be used in the replacement environment in a blue/green deployment.

TimeBasedCanary

A configuration that shifts traffic from one version of a Lambda function or Amazon ECS task set to another in two increments. The original and target Lambda function versions or ECS task sets are specified in the deployment's AppSpec file.

TimeBasedLinear

A configuration that shifts traffic from one version of a Lambda function or ECS task set to another in equal increments, with an equal number of minutes between each increment. The original and target Lambda function versions or ECS task sets are specified in the deployment's AppSpec file.

TimeRange

Information about a time range.

TrafficRoute

Information about a listener. The listener contains the path used to route traffic that is received from the load balancer to a target group.

TrafficRoutingConfig

The configuration that specifies how traffic is shifted from one version of a Lambda function to another version during an Lambda deployment, or from one Amazon ECS task set to another during an Amazon ECS deployment.

TriggerConfig

Information about notification triggers for the deployment group.

ZonalConfig

Configure the ZonalConfig object if you want CodeDeploy to deploy your application to one Availability Zone at a time, within an Amazon Web Services Region. By deploying to one Availability Zone at a time, you can expose your deployment to a progressively larger audience as confidence in the deployment's performance and viability grows. If you don't configure the ZonalConfig object, CodeDeploy deploys your application to a random selection of hosts across a Region.

For more information about the zonal configuration feature, see zonal configuration in the CodeDeploy User Guide.

Enums

ApplicationRevisionSortBy

When writing a match expression against ApplicationRevisionSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AutoRollbackEvent

When writing a match expression against AutoRollbackEvent, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

BundleType

When writing a match expression against BundleType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ComputePlatform

When writing a match expression against ComputePlatform, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DeploymentCreator

When writing a match expression against DeploymentCreator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DeploymentOption

When writing a match expression against DeploymentOption, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DeploymentReadyAction

When writing a match expression against DeploymentReadyAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DeploymentStatus

When writing a match expression against DeploymentStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DeploymentTargetType

When writing a match expression against DeploymentTargetType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DeploymentType

When writing a match expression against DeploymentType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DeploymentWaitType

When writing a match expression against DeploymentWaitType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Ec2TagFilterType

When writing a match expression against Ec2TagFilterType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ErrorCode

When writing a match expression against ErrorCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FileExistsBehavior

When writing a match expression against FileExistsBehavior, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

GreenFleetProvisioningAction

When writing a match expression against GreenFleetProvisioningAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

InstanceAction

When writing a match expression against InstanceAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

InstanceStatusDeprecated

When writing a match expression against InstanceStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

InstanceType

When writing a match expression against InstanceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LifecycleErrorCode

When writing a match expression against LifecycleErrorCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LifecycleEventStatus

When writing a match expression against LifecycleEventStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ListStateFilterAction

When writing a match expression against ListStateFilterAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MinimumHealthyHostsPerZoneType

When writing a match expression against MinimumHealthyHostsPerZoneType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MinimumHealthyHostsType

When writing a match expression against MinimumHealthyHostsType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

OutdatedInstancesStrategy

When writing a match expression against OutdatedInstancesStrategy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RegistrationStatus

When writing a match expression against RegistrationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RevisionLocationType

When writing a match expression against RevisionLocationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SortOrder

When writing a match expression against SortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StopStatus

When writing a match expression against StopStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TagFilterType

When writing a match expression against TagFilterType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TargetFilterName

When writing a match expression against TargetFilterName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TargetLabel

When writing a match expression against TargetLabel, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TargetStatus

When writing a match expression against TargetStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TrafficRoutingType

When writing a match expression against TrafficRoutingType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TriggerEventType

When writing a match expression against TriggerEventType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.