ecs_deploy_cli 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c4714117729290e91e7d5869862246b6aee1d023bbeca7681b92620f18dd03e
-  data.tar.gz: e6ddab9870c19af272723491398afd4ca49bf8f647182270ac71c0c3b08aa578
+  metadata.gz: 36c1f26447ccb1748f1c064fbee8c5417502162d564e43b697148f0c9b399a12
+  data.tar.gz: d2571aff0f5ae5dcdf556a3b3cdeb9177310bcbb230a0817d92c7d276d8fcd30
 SHA512:
-  metadata.gz: 7dc1d20820ebf9f6d9c300b8f0f31df44ca256b379d6e84ca10e0c48f120ea566e94a61cb25694462fe03f67ae35b8658e64e0af4d5253ee14a9717c614b2377
-  data.tar.gz: 903942389ab805b9201c46d55562994648bc8102b5ad6bed62770674cc115f39127d482fa8afd405dde058372413ef684d33e52af6509b4e0d4e4f4eab3b07bd
+  metadata.gz: 71e0f4b2ac6191c6bc8194f07a352ddb51056caa1b30071e7a92a108ca22b0a2d6fe0fa4b5e92e7793a0df13c0260b96c1d0748939816014254bf4027afd524a
+  data.tar.gz: c40587c040e0077860b3cf573b8d03b31a189ec931143612de2f1184b72379562ff8cc03fe14da6415713cd230edf854ced7844c7b611435c1caa1f0b71021ab

data/lib/ecs_deploy_cli.rb

@@ -26,6 +26,7 @@ end
 
 require 'ecs_deploy_cli/version'
 require 'ecs_deploy_cli/dsl/auto_options'
+require 'ecs_deploy_cli/dsl/cluster'
 require 'ecs_deploy_cli/dsl/container'
 require 'ecs_deploy_cli/dsl/task'
 require 'ecs_deploy_cli/dsl/cron'

data/lib/ecs_deploy_cli/cli.rb

@@ -26,6 +26,13 @@ module EcsDeployCli
       puts "ECS Deploy CLI Version #{EcsDeployCli::VERSION}."
     end
 
+    desc 'setup', 'Creates the cluster and relative services'
+    option :file, default: 'ECSFile'
+    def setup
+      @parser = load(options[:file])
+      runner.setup!
+    end
+
     desc 'deploy-scheduled-tasks', 'Updates all scheduled tasks defined in your ECSFile'
     option :file, default: 'ECSFile'
     def deploy_scheduled_tasks

data/lib/ecs_deploy_cli/cloudformation/default.yml

