cft.yml

AWSTemplateFormatVersion: 2010-09-09
Parameters:
# Uncomment the network-related parameters if you wish to use your own predefined resources
#   VPC:
#     Type: 'AWS::EC2::VPC::Id'
#     Description: Select a VPC that allows instances to access the Internet.
#   PublicSubnetOne:
#     Type: 'AWS::EC2::Subnet::Id'
#     Description: Select a public subnet in your selected VPC.
#   PublicSubnetTwo:
#     Type: 'AWS::EC2::Subnet::Id'
#     Description: Select one more public subnet in your selected VPC.
#   PrivateSubnetOne:
#     Type: 'AWS::EC2::Subnet::Id'
#     Description: Select a private subnet in your selected VPC.
#   PrivateSubnetTwo:
#     Type: 'AWS::EC2::Subnet::Id'
#     Description: Select another private subnet in your selected VPC .
  ContainerCpu:
    Type: Number
    Default: 256
    Description: How much CPU to give the container. 1024 is 1 CPU
  ContainerMemory:
    Type: Number
    Default: 512
    Description: How much memory in megabytes to give the container
  SeleniumImageVersion:
    Type: String
    Default: 3.141.59
    Description: >-
      Version of the Selenium docker images - hub, node-chrome and node-firefox
      - to be used.
  Path:
    Type: String
    Default: '*'
    Description: >-
      A path on the public load balancer that this service should be connected
      to. Use * to send all load balancer traffic to this service.
  Priority:
    Type: Number
    Default: 1
    Description: >-
      The priority for the routing rule added to the load balancer. This only
      applies if your have multiple services which have been assigned to
      different paths on the load balancer.
  Role:
    Type: String
    Default: ''
    Description: >-
      (Optional) An IAM role to give the service's containers if the code within
      needs to access other AWS resources like S3 buckets, DynamoDB tables, etc
Conditions:
  HasCustomRole: !Not 
    - !Equals 
      - !Ref Role
      - ''
Mappings:
  SubnetConfig:
    VPC:
      CIDR: 10.0.0.0/16
    PublicOne:
      CIDR: 10.0.0.0/24
    PublicTwo:
      CIDR: 10.0.1.0/24
    PrivateOne:
      CIDR: 10.0.2.0/24
    PrivateTwo:
      CIDR: 10.0.3.0/24
