Metadata-Version: 2.1
Name: aws-cdk.aws-codedeploy
Version: 1.101.0
Summary: The CDK Construct Library for AWS::CodeDeploy
Home-page: https://github.com/aws/aws-cdk
Author: Amazon Web Services
License: Apache-2.0
Project-URL: Source, https://github.com/aws/aws-cdk.git
Description: # AWS CodeDeploy Construct Library
        
        <!--BEGIN STABILITY BANNER-->---
        
        
        ![cfn-resources: Stable](https://img.shields.io/badge/cfn--resources-stable-success.svg?style=for-the-badge)
        
        ![cdk-constructs: Stable](https://img.shields.io/badge/cdk--constructs-stable-success.svg?style=for-the-badge)
        
        ---
        <!--END STABILITY BANNER-->
        
        AWS CodeDeploy is a deployment service that automates application deployments to
        Amazon EC2 instances, on-premises instances, serverless Lambda functions, or
        Amazon ECS services.
        
        The CDK currently supports Amazon EC2, on-premise and AWS Lambda applications.
        
        ## EC2/on-premise Applications
        
        To create a new CodeDeploy Application that deploys to EC2/on-premise instances:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_codedeploy as codedeploy
        
        application = codedeploy.ServerApplication(self, "CodeDeployApplication",
            application_name="MyApplication"
        )
        ```
        
        To import an already existing Application:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        application = codedeploy.ServerApplication.from_server_application_name(self, "ExistingCodeDeployApplication", "MyExistingApplication")
        ```
        
        ## EC2/on-premise Deployment Groups
        
        To create a new CodeDeploy Deployment Group that deploys to EC2/on-premise instances:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        deployment_group = codedeploy.ServerDeploymentGroup(self, "CodeDeployDeploymentGroup",
            application=application,
            deployment_group_name="MyDeploymentGroup",
            auto_scaling_groups=[asg1, asg2],
            # adds User Data that installs the CodeDeploy agent on your auto-scaling groups hosts
            # default: true
            install_agent=True,
            # adds EC2 instances matching tags
            ec2_instance_tags=codedeploy.InstanceTagSet(
                # any instance with tags satisfying
                # key1=v1 or key1=v2 or key2 (any value) or value v3 (any key)
                # will match this group
                key1=["v1", "v2"],
                key2=[],
                =["v3"]
            ),
            # adds on-premise instances matching tags
            on_premise_instance_tags=codedeploy.InstanceTagSet({
                "key1": ["v1", "v2"]
            },
                key2=["v3"]
            ),
            # CloudWatch alarms
            alarms=[
                cloudwatch.Alarm()
            ],
            # whether to ignore failure to fetch the status of alarms from CloudWatch
            # default: false
            ignore_poll_alarms_failure=False,
            # auto-rollback configuration
            auto_rollback={
                "failed_deployment": True, # default: true
                "stopped_deployment": True, # default: false
                "deployment_in_alarm": True
            }
        )
        ```
        
        All properties are optional - if you don't provide an Application,
        one will be automatically created.
        
        To import an already existing Deployment Group:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        deployment_group = codedeploy.ServerDeploymentGroup.from_lambda_deployment_group_attributes(self, "ExistingCodeDeployDeploymentGroup",
            application=application,
            deployment_group_name="MyExistingDeploymentGroup"
        )
        ```
        
        ### Load balancers
        
        You can [specify a load balancer](https://docs.aws.amazon.com/codedeploy/latest/userguide/integrations-aws-elastic-load-balancing.html)
        with the `loadBalancer` property when creating a Deployment Group.
        
        `LoadBalancer` is an abstract class with static factory methods that allow you to create instances of it from various sources.
        
        With Classic Elastic Load Balancer, you provide it directly:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_elasticloadbalancing as lb
        
        elb = lb.LoadBalancer(self, "ELB")
        elb.add_target()
        elb.add_listener()
        
        deployment_group = codedeploy.ServerDeploymentGroup(self, "DeploymentGroup",
            load_balancer=codedeploy.LoadBalancer.classic(elb)
        )
        ```
        
        With Application Load Balancer or Network Load Balancer,
        you provide a Target Group as the load balancer:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_elasticloadbalancingv2 as lbv2
        
        alb = lbv2.ApplicationLoadBalancer(self, "ALB")
        listener = alb.add_listener("Listener")
        target_group = listener.add_targets("Fleet")
        
        deployment_group = codedeploy.ServerDeploymentGroup(self, "DeploymentGroup",
            load_balancer=codedeploy.LoadBalancer.application(target_group)
        )
        ```
        
        ## Deployment Configurations
        
        You can also pass a Deployment Configuration when creating the Deployment Group:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        deployment_group = codedeploy.ServerDeploymentGroup(self, "CodeDeployDeploymentGroup",
            deployment_config=codedeploy.ServerDeploymentConfig.ALL_AT_ONCE
        )
        ```
        
        The default Deployment Configuration is `ServerDeploymentConfig.ONE_AT_A_TIME`.
        
        You can also create a custom Deployment Configuration:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        deployment_config = codedeploy.ServerDeploymentConfig(self, "DeploymentConfiguration",
            deployment_config_name="MyDeploymentConfiguration", # optional property
            # one of these is required, but both cannot be specified at the same time
            min_healthy_host_count=2,
            min_healthy_host_percentage=75
        )
        ```
        
        Or import an existing one:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        deployment_config = codedeploy.ServerDeploymentConfig.from_server_deployment_config_name(self, "ExistingDeploymentConfiguration", "MyExistingDeploymentConfiguration")
        ```
        
        ## Lambda Applications
        
        To create a new CodeDeploy Application that deploys to a Lambda function:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_codedeploy as codedeploy
        
        application = codedeploy.LambdaApplication(self, "CodeDeployApplication",
            application_name="MyApplication"
        )
        ```
        
        To import an already existing Application:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        application = codedeploy.LambdaApplication.from_lambda_application_name(self, "ExistingCodeDeployApplication", "MyExistingApplication")
        ```
        
        ## Lambda Deployment Groups
        
        To enable traffic shifting deployments for Lambda functions, CodeDeploy uses Lambda Aliases, which can balance incoming traffic between two different versions of your function.
        Before deployment, the alias sends 100% of invokes to the version used in production.
        When you publish a new version of the function to your stack, CodeDeploy will send a small percentage of traffic to the new version, monitor, and validate before shifting 100% of traffic to the new version.
        
        To create a new CodeDeploy Deployment Group that deploys to a Lambda function:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_codedeploy as codedeploy
        import aws_cdk.aws_lambda as lambda_
        
        my_application = codedeploy.LambdaApplication()
        func = lambda_.Function()
        version = func.add_version("1")
        version1_alias = lambda_.Alias(self, "alias",
            alias_name="prod",
            version=version
        )
        
        deployment_group = codedeploy.LambdaDeploymentGroup(stack, "BlueGreenDeployment",
            application=my_application, # optional property: one will be created for you if not provided
            alias=version1_alias,
            deployment_config=codedeploy.LambdaDeploymentConfig.LINEAR_10PERCENT_EVERY_1MINUTE
        )
        ```
        
        In order to deploy a new version of this function:
        
        1. Increment the version, e.g. `const version = func.addVersion('2')`.
        2. Re-deploy the stack (this will trigger a deployment).
        3. Monitor the CodeDeploy deployment as traffic shifts between the versions.
        
        ### Create a custom Deployment Config
        
        CodeDeploy for Lambda comes with built-in configurations for traffic shifting.
        If you want to specify your own strategy,
        you can do so with the CustomLambdaDeploymentConfig construct,
        letting you specify precisely how fast a new function version is deployed.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        config = codedeploy.CustomLambdaDeploymentConfig(stack, "CustomConfig",
            type=codedeploy.CustomLambdaDeploymentConfigType.CANARY,
            interval=Duration.minutes(1),
            percentage=5
        )
        deployment_group = codedeploy.LambdaDeploymentGroup(stack, "BlueGreenDeployment",
            application=application,
            alias=alias,
            deployment_config=config
        )
        ```
        
        You can specify a custom name for your deployment config, but if you do you will not be able to update the interval/percentage through CDK.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        config = codedeploy.CustomLambdaDeploymentConfig(stack, "CustomConfig",
            type=codedeploy.CustomLambdaDeploymentConfigType.CANARY,
            interval=Duration.minutes(1),
            percentage=5,
            deployment_config_name="MyDeploymentConfig"
        )
        ```
        
        ### Rollbacks and Alarms
        
        CodeDeploy will roll back if the deployment fails. You can optionally trigger a rollback when one or more alarms are in a failed state:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        deployment_group = codedeploy.LambdaDeploymentGroup(stack, "BlueGreenDeployment",
            alias=alias,
            deployment_config=codedeploy.LambdaDeploymentConfig.LINEAR_10PERCENT_EVERY_1MINUTE,
            alarms=[
                # pass some alarms when constructing the deployment group
                cloudwatch.Alarm(stack, "Errors",
                    comparison_operator=cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,
                    threshold=1,
                    evaluation_periods=1,
                    metric=alias.metric_errors()
                )
            ]
        )
        
        # or add alarms to an existing group
        deployment_group.add_alarm(cloudwatch.Alarm(stack, "BlueGreenErrors",
            comparison_operator=cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,
            threshold=1,
            evaluation_periods=1,
            metric=blue_green_alias.metric_errors()
        ))
        ```
        
        ### Pre and Post Hooks
        
        CodeDeploy allows you to run an arbitrary Lambda function before traffic shifting actually starts (PreTraffic Hook) and after it completes (PostTraffic Hook).
        With either hook, you have the opportunity to run logic that determines whether the deployment must succeed or fail.
        For example, with PreTraffic hook you could run integration tests against the newly created Lambda version (but not serving traffic). With PostTraffic hook, you could run end-to-end validation checks.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        warm_up_user_cache = lambda_.Function()
        end_to_end_validation = lambda_.Function()
        
        # pass a hook whe creating the deployment group
        deployment_group = codedeploy.LambdaDeploymentGroup(stack, "BlueGreenDeployment",
            alias=alias,
            deployment_config=codedeploy.LambdaDeploymentConfig.LINEAR_10PERCENT_EVERY_1MINUTE,
            pre_hook=warm_up_user_cache
        )
        
        # or configure one on an existing deployment group
        deployment_group.on_post_hook(end_to_end_validation)
        ```
        
        ### Import an existing Deployment Group
        
        To import an already existing Deployment Group:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        deployment_group = codedeploy.LambdaDeploymentGroup.import(self, "ExistingCodeDeployDeploymentGroup",
            application=application,
            deployment_group_name="MyExistingDeploymentGroup"
        )
        ```
        
Platform: UNKNOWN
Classifier: Intended Audience :: Developers
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: JavaScript
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Typing :: Typed
Classifier: Development Status :: 5 - Production/Stable
Classifier: License :: OSI Approved
Classifier: Framework :: AWS CDK
Classifier: Framework :: AWS CDK :: 1
Requires-Python: >=3.6
Description-Content-Type: text/markdown