@@ -0,0 +1,412 @@
+AWSTemplateFormatVersion: '2010-09-09'
+Description: >
+  AWS CloudFormation template to create a new VPC
+  or use an existing VPC for ECS deployment
+  in Create Cluster Wizard. Requires exactly 1
+  Instance Types for a Spot Request.
+Parameters:
+  EcsClusterName:
+    Type: String
+    Description: >
+      Specifies the ECS Cluster Name with which the resources would be
+      associated
+    Default: default
+  EcsAmiId:
+    Type: String
+    Description: Specifies the AMI ID for your container instances.
+  EcsInstanceType:
+    Type: CommaDelimitedList
+    Description: >
+      Specifies the EC2 instance type for your container instances.
+      Defaults to m4.large
+    Default: m4.large
+    ConstraintDescription: must be a valid EC2 instance type.
+  KeyName:
+    Type: String
+    Description: >
+      Optional - Specifies the name of an existing Amazon EC2 key pair
+      to enable SSH access to the EC2 instances in your cluster.
+    Default: ''
+  VpcId:
+    Type: String
+    Description: >
+      Optional - Specifies the ID of an existing VPC in which to launch
+      your container instances. If you specify a VPC ID, you must specify a list of
+      existing subnets in that VPC. If you do not specify a VPC ID, a new VPC is created
+      with atleast 1 subnet.
+    Default: ''
+    ConstraintDescription: >
+      VPC Id must begin with 'vpc-' or leave blank to have a
+      new VPC created
+  SubnetIds:
+    Type: CommaDelimitedList
+    Description: >
+      Optional - Specifies the Comma separated list of existing VPC Subnet
+      Ids where ECS instances will run
+    Default: ''
+  SecurityGroupId:
+    Type: String
+    Description: >
+      Optional - Specifies the Security Group Id of an existing Security
+      Group. Leave blank to have a new Security Group created
+    Default: ''
+  VpcCidr:
+    Type: String
+    Description: Optional - Specifies the CIDR Block of VPC
+    Default: ''
+  SubnetCidr1:
+    Type: String
+    Description: Specifies the CIDR Block of Subnet 1
+    Default: ''
+  SubnetCidr2:
+    Type: String
+    Description: Specifies the CIDR Block of Subnet 2
+    Default: ''
+  SubnetCidr3:
+    Type: String
+    Description: Specifies the CIDR Block of Subnet 3
+    Default: ''
+  AsgMaxSize:
+    Type: Number
+    Description: >
+      Specifies the number of instances to launch and register to the cluster.
+      Defaults to 1.
+    Default: '1'
+  IamRoleInstanceProfile:
+    Type: String
+    Description: >
+      Specifies the Name or the Amazon Resource Name (ARN) of the instance
+      profile associated with the IAM role for the instance
+  SecurityIngressFromPort:
+    Type: Number
+    Description: >
+      Optional - Specifies the Start of Security Group port to open on
+      ECS instances - defaults to port 0
+    Default: '0'
+  SecurityIngressToPort:
+    Type: Number
+    Description: >
+      Optional - Specifies the End of Security Group port to open on ECS
+      instances - defaults to port 65535
+    Default: '65535'
+  SecurityIngressCidrIp:
+    Type: String
+    Description: >
+      Optional - Specifies the CIDR/IP range for Security Ports - defaults
+      to 0.0.0.0/0
+    Default: 0.0.0.0/0
+  EcsEndpoint:
+    Type: String
+    Description: >
+      Optional - Specifies the ECS Endpoint for the ECS Agent to connect to
+    Default: ''
+  VpcAvailabilityZones:
+    Type: CommaDelimitedList
+    Description: >
+      Specifies a comma-separated list of 3 VPC Availability Zones for
+      the creation of new subnets. These zones must have the available status.
+    Default: ''
+  RootEbsVolumeSize:
+    Type: Number
+    Description: >
+      Optional - Specifies the Size in GBs of the root EBS volume
+    Default: 30
+  EbsVolumeSize:
+    Type: Number
+    Description: >
+      Optional - Specifies the Size in GBs of the data storage EBS volume used by the Docker in the AL1 ECS-optimized AMI
+    Default: 22
+  EbsVolumeType:
+    Type: String
+    Description: Optional - Specifies the Type of (Amazon EBS) volume
+    Default: ''
+    AllowedValues:
+      - ''
+      - standard
+      - io1
+      - gp2
+      - sc1
+      - st1
+    ConstraintDescription: Must be a valid EC2 volume type.
+  RootDeviceName:
+    Type: String
+    Description: Optional - Specifies the device mapping for the root EBS volume.
+    Default: /dev/xvda
+  DeviceName:
+    Type: String
+    Description: Optional - Specifies the device mapping for the EBS volume used for data storage. Only applicable to AL1.
+  UseSpot:
+    Type: String
+    Default: 'false'
+  IamSpotFleetRoleArn:
+    Type: String
+    Default: ''
+  SpotPrice:
+    Type: String
+    Default: ''
+  SpotAllocationStrategy:
+    Type: String
+    Default: 'diversified'
+    AllowedValues:
+      - 'lowestPrice'
+      - 'diversified'
+  UserData:
+    Type: String
+  IsWindows:
+    Type: String
+    Default: 'false'
+  ConfigureRootVolume:
+    Type: String
+    Description: Optional - Specifies if there should be customization of the root volume
+    Default: 'false'
+  ConfigureDataVolume:
+    Type: String
+    Description: Optional - Specifies if there should be customization of the data volume
+    Default: 'true'
+  AutoAssignPublicIp:
+    Type: String
+    Default: 'INHERIT'
+Conditions:
+  CreateEC2LCWithKeyPair:
+    !Not [!Equals [!Ref KeyName, '']]
+  SetEndpointToECSAgent:
+    !Not [!Equals [!Ref EcsEndpoint, '']]
+  CreateNewSecurityGroup:
+    !Equals [!Ref SecurityGroupId, '']
+  CreateNewVpc:
+    !Equals [!Ref VpcId, '']
+  CreateSubnet1: !And
+    - !Not [!Equals [!Ref SubnetCidr1, '']]
+    - !Condition CreateNewVpc
+  CreateSubnet2: !And
+    - !Not [!Equals [!Ref SubnetCidr2, '']]
+    - !Condition CreateSubnet1
+  CreateSubnet3: !And
+    - !Not [!Equals [!Ref SubnetCidr3, '']]
+    - !Condition CreateSubnet2
+  CreateWithSpot: !Equals [!Ref UseSpot, 'true']
+  CreateWithASG: !Not [!Condition CreateWithSpot]
+  CreateWithSpotPrice: !Not [!Equals [!Ref SpotPrice, '']]
+  IsConfiguringRootVolume: !Equals [!Ref ConfigureRootVolume, 'true']
+  IsConfiguringDataVolume: !Equals [!Ref ConfigureDataVolume, 'true']
+  IsInheritPublicIp: !Equals [!Ref AutoAssignPublicIp, 'INHERIT']
+Resources:
+  Vpc:
+    Condition: CreateSubnet1
+    Type: AWS::EC2::VPC
+    Properties:
+      CidrBlock: !Ref VpcCidr
+      EnableDnsSupport: true
+      EnableDnsHostnames: true
+  PubSubnetAz1:
+    Condition: CreateSubnet1
+    Type: AWS::EC2::Subnet
+    Properties:
+      VpcId: !Ref Vpc
+      CidrBlock: !Ref SubnetCidr1
+      AvailabilityZone: !Select [ 0, !Ref VpcAvailabilityZones ]
+      MapPublicIpOnLaunch: true
+  PubSubnetAz2:
+    Condition: CreateSubnet2
+    Type: AWS::EC2::Subnet
+    Properties:
+      VpcId: !Ref Vpc
+      CidrBlock: !Ref SubnetCidr2
+      AvailabilityZone: !Select [ 1, !Ref VpcAvailabilityZones ]
+      MapPublicIpOnLaunch: true
+  PubSubnetAz3:
+    Condition: CreateSubnet3
+    Type: AWS::EC2::Subnet
+    Properties:
+      VpcId: !Ref Vpc
+      CidrBlock: !Ref SubnetCidr3
+      AvailabilityZone: !Select [ 2, !Ref VpcAvailabilityZones ]
+      MapPublicIpOnLaunch: true
+  InternetGateway:
+    Condition: CreateSubnet1
+    Type: AWS::EC2::InternetGateway
+  AttachGateway:
+    Condition: CreateSubnet1
+    Type: AWS::EC2::VPCGatewayAttachment
+    Properties:
+      VpcId: !Ref Vpc
+      InternetGatewayId: !Ref InternetGateway
+  RouteViaIgw:
+    Condition: CreateSubnet1
+    Type: AWS::EC2::RouteTable
+    Properties:
+      VpcId: !Ref Vpc
+  PublicRouteViaIgw:
+    Condition: CreateSubnet1
+    Type: AWS::EC2::Route
+    DependsOn: AttachGateway
+    Properties:
+      RouteTableId: !Ref RouteViaIgw
+      DestinationCidrBlock: 0.0.0.0/0
+      GatewayId: !Ref InternetGateway
+  PubSubnet1RouteTableAssociation:
+    Condition: CreateSubnet1
+    Type: AWS::EC2::SubnetRouteTableAssociation
+    Properties:
+      SubnetId: !Ref PubSubnetAz1
+      RouteTableId: !Ref RouteViaIgw
+  PubSubnet2RouteTableAssociation:
+    Condition: CreateSubnet2
+    Type: AWS::EC2::SubnetRouteTableAssociation
+    Properties:
+      SubnetId: !Ref PubSubnetAz2
+      RouteTableId: !Ref RouteViaIgw
+  PubSubnet3RouteTableAssociation:
+    Condition: CreateSubnet3
+    Type: AWS::EC2::SubnetRouteTableAssociation
+    Properties:
+      SubnetId: !Ref PubSubnetAz3
+      RouteTableId: !Ref RouteViaIgw
+  EcsSecurityGroup:
+    Condition: CreateNewSecurityGroup
+    Type: AWS::EC2::SecurityGroup
+    Properties:
+      GroupDescription: ECS Allowed Ports
+      VpcId: !If [ CreateSubnet1, !Ref Vpc, !Ref VpcId ]
+      SecurityGroupIngress:
+        IpProtocol: tcp
+        FromPort: !Ref SecurityIngressFromPort
+        ToPort: !Ref SecurityIngressToPort
+        CidrIp: !Ref SecurityIngressCidrIp
+
+
+  ## TODO: FINISH
+  # ALBSecurityGroup:
+  #   Condition: CreateNewLoadBalancer
+  #   Type: AWS::EC2::SecurityGroup
+  #   Properties:
+  #     GroupDescription: ECS Allowed Ports
+  #     VpcId: !If [ CreateSubnet1, !Ref Vpc, !Ref VpcId ]
+  #     SecurityGroupIngress:
+  #       IpProtocol: tcp
+  #       FromPort: !Ref SecurityIngressFromPort
+  #       ToPort: !Ref SecurityIngressToPort
+  #       CidrIp: !Ref SecurityIngressCidrIp
+
+  # EcsLoadBalancer:
+  #   Condition: CreateNewLoadBalancer
+  #   Type: AWS::ElasticLoadBalancing::LoadBalancer
+  #   Properties:
+  #     LoadBalancerName: !Ref LoadBalancer
+  #     AvailabilityZones:
+  #       - !Select [ 0, !Ref VpcAvailabilityZones ]
+  #       - !Select [ 1, !Ref VpcAvailabilityZones ]
+  #       - !Select [ 2, !Ref VpcAvailabilityZones ]
+  #     SecurityGroups:
+  #       - !Select [ 0, !Ref VpcAvailabilityZones ]
+  #     Subnets:
+  #       -
+  ## /TODO: FINISH
+
+  EcsInstanceLc:
+    Type: AWS::AutoScaling::LaunchConfiguration
+    Condition: CreateWithASG
+    Properties:
+      ImageId: !Ref EcsAmiId
+      InstanceType: !Select [ 0, !Ref EcsInstanceType ]
+      AssociatePublicIpAddress: !If [ IsInheritPublicIp, !Ref "AWS::NoValue", !Ref AutoAssignPublicIp ]
+      IamInstanceProfile: !Ref IamRoleInstanceProfile
+      KeyName: !If [ CreateEC2LCWithKeyPair, !Ref KeyName, !Ref "AWS::NoValue" ]
+      SecurityGroups: [ !If [ CreateNewSecurityGroup, !Ref EcsSecurityGroup, !Ref SecurityGroupId ] ]
+      BlockDeviceMappings:
+        - !If
+          - IsConfiguringRootVolume
+          - DeviceName: !Ref RootDeviceName
+            Ebs:
+              VolumeSize: !Ref RootEbsVolumeSize
+              VolumeType: !Ref EbsVolumeType
+          - !Ref AWS::NoValue
+        - !If
+          - IsConfiguringDataVolume
+          - DeviceName: !Ref DeviceName
+            Ebs:
+              VolumeSize: !Ref EbsVolumeSize
+              VolumeType: !Ref EbsVolumeType
+          - !Ref AWS::NoValue
+      UserData:
+        Fn::Base64: !Ref UserData
+  EcsInstanceAsg:
+    Type: AWS::AutoScaling::AutoScalingGroup
+    Condition: CreateWithASG
+    Properties:
+      VPCZoneIdentifier: !If
+        - CreateSubnet1
+        - !If
+          - CreateSubnet2
+          - !If
+            - CreateSubnet3
+            - [ !Sub "${PubSubnetAz1}, ${PubSubnetAz2}, ${PubSubnetAz3}" ]
+            - [ !Sub "${PubSubnetAz1}, ${PubSubnetAz2}" ]
+          - [ !Sub "${PubSubnetAz1}" ]
+        - !Ref SubnetIds
+      LaunchConfigurationName: !Ref EcsInstanceLc
+      MinSize: '0'
+      MaxSize: !Ref AsgMaxSize
+      DesiredCapacity: !Ref AsgMaxSize
+      Tags:
+        -
+          Key: Name
+          Value: !Sub "ECS Instance - ${AWS::StackName}"
+          PropagateAtLaunch: true
+        -
+          Key: Description
+          Value: "This instance is the part of the Auto Scaling group which was created through ECS Console"
+          PropagateAtLaunch: true
+  EcsSpotFleet:
+    Condition: CreateWithSpot
+    Type: AWS::EC2::SpotFleet
+    Properties:
+      SpotFleetRequestConfigData:
+        AllocationStrategy: !Ref SpotAllocationStrategy
+        IamFleetRole: !Ref IamSpotFleetRoleArn
+        TargetCapacity: !Ref AsgMaxSize
+        SpotPrice: !If [ CreateWithSpotPrice, !Ref SpotPrice, !Ref 'AWS::NoValue' ]
+        TerminateInstancesWithExpiration: true
+        LaunchSpecifications:
+            -
+              IamInstanceProfile:
+                Arn: !Ref IamRoleInstanceProfile
+              ImageId: !Ref EcsAmiId
+              InstanceType: !Select [ 0, !Ref EcsInstanceType ]
+              KeyName: !If [ CreateEC2LCWithKeyPair, !Ref KeyName, !Ref "AWS::NoValue" ]
+              Monitoring:
+                Enabled: true
+              SecurityGroups:
+                - GroupId: !If [ CreateNewSecurityGroup, !Ref EcsSecurityGroup, !Ref SecurityGroupId ]
+              SubnetId: !If
+                      - CreateSubnet1
+                      - !If
+                        - CreateSubnet2
+                        - !If
+                          - CreateSubnet3
+                          - !Join [ "," , [ !Ref PubSubnetAz1, !Ref PubSubnetAz2, !Ref PubSubnetAz3 ] ]
+                          - !Join [ "," , [ !Ref PubSubnetAz1, !Ref PubSubnetAz2 ] ]
+                        - !Ref PubSubnetAz1
+                      - !Join [ "," , !Ref SubnetIds ]
+              BlockDeviceMappings:
+                    - DeviceName: !Ref DeviceName
+                      Ebs:
+                       VolumeSize: !Ref EbsVolumeSize
+                       VolumeType: !Ref EbsVolumeType
+              UserData:
+                    Fn::Base64: !Ref UserData
+Outputs:
+  EcsInstanceAsgName:
+    Condition: CreateWithASG
+    Description: Auto Scaling Group Name for ECS Instances
+    Value: !Ref EcsInstanceAsg
+  EcsSpotFleetRequestId:
+      Condition: CreateWithSpot
+      Description: Spot Fleet Request for ECS Instances
+      Value: !Ref EcsSpotFleet
+  UsedByECSCreateCluster:
+    Description: Flag used by ECS Create Cluster Wizard
+    Value: 'true'
+  TemplateVersion:
+    Description: The version of the template used by Create Cluster Wizard
+    Value: '2.0.0'