Resources:
  # VPC in which containers will be networked.
  # It has two public subnets, and two private subnets.
  # We distribute the subnets across the first two available subnets
  # for the region, for high availability.
  VPC:
    Type: 'AWS::EC2::VPC'
    Properties:
      EnableDnsSupport: true
      EnableDnsHostnames: true
      CidrBlock: !FindInMap 
        - SubnetConfig
        - VPC
        - CIDR
  PublicSubnetOne:
    Type: 'AWS::EC2::Subnet'
    Properties:
      AvailabilityZone:
        'Fn::Select':
          - 0
          - 'Fn::GetAZs':
              Ref: 'AWS::Region'
      VpcId: !Ref VPC
      CidrBlock: !FindInMap 
        - SubnetConfig
        - PublicOne
        - CIDR
      MapPublicIpOnLaunch: true
  PublicSubnetTwo:
    Type: 'AWS::EC2::Subnet'
    Properties:
      AvailabilityZone:
        'Fn::Select':
          - 1
          - 'Fn::GetAZs':
              Ref: 'AWS::Region'
      VpcId: !Ref VPC
      CidrBlock: !FindInMap 
        - SubnetConfig
        - PublicTwo
        - CIDR
      MapPublicIpOnLaunch: true
  
  # Two private subnets where containers will only have private
  # IP addresses, and will only be reachable by other members of the
  # VPC
  
  PrivateSubnetOne:
    Type: 'AWS::EC2::Subnet'
    Properties:
      AvailabilityZone:
        'Fn::Select':
          - 0
          - 'Fn::GetAZs':
              Ref: 'AWS::Region'
      VpcId: !Ref VPC
      CidrBlock: !FindInMap 
        - SubnetConfig
        - PrivateOne
        - CIDR
  PrivateSubnetTwo:
    Type: 'AWS::EC2::Subnet'
    Properties:
      AvailabilityZone:
        'Fn::Select':
          - 1
          - 'Fn::GetAZs':
              Ref: 'AWS::Region'
      VpcId: !Ref VPC
      CidrBlock: !FindInMap 
        - SubnetConfig
        - PrivateTwo
        - CIDR
        
  # Setup networking resources for the public subnets. Containers
  # in the public subnets have public IP addresses and the routing table
  # sends network traffic via the internet gateway.

  InternetGateway:
    Type: 'AWS::EC2::InternetGateway'
  GatewayAttachement:
    Type: 'AWS::EC2::VPCGatewayAttachment'
    Properties:
      VpcId: !Ref VPC
      InternetGatewayId: !Ref InternetGateway
  PublicRouteTable:
    Type: 'AWS::EC2::RouteTable'
    Properties:
      VpcId: !Ref VPC
  PublicRoute:
    Type: 'AWS::EC2::Route'
    DependsOn: GatewayAttachement
    Properties:
      RouteTableId: !Ref PublicRouteTable
      DestinationCidrBlock: 0.0.0.0/0
      GatewayId: !Ref InternetGateway
  PublicSubnetOneRouteTableAssociation:
    Type: 'AWS::EC2::SubnetRouteTableAssociation'
    Properties:
      SubnetId: !Ref PublicSubnetOne
      RouteTableId: !Ref PublicRouteTable
  PublicSubnetTwoRouteTableAssociation:
    Type: 'AWS::EC2::SubnetRouteTableAssociation'
    Properties:
      SubnetId: !Ref PublicSubnetTwo
      RouteTableId: !Ref PublicRouteTable
  
  # Setup networking resources for the private subnets. Containers
  # in these subnets have only private IP addresses, and must use a NAT
  # gateway to talk to the internet. We launch two NAT gateways, one for
  # each private subnet.
  
  NatGatewayOneAttachment:
    Type: 'AWS::EC2::EIP'
    DependsOn: GatewayAttachement
    Properties:
      Domain: vpc
  NatGatewayTwoAttachment:
    Type: 'AWS::EC2::EIP'
    DependsOn: GatewayAttachement
    Properties:
      Domain: vpc
  NatGatewayOne:
    Type: 'AWS::EC2::NatGateway'
    Properties:
      AllocationId: !GetAtt 
        - NatGatewayOneAttachment
        - AllocationId
      SubnetId: !Ref PublicSubnetOne
  NatGatewayTwo:
    Type: 'AWS::EC2::NatGateway'
    Properties:
      AllocationId: !GetAtt 
        - NatGatewayTwoAttachment
        - AllocationId
      SubnetId: !Ref PublicSubnetTwo
  PrivateRouteTableOne:
    Type: 'AWS::EC2::RouteTable'
    Properties:
      VpcId: !Ref VPC
  PrivateRouteOne:
    Type: 'AWS::EC2::Route'
    Properties:
      RouteTableId: !Ref PrivateRouteTableOne
      DestinationCidrBlock: 0.0.0.0/0
      NatGatewayId: !Ref NatGatewayOne
  PrivateRouteTableOneAssociation:
    Type: 'AWS::EC2::SubnetRouteTableAssociation'
    Properties:
      RouteTableId: !Ref PrivateRouteTableOne
      SubnetId: !Ref PrivateSubnetOne
  PrivateRouteTableTwo:
    Type: 'AWS::EC2::RouteTable'
    Properties:
      VpcId: !Ref VPC
  PrivateRouteTwo:
    Type: 'AWS::EC2::Route'
    Properties:
      RouteTableId: !Ref PrivateRouteTableTwo
      DestinationCidrBlock: 0.0.0.0/0
      NatGatewayId: !Ref NatGatewayTwo
  PrivateRouteTableTwoAssociation:
    Type: 'AWS::EC2::SubnetRouteTableAssociation'
    Properties:
      RouteTableId: !Ref PrivateRouteTableTwo
      SubnetId: !Ref PrivateSubnetTwo
      
 # ECS-Fargate Resources
  SeleniumGrid:
    Type: 'AWS::ECS::Cluster'
    Properties:
      ClusterName: selenium-grid
  SeleniumGridContainerSecurityGroup:
    Type: 'AWS::EC2::SecurityGroup'
    Properties:
      GroupDescription: Access to the Fargate containers
      VpcId: !Ref VPC
  EcsSecurityGroupIngressFromPublicALB:
    Type: 'AWS::EC2::SecurityGroupIngress'
    Properties:
      Description: Ingress from the public ALB
      GroupId: !Ref SeleniumGridContainerSecurityGroup
      IpProtocol: -1
      SourceSecurityGroupId: !Ref SeleniumLoadBalancerSG

  EcsSecurityGroupIngressFromSelf:
    Type: 'AWS::EC2::SecurityGroupIngress'
    Properties:
      Description: Ingress from other containers in the same security group
      GroupId: !Ref SeleniumGridContainerSecurityGroup
      IpProtocol: -1
      SourceSecurityGroupId: !Ref SeleniumGridContainerSecurityGroup
      
  # A public facing load balancer, this is used for accepting traffic from the public
  # internet and directing it to public facing containers
  SeleniumLoadBalancerSG:
    Type: 'AWS::EC2::SecurityGroup'
    Properties:
      GroupDescription: Access to the public facing load balancer
      VpcId: !Ref VPC
      SecurityGroupIngress:
        - CidrIp: 0.0.0.0/0
          IpProtocol: -1
  SeleniumLoadBalancer:
    Type: 'AWS::ElasticLoadBalancingV2::LoadBalancer'
    Properties:
      Scheme: internet-facing
      LoadBalancerAttributes:
        - Key: idle_timeout.timeout_seconds
          Value: '100'
      
        # The load balancer is placed into the public subnets, so that traffic
        # from the internet can reach the load balancer directly via the internet gateway
      Subnets:
        - !Ref PublicSubnetOne
        - !Ref PublicSubnetTwo
      SecurityGroups:
        - !Ref SeleniumLoadBalancerSG
  DummyTargetGroupPublic:
    Type: 'AWS::ElasticLoadBalancingV2::TargetGroup'
    Properties:
      HealthCheckIntervalSeconds: 6
      HealthCheckPath: /
      HealthCheckProtocol: HTTP
      HealthCheckTimeoutSeconds: 5
      HealthyThresholdCount: 2
      Name: !Join 
        - '-'
        - - !Ref 'AWS::StackName'
          - drop-1
      Port: 4444
      Protocol: HTTP
      UnhealthyThresholdCount: 2
      VpcId: !Ref VPC
  SeleniumLoadBalancerListener:
    Type: 'AWS::ElasticLoadBalancingV2::Listener'
    DependsOn: SeleniumLoadBalancer
    Properties:
      DefaultActions:
        - TargetGroupArn: !Ref DummyTargetGroupPublic
          Type: forward
      LoadBalancerArn: !Ref SeleniumLoadBalancer
      Port: 4444
      Protocol: HTTP
      
  # This is an IAM role which authorizes ECS to manage resources on your
  # account on your behalf, such as updating your load balancer with the
  # details of where your containers are, so that traffic can reach your
  # containers.
  
  ECSRole:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - ecs.amazonaws.com
            Action:
              - 'sts:AssumeRole'
      Path: /
      Policies:
        - PolicyName: ecs-service
          PolicyDocument:
            Statement:
              - Effect: Allow
                Action:
              # Rules which allow ECS to attach network interfaces to instances
              # on your behalf in order for awsvpc networking mode to work right                
                  - 'ec2:AttachNetworkInterface'
                  - 'ec2:CreateNetworkInterface'
                  - 'ec2:CreateNetworkInterfacePermission'
                  - 'ec2:DeleteNetworkInterface'
                  - 'ec2:DeleteNetworkInterfacePermission'
                  - 'ec2:Describe*'
                  - 'ec2:DetachNetworkInterface'
                  
              # Rules which allow ECS to update load balancers on your behalf
              # with the information sabout how to send traffic to your containers
                  - 'elasticloadbalancing:DeregisterInstancesFromLoadBalancer'
                  - 'elasticloadbalancing:DeregisterTargets'
                  - 'elasticloadbalancing:Describe*'
                  - 'elasticloadbalancing:RegisterInstancesWithLoadBalancer'
                  - 'elasticloadbalancing:RegisterTargets'
                Resource: '*'
                
  # This is a role which is used by the ECS tasks themselves.                
  ECSTaskExecutionRole:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - ecs-tasks.amazonaws.com
            Action:
              - 'sts:AssumeRole'
      Path: /
      Policies:
        - PolicyName: AmazonECSTaskExecutionRolePolicy
          PolicyDocument:
            Statement:
              - Effect: Allow
                Action:
                # Allow the ECS Tasks to download images from ECR
                  - 'ecr:GetAuthorizationToken'
                  - 'ecr:BatchCheckLayerAvailability'
                  - 'ecr:GetDownloadUrlForLayer'
                  - 'ecr:BatchGetImage'                
                  
                # Allow the ECS tasks to upload logs to CloudWatch
                  - 'logs:CreateLogStream'
                  - 'logs:CreateLogGroup'
                  - 'logs:DescribeLogGroups'
                  - 'logs:DescribeLogStreams'
                  - 'logs:PutLogEvents'
                Resource: '*'
  LogGroup:
    Type: 'AWS::Logs::LogGroup'
    Properties:
      LogGroupName: selenium-grid
      RetentionInDays: 30
  TaskDefinitionHub:
    Type: 'AWS::ECS::TaskDefinition'
    Properties:
      Cpu: !Ref ContainerCpu
      Memory: !Ref ContainerMemory
      NetworkMode: awsvpc
      RequiresCompatibilities:
        - FARGATE
      ExecutionRoleArn: !GetAtt 
        - ECSTaskExecutionRole
        - Arn
      ContainerDefinitions:
        - Name: selenium-hub
          Cpu: !Ref ContainerCpu
          Memory: !Ref ContainerMemory
          Image: !Join 
            - ':'
            - - 'selenium/hub'
              - !Ref SeleniumImageVersion
          Environment:
            - Name: SE_OPTS
              Value: '-debug'
            - Name: GRID_TIMEOUT
              Value: '180'
            - Name: GRID_BROWSER_TIMEOUT
              Value: '200000'
          LogConfiguration:
            LogDriver: awslogs
            Options:
              awslogs-group: !Ref LogGroup
              awslogs-region: !Ref 'AWS::Region'
              awslogs-stream-prefix: selenium-logs
          PortMappings:
            - ContainerPort: 4444
  TaskDefinitionNodeChrome:
    Type: 'AWS::ECS::TaskDefinition'
    Properties:
      Cpu: !Ref ContainerCpu
      Memory: !Ref ContainerMemory
      NetworkMode: awsvpc
      RequiresCompatibilities:
        - FARGATE
      ExecutionRoleArn: !GetAtt 
        - ECSTaskExecutionRole
        - Arn
      ContainerDefinitions:
        - Name: selenium-node-chrome
          Cpu: !Ref ContainerCpu
          Memory: !Ref ContainerMemory
          Image: !Join 
            - ':'
            - - 'selenium/node-chrome'
              - !Ref SeleniumImageVersion
          Environment:
            - Name: HUB_PORT_4444_TCP_ADDR
              Value: !GetAtt 
                - SeleniumLoadBalancer
                - DNSName
            - Name: HUB_PORT_4444_TCP_PORT
              Value: '4444'
            - Name: NODE_MAX_INSTANCES
              Value: '5'
            - Name: NODE_MAX_SESSION
              Value: '5'
            - Name: shm_size
              Value: 512
            - Name: SE_OPTS
              Value: '-debug'
          LogConfiguration:
            LogDriver: awslogs
            Options:
              awslogs-group: !Ref LogGroup
              awslogs-region: !Ref 'AWS::Region'
              awslogs-stream-prefix: selenium-logs
          EntryPoint:
            - sh
            - '-c'
          Command:
            - >-
              PRIVATE=$(curl -s http://169.254.170.2/v2/metadata | jq -r
              '.Containers[1].Networks[0].IPv4Addresses[0]') ; export
              REMOTE_HOST="http://$PRIVATE:5555" ; /opt/bin/entry_point.sh

  TaskDefinitionNodeFirefox:
    Type: 'AWS::ECS::TaskDefinition'
    Properties:
      Cpu: !Ref ContainerCpu
      Memory: !Ref ContainerMemory
      NetworkMode: awsvpc
      RequiresCompatibilities:
        - FARGATE
      ExecutionRoleArn: !GetAtt 
        - ECSTaskExecutionRole
        - Arn
      ContainerDefinitions:
        - Name: selenium-node-firefox
          Cpu: !Ref ContainerCpu
          Memory: !Ref ContainerMemory
          Image: !Join 
            - ':'
            - - 'selenium/node-firefox'
              - !Ref SeleniumImageVersion
          Environment:
            - Name: HUB_PORT_4444_TCP_ADDR
              Value: !GetAtt 
                - SeleniumLoadBalancer
                - DNSName
            - Name: HUB_PORT_4444_TCP_PORT
              Value: '4444'
            - Name: NODE_MAX_INSTANCES
              Value: '5'
            - Name: NODE_MAX_SESSION
              Value: '5'
          LogConfiguration:
            LogDriver: awslogs
            Options:
              awslogs-group: !Ref LogGroup
              awslogs-region: !Ref 'AWS::Region'
              awslogs-stream-prefix: selenium-logs
          EntryPoint:
            - sh
            - '-c'
          Command:
            - >-
              PRIVATE=$(curl -s http://169.254.170.2/v2/metadata | jq -r
              '.Containers[1].Networks[0].IPv4Addresses[0]') ; export
              REMOTE_HOST="http://$PRIVATE:5555" ; /opt/bin/entry_point.sh

  ServiceHub:
    Type: 'AWS::ECS::Service'
    DependsOn: LoadBalancerRule
    Properties:
      ServiceName: selenium-hub-service
      Cluster: !Ref SeleniumGrid
      LaunchType: FARGATE
      DeploymentConfiguration:
        MaximumPercent: 200
        MinimumHealthyPercent: 75
      DesiredCount: 1
      NetworkConfiguration:
        AwsvpcConfiguration:
          AssignPublicIp: ENABLED
          SecurityGroups:
            - !Ref SeleniumGridContainerSecurityGroup
          Subnets:
            - !Ref PrivateSubnetOne
            - !Ref PrivateSubnetTwo
      TaskDefinition: !Ref TaskDefinitionHub
      Role: !If 
        - HasCustomRole
        - !Ref Role
        - !Ref 'AWS::NoValue'
      LoadBalancers:
        - ContainerName: selenium-hub
          ContainerPort: 4444
          TargetGroupArn: !Ref SeleniumGridTargetGroup
  ServiceNodeChrome:
    Type: 'AWS::ECS::Service'
    DependsOn: ServiceHub
    Properties:
      ServiceName: node-chrome
      Cluster: !Ref SeleniumGrid
      LaunchType: FARGATE
      DeploymentConfiguration:
        MaximumPercent: 200
        MinimumHealthyPercent: 75
      DesiredCount: 2
      NetworkConfiguration:
        AwsvpcConfiguration:
          AssignPublicIp: ENABLED
          SecurityGroups:
            - !Ref SeleniumGridContainerSecurityGroup
          Subnets:
            - !Ref PrivateSubnetOne
            - !Ref PrivateSubnetTwo
      TaskDefinition: !Ref TaskDefinitionNodeChrome
  ServiceNodeFirefox:
    Type: 'AWS::ECS::Service'
    DependsOn: ServiceHub
    Properties:
      ServiceName: node-firefox
      Cluster: !Ref SeleniumGrid
      LaunchType: FARGATE
      DeploymentConfiguration:
        MaximumPercent: 200
        MinimumHealthyPercent: 75
      DesiredCount: 2
      NetworkConfiguration:
        AwsvpcConfiguration:
          AssignPublicIp: ENABLED
          SecurityGroups:
            - !Ref SeleniumGridContainerSecurityGroup
          Subnets:
            - !Ref PrivateSubnetOne
            - !Ref PrivateSubnetTwo
      TaskDefinition: !Ref TaskDefinitionNodeFirefox
  SeleniumGridTargetGroup:
    Type: 'AWS::ElasticLoadBalancingV2::TargetGroup'
    Properties:
      HealthCheckIntervalSeconds: 6
      HealthCheckPath: /
      HealthCheckProtocol: HTTP
      HealthCheckTimeoutSeconds: 5
      HealthyThresholdCount: 2
      TargetType: ip
      Name: selenium-grid
      Port: 4444
      Protocol: HTTP
      UnhealthyThresholdCount: 2
      VpcId: !Ref VPC
  LoadBalancerRule:
    Type: 'AWS::ElasticLoadBalancingV2::ListenerRule'
    DependsOn: SeleniumLoadBalancerListener
    Properties:
      Actions:
        - TargetGroupArn: !Ref SeleniumGridTargetGroup
          Type: forward
      Conditions:
        - Field: path-pattern
          Values:
            - !Ref Path
      ListenerArn: !Ref SeleniumLoadBalancerListener
      Priority: !Ref Priority
      
  # Resources for auto-scaling browser clusters
  AutoscalingRole:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
         Statement:
           - Effect: Allow
             Principal:
               Service:
               - application-autoscaling.amazonaws.com
             Action:
               - 'sts:AssumeRole'
      Path: /
      Policies:
        - PolicyName: service-autoscaling
          PolicyDocument:
            Statement:
              - Effect: Allow
                Action:
                  - 'application-autoscaling:*'
                  - 'cloudwatch:DescribeAlarms'
                  - 'cloudwatch:PutMetricAlarm'
                  - 'ecs:DescribeServices'
                  - 'ecs:UpdateService'
                Resource: '*'


  FirefoxScalableTarget:
    Type: 'AWS::ApplicationAutoScaling::ScalableTarget'
    DependsOn: ServiceNodeFirefox
    Properties:
      ResourceId: !Join 
        - /
        - - service
          - !Ref SeleniumGrid
          - !GetAtt 
            - ServiceNodeFirefox
            - Name
      ServiceNamespace: ecs
      ScalableDimension: 'ecs:service:DesiredCount'
      RoleARN: !GetAtt 
        - AutoscalingRole
        - Arn
      MaxCapacity: '4'
      MinCapacity: '0'
  FirefoxServiceScaleOutPolicy:
    Type: 'AWS::ApplicationAutoScaling::ScalingPolicy'
    DependsOn: FirefoxScalableTarget
    Properties:
      PolicyName: autoscale_firefox_service
      PolicyType: StepScaling
      ScalingTargetId: !Ref FirefoxScalableTarget
      StepScalingPolicyConfiguration:
        AdjustmentType: ChangeInCapacity
        Cooldown: 180
        MetricAggregationType: Average
        StepAdjustments:
          - ScalingAdjustment: 2
            MetricIntervalLowerBound: 0
  ChromeScalableTarget:
    Type: 'AWS::ApplicationAutoScaling::ScalableTarget'
    DependsOn: ServiceNodeChrome
    Properties:
      ResourceId: !Join 
        - /
        - - service
          - !Ref SeleniumGrid
          - !GetAtt 
            - ServiceNodeChrome
            - Name
      ServiceNamespace: ecs
      ScalableDimension: 'ecs:service:DesiredCount'
      RoleARN: !GetAtt 
        - AutoscalingRole
        - Arn
      MaxCapacity: '36'
      MinCapacity: '0'
  ChromeServiceScaleOutPolicy:
    Type: 'AWS::ApplicationAutoScaling::ScalingPolicy'
    DependsOn: ChromeScalableTarget
    Properties:
      PolicyName: autoscale_chrome_service
      PolicyType: StepScaling
      ScalingTargetId: !Ref ChromeScalableTarget
      StepScalingPolicyConfiguration:
        AdjustmentType: ChangeInCapacity
        Cooldown: 180
        MetricAggregationType: Average
        StepAdjustments:
          - ScalingAdjustment: 1
            MetricIntervalLowerBound: 0
  NodeServiceCPUScaleOutAlarm:
    Type: 'AWS::CloudWatch::Alarm'
    Properties:
      AlarmName: SELENIUM_FARGATE_NODE_CPU_80PCT_1MIN_DEV
      EvaluationPeriods: '1'
      Statistic: Maximum
      TreatMissingData: missing
      Threshold: '80'
      AlarmDescription: Alarm to add capacity if CPU is high
      Period: 60
      AlarmActions:
        - !Ref FirefoxServiceScaleOutPolicy
        - !Ref ChromeServiceScaleOutPolicy
      Namespace: AWS/ECS
      Dimensions:
        - Name: ClusterName
          Value: !Ref SeleniumGrid
        - Name: ServiceName
          Value: !GetAtt 
            - ServiceNodeFirefox
            - Name
      ComparisonOperator: GreaterThanOrEqualToThreshold
      MetricName: CPUUtilization
  NodeServiceMemoryScaleOutAlarm:
    Type: 'AWS::CloudWatch::Alarm'
    Properties:
      AlarmName: SELENIUM_FARGATE_NODE_MEMORY_80PCT_1MIN_DEV
      EvaluationPeriods: '1'
      Statistic: Maximum
      TreatMissingData: missing
      Threshold: '80'
      AlarmDescription: Alarm to add capacity if MEMORY is high
      Period: 60
      AlarmActions:
        - !Ref FirefoxServiceScaleOutPolicy
        - !Ref ChromeServiceScaleOutPolicy
      Namespace: AWS/ECS
      Dimensions:
        - Name: ClusterName
          Value: !Ref SeleniumGrid
        - Name: ServiceName
          Value: !GetAtt 
            - ServiceNodeFirefox
            - Name
      ComparisonOperator: GreaterThanOrEqualToThreshold
      MetricName: MemoryUtilization
# Optional
#   RecordSet:
#     Type: 'AWS::Route53::RecordSetGroup'
#     DependsOn: SeleniumLoadBalancer
#     Properties:
#       HostedZoneId: !GetAtt 
#         - SeleniumLoadBalancer
#         - CanonicalHostedZoneID
#       RecordSets:
#         - Name: !Join 
#             - .
#             - - selenium-grid
#               - !Ref DomainName
#           Type: CNAME
#           TTL: '300'
#           ResourceRecords:
#             - !GetAtt 
#               - SeleniumLoadBalancer
#               - DNSName    
Outputs:
  ExternalUrl:
    Description: The url of the external load balancer
    Value: !Join 
      - ''
      - - 'http://'
        - !GetAtt 
          - SeleniumLoadBalancer
          - DNSName
    Export:
      Name: !Join 
        - ':'
        - - !Ref 'AWS::StackName'
          - ExternalUrl