Module aws_sdk_codedeploy::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.