data/lib/ecs_deploy_cli/dsl/cluster.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module DSL
+    class Cluster
+      include AutoOptions
+
+      allowed_options :instances_count, :instance_type, :ebs_volume_size, :keypair_name
+
+      def initialize(name, config)
+        @config = config
+        _options[:name] = name.to_s
+      end
+
+      def vpc(id = nil, &block)
+        @vpc = VPC.new(id)
+        @vpc.instance_exec(&block)
+      end
+
+      def as_definition
+        {
+          instances_count: 1,
+
+          device_name: '/dev/xvda',
+          ebs_volume_size: 22,
+          ebs_volume_type: 'gp2',
+
+          root_device_name: '/dev/xvdcz',
+          root_ebs_volume_size: 30,
+
+          vpc: @vpc&.as_definition
+        }.merge(_options)
+      end
+
+      class VPC
+        include AutoOptions
+        allowed_options :cidr, :subnet1, :subnet2, :subnet3
+
+        def initialize(id)
+          _options[:id] = id
+        end
+
+        def availability_zones(*values)
+          _options[:availability_zones] = values.join(',')
+        end
+
+        def subnet_ids(*values)
+          _options[:subnet_ids] = values.join(',')
+        end
+
+        def as_definition
+          validate! if _options[:id]
+
+          {
+            cidr: '10.0.0.0/16',
+            subnet1: '10.0.0.0/24',
+            subnet2: '10.0.1.0/24',
+            subnet3: '10.0.2.0/24'
+          }.merge(_options)
+        end
+
+        def validate!
+          [
+            :subnet1, :subnet_ids, :availability_zones
+          ].each { |key| raise "Missing required parameter #{key}" unless _options[key] }
+        end
+      end
+    end
+  end
+end

