Add CloudFormation support to AWS::ElasticLoadBalancingV2::LoadBalancer

moto/cloudformation/parsing.py

@@ -15,6 +15,7 @@ from moto.dynamodb import models as dynamodb_models
 from moto.ec2 import models as ec2_models
 from moto.ecs import models as ecs_models
 from moto.elb import models as elb_models
+from moto.elbv2 import models as elbv2_models
 from moto.iam import models as iam_models
 from moto.kinesis import models as kinesis_models
 from moto.kms import models as kms_models
@@ -61,6 +62,7 @@ MODEL_MAP = {
     "AWS::ECS::TaskDefinition": ecs_models.TaskDefinition,
     "AWS::ECS::Service": ecs_models.Service,
     "AWS::ElasticLoadBalancing::LoadBalancer": elb_models.FakeLoadBalancer,
+    "AWS::ElasticLoadBalancingV2::LoadBalancer": elbv2_models.FakeLoadBalancer,
     "AWS::DataPipeline::Pipeline": datapipeline_models.Pipeline,
     "AWS::IAM::InstanceProfile": iam_models.InstanceProfile,
     "AWS::IAM::Role": iam_models.Role,

moto/elbv2/models.py

@@ -186,6 +186,20 @@ class FakeLoadBalancer(BaseModel):
         ''' Not exposed as part of the ELB API - used for CloudFormation. '''
         elbv2_backends[region].delete_load_balancer(self.arn)
 
+    @classmethod
+    def create_from_cloudformation_json(cls, resource_name, cloudformation_json, region_name):
+        properties = cloudformation_json['Properties']
+
+        elbv2_backend = elbv2_backends[region_name]
+
+        name = properties.get('Name')
+        security_groups = properties.get("SecurityGroups")
+        subnet_ids = properties.get('Subnets')
+        scheme = properties.get('Scheme', 'internet-facing')
+
+        load_balancer = elbv2_backend.create_load_balancer(name, security_groups, subnet_ids, scheme=scheme)
+        return load_balancer
+
 
 class ELBv2Backend(BaseBackend):
 

tests/test_cloudformation/test_cloudformation_stack_integration.py

@@ -38,7 +38,7 @@ from moto import (
     mock_sns_deprecated,
     mock_sqs,
     mock_sqs_deprecated,
-)
+    mock_elbv2)
 
 from .fixtures import (
     ec2_classic_eip,
@@ -2111,3 +2111,113 @@ def test_stack_spot_fleet():
     launch_spec['SubnetId'].should.equal(subnet_id)
     launch_spec['SpotPrice'].should.equal("0.13")
     launch_spec['WeightedCapacity'].should.equal(2.0)
+
+
+@mock_ec2
+@mock_elbv2
+@mock_cloudformation
+def test_stack_elbv2_resources_integration():
+    alb_template = {
+        "AWSTemplateFormatVersion": "2010-09-09",
+        "Resources": {
+            "alb": {
+                  "Type": "AWS::ElasticLoadBalancingV2::LoadBalancer",
+                  "Properties": {
+                        "Name": "myelbv2",
+                        "Scheme": "internet-facing",
+                        "Subnets": [{
+                            "Ref": "mysubnet",
+                        }],
+                        "SecurityGroups": [{
+                            "Ref": "mysg",
+                        }],
+                        "Type": "application",
+                        "IpAddressType": "ipv4",
+                  }
+            },
+            "mytargetgroup": {
+                "Type": "AWS::ElasticLoadBalancingV2::TargetGroup",
+                "Properties": {
+                    "HealthCheckIntervalSeconds": 30,
+                    "HealthCheckPath": "/status",
+                    "HealthCheckPort": 80,
+                    "HealthCheckProtocol": "HTTP",
+                    "HealthCheckTimeoutSeconds": 5,
+                    "HealthyThresholdCount": 30,
+                    "UnhealthyThresholdCount": 5,
+                    "Matcher": {
+                        "HttpCode": "200,201"
+                    },
+                    "Name": "mytargetgroup",
+                    "Port": 80,
+                    "Protocol": "HTTP",
+                    "TargetType": "instance",
+                    "Targets": [{
+                      "Id": {
+                          "Ref": "ec2instance",
+                          "Port": 80,
+                      },
+                    }],
+                    "VpcId": {
+                        "Ref": "myvpc",
+                    }
+                }
+            },
+            "listener": {
+                "Type": "AWS::ElasticLoadBalancingV2::Listener",
+                "Properties": {
+                    "DefaultActions": [{
+                        "Type": "forward",
+                        "TargetGroupArn": {"Ref": "mytargetgroup"}
+                    }],
+                    "LoadBalancerArn": {"Ref": "alb"},
+                    "Port": "80",
+                    "Protocol": "HTTP"
+                }
+            },
+            "myvpc": {
+                "Type": "AWS::EC2::VPC",
+                "Properties": {
+                    "CidrBlock": "10.0.0.0/16",
+                }
+            },
+            "mysubnet": {
+                "Type": "AWS::EC2::Subnet",
+                "Properties": {
+                    "CidrBlock": "10.0.0.0/27",
+                    "VpcId": {"Ref": "myvpc"},
+                }
+            },
+            "mysg": {
+                "Type": "AWS::EC2::SecurityGroup",
+                "Properties": {
+                    "GroupName": "mysg",
+                    "GroupDescription": "test security group",
+                    "VpcId": {"Ref": "myvpc"}
+                }
+            },
+            "ec2instance": {
+                "Type": "AWS::EC2::Instance",
+                "Properties": {
+                    "ImageId": "ami-1234abcd",
+                    "UserData": "some user data",
+                }
+            },
+        },
+    }
+    alb_template_json = json.dumps(alb_template)
+
+    conn = boto3.client("cloudformation", "us-west-1")
+    conn.create_stack(
+        StackName="elb_stack",
+        TemplateBody=alb_template_json,
+    )
+
+    elbv2_conn = boto3.client("elbv2", "us-west-1")
+
+    load_balancers = elbv2_conn.describe_load_balancers()['LoadBalancers']
+    assert len(load_balancers) == 1
+    assert load_balancers[0]['LoadBalancerName'] == 'myelbv2'
+    assert load_balancers[0]['Scheme'] == 'internet-facing'
+    assert load_balancers[0]['Type'] == 'application'
+    assert load_balancers[0]['IpAddressType'] == 'ipv4'