data/lib/ecs_deploy_cli/dsl/parser.rb

@@ -40,8 +40,11 @@ module EcsDeployCli
         @crons[name].instance_exec(&block)
       end
 
-      def cluster(name)
+      def cluster(name, &block)
         config[:cluster] = name
+        @cluster ||= {}.with_indifferent_access
+        @cluster = Cluster.new(name, config)
+        @cluster.instance_exec(&block) if block
       end
 
       def config
@@ -58,7 +61,8 @@ module EcsDeployCli
         resolved_containers = (@containers || {}).transform_values(&:as_definition)
         resolved_tasks = (@tasks || {}).transform_values { |t| t.as_definition(resolved_containers) }
         resolved_crons = (@crons || {}).transform_values { |t| t.as_definition(resolved_tasks) }
-        [@services, resolved_tasks, resolved_crons]
+        resolved_cluster = @cluster.as_definition
+        [@services, resolved_tasks, resolved_crons, resolved_cluster]
       end
 
       def self.load(file)

data/lib/ecs_deploy_cli/dsl/service.rb

@@ -18,13 +18,42 @@ module EcsDeployCli
         _options
       end
 
+      def load_balancer(name, &block)
+        @load_balancers ||= []
+
+        load_balancer = LoadBalancer.new(name, @config)
+        load_balancer.instance_exec(&block)
+
+        @load_balancers << load_balancer
+      end
+
       def as_definition(task)
         {
           cluster: @config[:cluster],
-          service: service_name,
-          task_definition: task
+          service: _options[:service],
+          task_definition: task,
+          load_balancers: @load_balancers&.map(&:as_definition) || []
         }
       end
+
+      class LoadBalancer
+        include AutoOptions
+        allowed_options :container_name, :container_port
+
+        def initialize(name, config)
+          _options[:load_balancer_name] = name
+          @config = config
+        end
+
+        def target_group_arn(value)
+          _options[:target_group_arn] = "arn:aws:elasticloadbalancing:#{@config[:aws_region]}:#{@config[:aws_profile_id]}:targetgroup/#{value}"
+          _options.delete(:load_balancer_name)
+        end
+
+        def as_definition
+          _options
+        end
+      end
     end
   end
 end

data/lib/ecs_deploy_cli/runner.rb

@@ -7,6 +7,7 @@ require 'ecs_deploy_cli/runners/diff'
 require 'ecs_deploy_cli/runners/update_crons'
 require 'ecs_deploy_cli/runners/update_services'
 require 'ecs_deploy_cli/runners/run_task'
+require 'ecs_deploy_cli/runners/setup'
 
 module EcsDeployCli
   class Runner
@@ -14,6 +15,10 @@ module EcsDeployCli
       @parser = parser
     end
 
+    def setup!
+      EcsDeployCli::Runners::Setup.new(@parser).run!
+    end
+
     def validate!
       EcsDeployCli::Runners::Validate.new(@parser).run!
     end

data/lib/ecs_deploy_cli/runners/base.rb

@@ -11,14 +11,35 @@ module EcsDeployCli
         raise NotImplementedError, 'abstract method'
       end
 
+      def update_task(definition)
+        _update_task(definition)
+      end
+
       protected
 
       def _update_task(definition)
+        definition[:container_definitions].each do |container|
+          next unless container.dig(:log_configuration, :log_driver) == 'awslogs'
+
+          _create_cloudwatch_logs_if_needed(container.dig(:log_configuration, :options, 'awslogs-group'))
+        end
+
         ecs_client.register_task_definition(
           definition
         ).to_h[:task_definition]
       end
 
+      def _create_cloudwatch_logs_if_needed(prefix)
+        log_group = cwl_client.describe_log_groups(log_group_name_prefix: prefix, limit: 1).to_h[:log_groups]
+        return if log_group.any?
+
+        cwl_client.create_log_group(log_group_name: prefix)
+        cwl_client.put_retention_policy(
+          log_group_name: prefix,
+          retention_in_days: 14
+        )
+      end
+
       def ec2_client
         @ec2_client ||= begin
           require 'aws-sdk-ec2'
@@ -46,6 +67,36 @@ module EcsDeployCli
         end
       end
 
+      def ssm_client
+        @cwl_client ||= begin
+          require 'aws-sdk-ssm'
+          Aws::SSM::Client.new(
+            profile: ENV.fetch('AWS_PROFILE', 'default'),
+            region: config[:aws_region]
+          )
+        end
+      end
+
+      def cwl_client
+        @cwl_client ||= begin
+          require 'aws-sdk-cloudwatchlogs'
+          Aws::CloudWatchLogs::Client.new(
+            profile: ENV.fetch('AWS_PROFILE', 'default'),
+            region: config[:aws_region]
+          )
+        end
+      end
+
+      def cf_client
+        @cl_client ||= begin
+          require 'aws-sdk-cloudformation'
+          Aws::CloudFormation::Client.new(
+            profile: ENV.fetch('AWS_PROFILE', 'default'),
+            region: config[:aws_region]
+          )
+        end
+      end
+
       def config
         @parser.config
       end

data/lib/ecs_deploy_cli/runners/setup.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module Runners
+    class Setup < Base
+      def run!
+        services, resolved_tasks, _, cluster_options = @parser.resolve
+
+        setup_cluster! cluster_options
+        setup_services! services, resolved_tasks: resolved_tasks
+      end
+
+      private
+
+      def setup_cluster!(cluster_options)
+        clusters = ecs_client.describe_clusters(clusters: [config[:cluster]]).to_h[:clusters]
+        if clusters.length == 1
+          EcsDeployCli.logger.info 'Cluster already created, skipping.'
+          return
+        end
+
+        EcsDeployCli.logger.info "Creating cluster #{config[:cluster]}..."
+
+        params = create_params(cluster_options)
+
+        ecs_client.create_cluster(
+          cluster_name: config[:cluster]
+        )
+
+        stack_name = "EC2ContainerService-#{config[:cluster]}"
+
+
+        cf_client.create_stack(
+          stack_name: stack_name,
+          template_body: File.read(File.join(__dir__, '..', 'cloudformation', 'default.yml')),
+          on_failure: 'ROLLBACK',
+          parameters: format_cloudformation_params(params)
+        )
+
+        cf_client.wait_until(:stack_create_complete, { stack_name: stack_name }, delay: 30, max_attempts: 120)
+        EcsDeployCli.logger.info "Cluster #{config[:cluster]} created!"
+      end
+
+      def setup_services!(services, resolved_tasks:)
+        services.each do |service_name, service_definition|
+          if ecs_client.describe_services(cluster: config[:cluster], services: [service_name]).to_h[:services].any?
+            EcsDeployCli.logger.info "Service #{service_name} already created, skipping."
+            next
+          end
+
+          EcsDeployCli.logger.info "Creating service #{service_name}..."
+          task_definition = _update_task resolved_tasks[service_definition.options[:task]]
+          task_name = "#{task_definition[:family]}:#{task_definition[:revision]}"
+
+          ecs_client.create_service(
+            cluster: config[:cluster],
+            desired_count: 1,
+            load_balancers: service_definition.as_definition(task_definition)[:load_balancers],
+            service_name: service_name,
+            task_definition: task_name
+          )
+          EcsDeployCli.logger.info "Service #{service_name} created!"
+        end
+      end
+
+      def create_params(cluster_options)
+        raise ArgumentError, 'Missing vpc configuration' unless cluster_options[:vpc]
+
+        {
+          'AsgMaxSize' => cluster_options[:instances_count],
+          'AutoAssignPublicIp' => 'INHERIT',
+          'ConfigureDataVolume' => false,
+          'ConfigureRootVolume' => true,
+          'DeviceName' => cluster_options[:device_name],
+          'EbsVolumeSize' => cluster_options[:ebs_volume_size],
+          'EbsVolumeType' => cluster_options[:ebs_volume_type],
+          'EcsAmiId' => load_ami_id,
+          'EcsClusterName' => config[:cluster],
+          'EcsEndpoint' => nil,
+          'EcsInstanceType' => cluster_options[:instance_type],
+          'IamRoleInstanceProfile' => "arn:aws:iam::#{config[:aws_profile_id]}:instance-profile/ecsInstanceRole",
+          'IamSpotFleetRoleArn' => nil,
+          'IsWindows' => false,
+          'KeyName' => cluster_options[:keypair_name],
+          'RootDeviceName' => cluster_options[:root_device_name],
+          'RootEbsVolumeSize' => cluster_options[:root_ebs_volume_size],
+
+          ##### TODO: Implement this feature
+          'SecurityGroupId' => nil,
+          'SecurityIngressCidrIp' => '0.0.0.0/0',
+          'SecurityIngressFromPort' => 80,
+          'SecurityIngressToPort' =>	80,
+          #####
+
+          ##### TODO: Implement this feature
+          'SpotAllocationStrategy' =>	'diversified',
+          'SpotPrice' => nil,
+          'UseSpot' =>	false,
+          #####
+
+          'UserData' => "#!/bin/bash\necho ECS_CLUSTER=#{config[:cluster]} >> /etc/ecs/ecs.config;echo ECS_BACKEND_HOST= >> /etc/ecs/ecs.config;",
+          'VpcAvailabilityZones' => cluster_options.dig(:vpc, :availability_zones),
+          'VpcCidr' => cluster_options.dig(:vpc, :cidr),
+          'SubnetCidr1' => cluster_options.dig(:vpc, :subnet1),
+          'SubnetCidr2' => cluster_options.dig(:vpc, :subnet2),
+          'SubnetCidr3' => cluster_options.dig(:vpc, :subnet3),
+
+          'VpcId' => cluster_options.dig(:vpc, :id),
+          'SubnetIds' => cluster_options.dig(:vpc, :subnet_ids)
+        }
+      end
+
+      def format_cloudformation_params(params)
+        params.map { |k, v| { parameter_key: k, parameter_value: v.to_s } }
+      end
+
+      def load_ami_id
+        ami_data = ssm_client.get_parameter(
+          name: '/aws/service/ecs/optimized-ami/amazon-linux-2/recommended'
+        ).to_h[:parameter]
+
+        ami_details = JSON.parse(ami_data[:value]).with_indifferent_access
+
+        ami_details[:image_id]
+      end
+    end
+  end
+end

data/lib/ecs_deploy_cli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EcsDeployCli
-  VERSION = '0.2.2'
+  VERSION = '0.3.0'
 end

data/spec/ecs_deploy_cli/cli_spec.rb

@@ -48,6 +48,14 @@ describe EcsDeployCli::CLI do
       described_class.start(['run-task', 'yourproject', '--subnets', 'subnet-123123', '--file', 'spec/support/ECSFile'])
     end
 
+    it 'runs setup' do
+      expect(runner).to receive(:setup!)
+      described_class.no_commands do
+        expect_any_instance_of(described_class).to receive(:runner).at_least(:once).and_return(runner)
+      end
+      expect { described_class.start(['setup', '--file', 'spec/support/ECSFile']) }.to output(/[WARNING]/).to_stdout
+    end
+
     it 'runs deploy' do
       expect(runner).to receive(:update_crons!)
       expect(runner).to receive(:update_services!).with(timeout: 500)

data/spec/ecs_deploy_cli/dsl/cluster_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe EcsDeployCli::DSL::Cluster do
+  context 'defines cluster data' do
+    subject { described_class.new('mydata-cluster', { aws_profile_id: '123123', aws_region: 'eu-central-1' }) }
+
+    it '#vpc' do
+      subject.instances_count 1
+      subject.instance_type 't2.small'
+      subject.keypair_name 'test'
+
+      subject.vpc do
+        cidr '11.0.0.0/16'
+        subnet1 '11.0.0.0/24'
+        subnet2 '11.0.1.0/24'
+        subnet3 '11.0.2.0/24'
+        subnet_ids 'subnet-123', 'subnet-321', 'subnet-333'
+
+        availability_zones 'eu-central-1a', 'eu-central-1b', 'eu-central-1c'
+      end
+
+      expect(subject.as_definition).to eq(
+        {
+          device_name: '/dev/xvda',
+          ebs_volume_size: 22,
+          ebs_volume_type: 'gp2',
+          instances_count: 1,
+          instance_type: 't2.small',
+          keypair_name: 'test',
+          name: 'mydata-cluster',
+          root_device_name: '/dev/xvdcz',
+          root_ebs_volume_size: 30,
+          vpc: {
+            availability_zones: 'eu-central-1a,eu-central-1b,eu-central-1c',
+            cidr: '11.0.0.0/16',
+            id: nil,
+            subnet1: '11.0.0.0/24',
+            subnet2: '11.0.1.0/24',
+            subnet3: '11.0.2.0/24',
+            subnet_ids: 'subnet-123,subnet-321,subnet-333'
+          }
+        }
+      )
+    end
+  end
+end

data/spec/ecs_deploy_cli/dsl/service_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe EcsDeployCli::DSL::Service do
+  context 'defines service data' do
+    subject { described_class.new('test', { aws_profile_id: '123123', aws_region: 'eu-central-1' }) }
+
+    it 'has the correct name' do
+      expect(subject.as_definition({})[:service]).to eq('test')
+    end
+
+    it '#load_balancer' do
+      subject.load_balancer :'yourproject-load-balancer' do
+        target_group_arn 'loader-target-group/123abc'
+        container_name :web
+        container_port 80
+      end
+
+      expect(subject.as_definition({})[:load_balancers]).to eq(
+        [
+          {
+            container_name: :web,
+            container_port: 80,
+            target_group_arn: 'arn:aws:elasticloadbalancing:eu-central-1:123123:targetgroup/loader-target-group/123abc'
+          }
+        ]
+      )
+    end
+  end
+end

data/spec/ecs_deploy_cli/runner_spec.rb

@@ -2,14 +2,20 @@
 
 require 'spec_helper'
 require 'aws-sdk-cloudwatchevents'
+require 'aws-sdk-cloudwatchlogs'
 require 'aws-sdk-ec2'
+require 'aws-sdk-ssm'
+require 'aws-sdk-cloudformation'
 
 describe EcsDeployCli::Runner do
   context 'defines task data' do
     let(:parser) { EcsDeployCli::DSL::Parser.load('spec/support/ECSFile') }
     subject { described_class.new(parser) }
+    let(:mock_cf_client) { Aws::CloudFormation::Client.new(stub_responses: true) }
+    let(:mock_ssm_client) { Aws::SSM::Client.new(stub_responses: true) }
     let(:mock_ecs_client) { Aws::ECS::Client.new(stub_responses: true) }
     let(:mock_ec2_client) { Aws::EC2::Client.new(stub_responses: true) }
+    let(:mock_cwl_client) { Aws::CloudWatchLogs::Client.new(stub_responses: true) }
     let(:mock_cwe_client) do
       Aws::CloudWatchEvents::Client.new(stub_responses: true)
     end
@@ -84,6 +90,26 @@ describe EcsDeployCli::Runner do
         ENV['AWS_REGION'] = nil
       end
 
+      it '#setup!' do
+        mock_ssm_client.stub_responses(:get_parameter, {
+                                         parameter: {
+                                           name: '/aws/service/ecs/optimized-ami/amazon-linux-2/recommended',
+                                           type: 'String',
+                                           value: '{"schema_version":1,"image_name":"amzn2-ami-ecs-hvm-2.0.20210331-x86_64-ebs","image_id":"ami-03bbf53329af34379","os":"Amazon Linux 2","ecs_runtime_version":"Docker version 19.03.13-ce","ecs_agent_version":"1.51.0"}'
+                                         }
+                                       })
+
+        expect(mock_cf_client).to receive(:wait_until)
+        expect(mock_ecs_client).to receive(:create_service)
+
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:cwl_client).at_least(:once).and_return(mock_cwl_client)
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ssm_client).at_least(:once).and_return(mock_ssm_client)
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:cf_client).at_least(:once).and_return(mock_cf_client)
+
+        subject.setup!
+      end
+
       it '#ssh' do
         expect(mock_ecs_client).to receive(:list_container_instances).and_return({ container_instance_arns: ['arn:123123'] })
         expect(mock_ecs_client).to receive(:describe_container_instances).and_return(double(container_instances: [double(ec2_instance_id: 'i-123123')]))
@@ -124,6 +150,7 @@ describe EcsDeployCli::Runner do
 
         mock_cwe_client.stub_responses(:run_task)
 
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:cwl_client).at_least(:once).and_return(mock_cwl_client)
         expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
 
         subject.run_task!('yourproject-cron', launch_type: 'FARGATE', security_groups: [], subnets: [])
@@ -134,6 +161,7 @@ describe EcsDeployCli::Runner do
 
         mock_cwe_client.stub_responses(:list_targets_by_rule, { targets: [{ id: '123', arn: 'arn:123' }] })
 
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:cwl_client).at_least(:once).and_return(mock_cwl_client)
         expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
         expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:cwe_client).at_least(:once).and_return(mock_cwe_client)
 
@@ -149,6 +177,7 @@ describe EcsDeployCli::Runner do
         )
         expect(mock_ecs_client).to receive(:wait_until)
 
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:cwl_client).at_least(:once).and_return(mock_cwl_client)
         expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
 
         subject.update_services!

data/spec/ecs_deploy_cli/runners/base_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'aws-sdk-cloudwatchevents'
+require 'aws-sdk-cloudwatchlogs'
+require 'aws-sdk-ec2'
+require 'aws-sdk-ssm'
+require 'aws-sdk-cloudformation'
+
+describe EcsDeployCli::Runners::Base do
+  let(:parser) { EcsDeployCli::DSL::Parser.load('spec/support/ECSFile') }
+  subject { described_class.new(parser) }
+  let(:mock_cf_client) { Aws::CloudFormation::Client.new(stub_responses: true) }
+  let(:mock_ssm_client) { Aws::SSM::Client.new(stub_responses: true) }
+  let(:mock_ecs_client) { Aws::ECS::Client.new(stub_responses: true) }
+  let(:mock_ec2_client) { Aws::EC2::Client.new(stub_responses: true) }
+  let(:mock_cwl_client) { Aws::CloudWatchLogs::Client.new(stub_responses: true) }
+  let(:mock_cwe_client) do
+    Aws::CloudWatchEvents::Client.new(stub_responses: true)
+  end
+
+  around(:each) do |example|
+    ENV['AWS_PROFILE_ID'] = '123123123'
+    ENV['AWS_REGION'] = 'us-east-1'
+    example.run
+    ENV['AWS_PROFILE_ID'] = nil
+    ENV['AWS_REGION'] = nil
+  end
+
+  context '#update_task' do
+    it 'creates cloud watch logs if missing' do
+      _, tasks, = parser.resolve
+
+      expect(mock_cwl_client).to receive(:describe_log_groups).at_least(:once).and_return({ log_groups: [] })
+      expect(mock_cwl_client).to receive(:create_log_group).at_least(:once)
+      expect(mock_ecs_client).to receive(:register_task_definition).at_least(:once).and_return({ task_definition: { family: 'some', revision: '1' } })
+
+      expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:cwl_client).at_least(:once).and_return(mock_cwl_client)
+      expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
+
+      subject.update_task(tasks.values.first)
+    end
+
+    it 'creates no cloudwatch log group if is already there' do
+      _, tasks, = parser.resolve
+
+      expect(mock_cwl_client).to receive(:describe_log_groups).at_least(:once).and_return({ log_groups: [{}] })
+      expect(mock_cwl_client).not_to receive(:create_log_group)
+      expect(mock_ecs_client).to receive(:register_task_definition).at_least(:once).and_return({ task_definition: { family: 'some', revision: '1' } })
+
+      expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:cwl_client).at_least(:once).and_return(mock_cwl_client)
+      expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
+
+      subject.update_task(tasks.values.first)
+    end
+  end
+end

data/spec/support/ECSFile

@@ -4,7 +4,14 @@ aws_region ENV.fetch('AWS_REGION', 'eu-central-1')
 aws_profile_id ENV['AWS_PROFILE_ID']
 
 # Defining the cluster name
-cluster 'yourproject-cluster'
+cluster 'yourproject-cluster' do
+  instance_type 't3.small'
+  keypair_name 'test'
+
+  vpc do
+    availability_zones 'eu-central-1a', 'eu-central-1b', 'eu-central-1c'
+  end
+end
 
 # This is used as a template for the next two containers, it will not be used inside a task
 container :base_container do
@@ -49,6 +56,11 @@ end
 # The main service
 service :'yourproject-service' do
   task :yourproject
+  load_balancer :'yourproject-load-balancer' do
+    target_group_arn 'loader-target-group/123abc'
+    container_name :web
+    container_port 80
+  end
 end
 
 # A task for cron jobs

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification
 name: ecs_deploy_cli
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Mònade
 - ProGM
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
 date: 2021-03-31 00:00:00.000000000 Z
@@ -31,6 +31,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '7'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-cloudformation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: aws-sdk-cloudwatchevents
   requirement: !ruby/object:Gem::Requirement
@@ -45,6 +59,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-cloudwatchlogs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: aws-sdk-ec2
   requirement: !ruby/object:Gem::Requirement
@@ -73,6 +101,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-ssm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: colorize
   requirement: !ruby/object:Gem::Requirement
@@ -155,7 +197,9 @@ files:
 - lib/ecs-deploy-cli.rb
 - lib/ecs_deploy_cli.rb
 - lib/ecs_deploy_cli/cli.rb
+- lib/ecs_deploy_cli/cloudformation/default.yml
 - lib/ecs_deploy_cli/dsl/auto_options.rb
+- lib/ecs_deploy_cli/dsl/cluster.rb
 - lib/ecs_deploy_cli/dsl/container.rb
 - lib/ecs_deploy_cli/dsl/cron.rb
 - lib/ecs_deploy_cli/dsl/parser.rb
@@ -166,6 +210,7 @@ files:
 - lib/ecs_deploy_cli/runners/diff.rb
 - lib/ecs_deploy_cli/runners/logs.rb
 - lib/ecs_deploy_cli/runners/run_task.rb
+- lib/ecs_deploy_cli/runners/setup.rb
 - lib/ecs_deploy_cli/runners/ssh.rb
 - lib/ecs_deploy_cli/runners/status.rb
 - lib/ecs_deploy_cli/runners/update_crons.rb
@@ -173,11 +218,14 @@ files:
 - lib/ecs_deploy_cli/runners/validate.rb
 - lib/ecs_deploy_cli/version.rb
 - spec/ecs_deploy_cli/cli_spec.rb
+- spec/ecs_deploy_cli/dsl/cluster_spec.rb
 - spec/ecs_deploy_cli/dsl/container_spec.rb
 - spec/ecs_deploy_cli/dsl/cron_spec.rb
 - spec/ecs_deploy_cli/dsl/parser_spec.rb
+- spec/ecs_deploy_cli/dsl/service_spec.rb
 - spec/ecs_deploy_cli/dsl/task_spec.rb
 - spec/ecs_deploy_cli/runner_spec.rb
+- spec/ecs_deploy_cli/runners/base_spec.rb
 - spec/spec_helper.rb
 - spec/support/ECSFile
 - spec/support/ECSFile.minimal
@@ -188,7 +236,7 @@ licenses:
 - MIT
 metadata:
   source_code_uri: https://github.com/monade/ecs-deploy-cli
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -203,19 +251,22 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.6
-signing_key: 
+rubygems_version: 3.2.8
+signing_key:
 specification_version: 4
 summary: A command line interface to make ECS deployments easier
 test_files:
+- spec/ecs_deploy_cli/cli_spec.rb
+- spec/ecs_deploy_cli/dsl/cluster_spec.rb
+- spec/ecs_deploy_cli/dsl/container_spec.rb
+- spec/ecs_deploy_cli/dsl/cron_spec.rb
+- spec/ecs_deploy_cli/dsl/parser_spec.rb
+- spec/ecs_deploy_cli/dsl/service_spec.rb
+- spec/ecs_deploy_cli/dsl/task_spec.rb
+- spec/ecs_deploy_cli/runner_spec.rb
+- spec/ecs_deploy_cli/runners/base_spec.rb
 - spec/spec_helper.rb
 - spec/support/ECSFile
 - spec/support/ECSFile.minimal
-- spec/support/env_file.yml
 - spec/support/env_file.ext.yml
-- spec/ecs_deploy_cli/runner_spec.rb
-- spec/ecs_deploy_cli/cli_spec.rb
-- spec/ecs_deploy_cli/dsl/task_spec.rb
-- spec/ecs_deploy_cli/dsl/parser_spec.rb
-- spec/ecs_deploy_cli/dsl/cron_spec.rb
-- spec/ecs_deploy_cli/dsl/container_spec.rb
+- spec/support/env_file.yml