ecs_deploy_cli 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e5f34210100053703e0137631635b625ea37cc1cb140e4fa432c3375c6cdf87a
+  data.tar.gz: '08d8ead32a4b87cddb19b36539d661fc954e006a8ac3986a8dc60aaac93cd560'
+SHA512:
+  metadata.gz: 90cb49d9d8de03d5b82946493d2df2466dec05cd01c190e9673ed6023adf9b5167465032bc47076ac12f7f8bfc451fd78c8568aec3aede6fd82467b7369914ad
+  data.tar.gz: f3dedd74c575d671fc65afb974086d8683c4eb3ee38074aec7d1dacb0b31632dd52813127bb39f1b3df95167353a8871308da8fbd885fd57cbb7f3ef34ca9941

data/bin/ecs-deploy

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'ecs_deploy_cli'
+
+EcsDeployCli::CLI.start(ARGV)

data/lib/ecs-deploy-cli.rb

@@ -0,0 +1 @@
+require 'ecs_deploy_cli'

data/lib/ecs_deploy_cli.rb

@@ -0,0 +1,32 @@
+require 'yaml'
+require 'logger'
+require 'thor'
+require 'aws-sdk-ecs'
+require 'active_support/core_ext/hash/indifferent_access'
+
+module EcsDeployCli
+  def self.logger
+    @logger ||= begin
+      logger = Logger.new(STDOUT)
+      logger.formatter = proc { |severity, datetime, progname, msg|
+        "#{msg}\n"
+      }
+      logger.level = Logger::INFO
+      logger
+    end
+  end
+
+  def self.logger=(value)
+    @logger = value
+  end
+end
+
+require 'ecs_deploy_cli/version'
+require 'ecs_deploy_cli/dsl/auto_options'
+require 'ecs_deploy_cli/dsl/container'
+require 'ecs_deploy_cli/dsl/task'
+require 'ecs_deploy_cli/dsl/cron'
+require 'ecs_deploy_cli/dsl/service'
+require 'ecs_deploy_cli/dsl/parser'
+require 'ecs_deploy_cli/runner'
+require 'ecs_deploy_cli/cli'

data/lib/ecs_deploy_cli/cli.rb

@@ -0,0 +1,58 @@
+module EcsDeployCli
+  class CLI < Thor
+    desc 'validate', 'Validates your ECSFile'
+    option :file, default: 'ECSFile'
+    def validate
+      @parser = load(options[:file])
+      runner.validate!
+      puts 'Your ECSFile looks fine! 🎉'
+    end
+
+    desc 'version', 'Updates all services defined in your ECSFile'
+    def version
+      puts "ECS Deploy CLI Version #{EcsDeployCli::VERSION}."
+    end
+
+    desc 'deploy-scheduled-tasks', 'Updates all scheduled tasks defined in your ECSFile'
+    option :file, default: 'ECSFile'
+    def deploy_scheduled_tasks
+      @parser = load(options[:file])
+      runner.update_crons!
+    end
+
+    desc 'deploy-services', 'Updates all services defined in your ECSFile'
+    option :only
+    option :file, default: 'ECSFile'
+    option :timeout, type: :numeric, default: 500
+    def deploy_services
+      @parser = load(options[:file])
+      runner.update_services! timeout: options[:timeout], service: options[:only]
+    end
+
+    desc 'deploy', 'Updates a single service defined in your ECSFile'
+    option :file, default: 'ECSFile'
+    option :timeout, type: :numeric, default: 500
+    def deploy
+      @parser = load(options[:file])
+      runner.update_services! timeout: options[:timeout]
+      runner.update_crons!
+    end
+
+    desc 'ssh', 'Connects to ECS instance via SSH'
+    option :file, default: 'ECSFile'
+    def ssh
+      @parser = load(options[:file])
+      runner.ssh
+    end
+
+    private
+
+    def load(file)
+      EcsDeployCli::DSL::Parser.load(file)
+    end
+
+    def runner
+      @runner ||= EcsDeployCli::Runner.new(@parser)
+    end
+  end
+end

data/lib/ecs_deploy_cli/dsl/auto_options.rb

@@ -0,0 +1,18 @@
+module EcsDeployCli
+  module DSL
+    module AutoOptions
+      def method_missing(name, *args, &block)
+        if args.count == 1 && !block
+          EcsDeployCli.logger.info("Auto-added option security_group #{name.to_sym} = #{args.first}")
+          _options[name.to_sym] = args.first
+        else
+          super
+        end
+      end
+
+      def _options
+        @_options ||= {}
+      end
+    end
+  end
+end

data/lib/ecs_deploy_cli/dsl/container.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module DSL
+    class Container
+      include AutoOptions
+
+      def initialize(name, config)
+        @config = config
+        _options[:name] = name.to_s
+      end
+
+      def image(value)
+        _options[:image] = value
+      end
+
+      def command(*command)
+        _options[:command] = command
+      end
+
+      def load_envs(name)
+        _options[:environment] = (_options[:environment] || []) + YAML.safe_load(File.open(name))
+      end
+
+      def env(key:, value:)
+        (_options[:environment] ||= []) << { 'name' => key, 'value' => value }
+      end
+
+      def secret(key:, value:)
+        (_options[:secrets] ||= []) << { name: key, value_from: "arn:aws:ssm:#{@config[:aws_region]}:#{@config[:aws_profile_id]}:parameter/#{value}" }
+      end
+
+      def expose(**options)
+        (_options[:port_mappings] ||= []) << options
+      end
+
+      def cpu(value)
+        _options[:cpu] = value
+      end
+
+      def memory(limit:, reservation:)
+        _options[:memory] = limit
+        _options[:memory_reservation] = reservation
+      end
+
+      def merge(other)
+        other_options = other._options
+        other_options.delete(:name)
+        _options.merge!(other_options)
+      end
+
+      def cloudwatch_logs(value)
+        _options[:log_configuration] = {
+          log_driver: 'awslogs',
+          options: {
+            'awslogs-group' => "/ecs/#{value}",
+            'awslogs-stream-prefix' => 'ecs',
+            'awslogs-region' => @config[:aws_region]
+          }
+        }
+      end
+
+      def as_definition
+        {
+          memory_reservation: nil,
+          essential: true
+        }.merge(_options)
+      end
+    end
+  end
+end

data/lib/ecs_deploy_cli/dsl/cron.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module DSL
+    class Cron
+      include AutoOptions
+
+      def initialize(name, config)
+        _options[:name] = name
+        @config = config
+      end
+
+      def task(name, &block)
+        _options[:task] = Task.new(name.to_s, @config)
+        _options[:task].instance_exec(&block)
+      end
+
+      def run_at(cron_expression)
+        @cron_expression = "cron(#{cron_expression})"
+      end
+
+      def run_every(interval)
+        @every = "rate(#{interval})"
+      end
+
+      def task_role(role)
+        _options[:task_role] = "arn:aws:iam::#{@config[:aws_profile_id]}:role/#{role}"
+      end
+
+      def subnets(*value)
+        _options[:subnets] = value
+      end
+
+      def security_groups(*value)
+        _options[:security_groups] = value
+      end
+
+      def launch_type(value)
+        _options[:launch_type] = value
+      end
+
+      def assign_public_ip(value)
+        _options[:assign_public_ip] = value
+      end
+
+      def as_definition(tasks)
+        raise 'Missing task definition' unless _options[:task]
+
+        input = { 'containerOverrides' => _options[:task].as_definition }
+        input['taskRoleArn'] = _options[:task_role] if _options[:task_role]
+
+        {
+          task_name: _options[:task].name,
+          rule: {
+            name: _options[:name],
+            schedule_expression: @cron_expression || @every || raise("Missing schedule expression.")
+          },
+          input: input,
+          ecs_parameters: {
+            # task_definition_arn: task_definition[:task_definition_arn],
+            task_count: _options[:task_count] || 1,
+            launch_type: _options[:launch_type] || raise('Missing parameter launch_type'),
+            network_configuration: {
+              awsvpc_configuration: {
+                subnets: _options[:subnets] || raise('Missing parameter subnets'),
+                security_groups: _options[:security_groups] || [],
+                assign_public_ip: _options[:assign_public_ip] ? 'ENABLED' : 'DISABLED'
+              }
+            },
+            platform_version: _options[:platform_version] || 'LATEST'
+          }
+        }
+      end
+
+      class Task
+        include AutoOptions
+
+        attr_reader :name
+
+        def initialize(name, config)
+          @name = name
+          @config = config
+        end
+
+        def container(name, &block)
+          container = Container.new(name, @config)
+          container.instance_exec(&block)
+          (_options[:containers] ||= []) << container
+        end
+
+        def as_definition
+          # [{"name"=>"cron", "command"=>["rails", "cron:adalytics"]}]
+          (_options[:containers] || []).map(&:as_definition)
+        end
+      end
+
+      class Container < EcsDeployCli::DSL::Container
+        def as_definition
+          _options.to_h
+        end
+      end
+    end
+  end
+end

data/lib/ecs_deploy_cli/dsl/parser.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module DSL
+    class Parser
+      def aws_profile_id(value)
+        config[:aws_profile_id] = value
+      end
+
+      def aws_region(value)
+        config[:aws_region] = value
+      end
+
+      def stage(stage)
+        config[:stage] = stage
+      end
+
+      def container(container, extends: nil, &block)
+        @containers ||= {}
+        @containers[container] = Container.new(container, config)
+        @containers[container].merge(@containers[extends]) if extends
+        @containers[container].instance_exec(&block)
+      end
+
+      def task(task, &block)
+        @tasks ||= {}.with_indifferent_access
+        @tasks[task] = Task.new(task, config)
+        @tasks[task].instance_exec(&block)
+      end
+
+      def service(name, &block)
+        @services ||= {}.with_indifferent_access
+        @services[name.to_s] = Service.new(name, config)
+        @services[name.to_s].instance_exec(&block)
+      end
+
+      def cron(name, &block)
+        @crons ||= {}.with_indifferent_access
+        @crons[name] = Cron.new(name, config)
+        @crons[name].instance_exec(&block)
+      end
+
+      def cluster(name)
+        config[:cluster] = name
+      end
+
+      def config
+        @config ||= {}
+      end
+
+      def ensure_required_params!
+        [
+          :aws_profile_id, :aws_region, :cluster
+        ].each { |key| raise "Missing required parameter #{key}" unless config[key] }
+      end
+
+      def resolve
+        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]
+      end
+
+      def self.load(file)
+        result = new
+        result.instance_eval(File.read(file))
+        result.ensure_required_params!
+        result
+      end
+    end
+  end
+end

data/lib/ecs_deploy_cli/dsl/service.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module DSL
+    class Service
+      include AutoOptions
+
+      def initialize(name, config)
+        _options[:service] = name
+        @config = config
+      end
+
+      def task(name)
+        _options[:task] = name
+      end
+
+      def options
+        _options
+      end
+
+      def as_definition(task)
+        {
+          cluster: @config[:cluster],
+          service: service_name,
+          task_definition: task
+        }
+      end
+    end
+  end
+end

data/lib/ecs_deploy_cli/dsl/task.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module DSL
+    class Task
+      include AutoOptions
+
+      def initialize(name, config)
+        @config = config
+        _options[:family] = name.to_s
+      end
+
+      def containers(*containers)
+        @containers = containers
+      end
+
+      def cpu(value)
+        @cpu = value.to_s
+      end
+
+      def memory(value)
+        @memory = value.to_s
+      end
+
+      def tag(key, value)
+        (_options[:tags] ||= []) << { key: key, value: value }
+      end
+
+      def volume(value)
+        (_options[:volumes] ||= []) << value
+      end
+
+      def execution_role(name)
+        _options[:execution_role_arn] = "arn:aws:iam::#{@config[:aws_profile_id]}:role/#{name}"
+      end
+
+      def as_definition(containers)
+        {
+          container_definitions: containers.values_at(*@containers),
+          execution_role_arn: "arn:aws:iam::#{@config[:aws_profile_id]}:role/ecsTaskExecutionRole",
+          requires_compatibilities: ['EC2'],
+          placement_constraints: [],
+          cpu: @cpu,
+          memory: @memory,
+          volumes: [],
+          network_mode: nil
+        }.merge(_options)
+      end
+    end
+  end
+end

data/lib/ecs_deploy_cli/runner.rb

@@ -0,0 +1,153 @@
+module EcsDeployCli
+  class Runner
+    def initialize(parser)
+      @parser = parser
+    end
+
+    def validate!
+      @parser.resolve
+    end
+
+    def update_crons!
+      _, tasks, crons = @parser.resolve
+
+      crons.each do |cron_name, cron_definition|
+        task_definition = tasks[cron_definition[:task_name]]
+        raise "Undefined task #{cron_definition[:task_name].inspect} in (#{tasks.keys.inspect})" unless task_definition
+
+        updated_task = _update_task(task_definition)
+
+        current_target = cwe_client.list_targets_by_rule(
+          {
+            rule: cron_name,
+            limit: 1
+          }
+        ).to_h[:targets].first
+
+        cwe_client.put_rule(
+          cron_definition[:rule]
+        )
+
+        cwe_client.put_targets(
+          rule: cron_name,
+          targets: [
+            id: current_target[:id],
+            arn: current_target[:arn],
+            role_arn: current_target[:role_arn],
+            input: cron_definition[:input].to_json,
+            ecs_parameters: cron_definition[:ecs_parameters].merge(task_definition_arn: updated_task[:task_definition_arn])
+          ]
+        )
+        EcsDeployCli.logger.info "Deployed scheduled task \"#{cron_name}\"!"
+      end
+    end
+
+    def ssh
+      instances = ecs_client.list_container_instances(
+        cluster: config[:cluster]
+      ).to_h[:container_instance_arns]
+
+      response = ecs_client.describe_container_instances(
+        cluster: config[:cluster],
+        container_instances: instances
+      )
+
+      EcsDeployCli.logger.info "Found instances: #{response.container_instances.map(&:ec2_instance_id).join(', ')}"
+
+      response = ec2_client.describe_instances(
+        instance_ids: response.container_instances.map(&:ec2_instance_id)
+      )
+
+      dns_name = response.reservations[0].instances[0].public_dns_name
+      EcsDeployCli.logger.info "Connecting to ec2-user@#{dns_name}..."
+
+      Process.fork { exec("ssh ec2-user@#{dns_name}") }
+      Process.wait
+    end
+
+    def update_services!(service: nil, timeout: 500)
+      services, resolved_tasks = @parser.resolve
+
+      services.each do |service_name, service_definition|
+        next if !service.nil? && service != service_name
+
+        task_definition = _update_task resolved_tasks[service_definition.options[:task]]
+        task_name = "#{task_definition[:family]}:#{task_definition[:revision]}"
+
+        ecs_client.update_service(
+          cluster: config[:cluster],
+          service: service_name,
+          task_definition: "#{task_definition[:family]}:#{task_name}"
+        )
+        wait_for_deploy(service_name, task_name, timeout: timeout)
+        EcsDeployCli.logger.info "Deployed service \"#{service_name}\"!"
+      end
+    end
+
+    private
+
+    def wait_for_deploy(service_name, task_name, timeout:)
+      wait_data = { cluster: config[:cluster], services: [service_name] }
+
+      started_at = Time.now
+      ecs_client.wait_until(
+        :services_stable, wait_data,
+        max_attempts: nil,
+        before_wait: lambda { |_, response|
+          deployments = response.services.first.deployments
+          log_deployments task_name, deployments
+
+          throw :success if deployments.count == 1 && deployments[0].task_definition.end_with?(task_name)
+          throw :failure if Time.now - started_at > timeout
+        }
+      )
+    end
+
+    def _update_task(definition)
+      ecs_client.register_task_definition(
+        definition
+      ).to_h[:task_definition]
+    end
+
+    def log_deployments(task_name, deployments)
+      EcsDeployCli.logger.info "Waiting for task: #{task_name} to become ok."
+      EcsDeployCli.logger.info 'Deployment status:'
+      deployments.each do |deploy|
+        EcsDeployCli.logger.info "[#{deploy.status}] task=#{deploy.task_definition.split('/').last}, "\
+                                 "desired_count=#{deploy.desired_count}, pending_count=#{deploy.pending_count}, running_count=#{deploy.running_count}, failed_tasks=#{deploy.failed_tasks}"
+      end
+      EcsDeployCli.logger.info ''
+    end
+
+    def ec2_client
+      @ec2_client ||= begin
+        require 'aws-sdk-ec2'
+        Aws::EC2::Client.new(
+          profile: ENV.fetch('AWS_PROFILE', 'default'),
+          region: config[:aws_region]
+        )
+      end
+    end
+
+    def ecs_client
+      @ecs_client ||= Aws::ECS::Client.new(
+        profile: ENV.fetch('AWS_PROFILE', 'default'),
+        region: config[:aws_region]
+      )
+    end
+
+    def cwe_client
+      @cwe_client ||= begin
+        require 'aws-sdk-cloudwatchevents'
+        Aws::CloudWatchEvents::Client.new(
+          profile: ENV.fetch('AWS_PROFILE', 'default'),
+          region: config[:aws_region]
+        )
+      end
+    end
+
+    def config
+      @parser.config
+    end
+  end
+end

data/lib/ecs_deploy_cli/version.rb

@@ -0,0 +1,3 @@
+module EcsDeployCli
+  VERSION = '0.1.0'
+end

data/spec/ecs_deploy_cli/cli_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe EcsDeployCli::CLI do
+  context 'defines task data' do
+    let(:runner) { double }
+
+    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
+
+    it 'runs help' do
+      expect { described_class.start(['help']) }.to output(/rspec deploy-scheduled-tasks/).to_stdout
+    end
+
+    it 'runs version' do
+      expect { described_class.start(['version']) }.to output(/Version #{EcsDeployCli::VERSION}/).to_stdout
+    end
+
+    it 'runs validate' do
+      expect { described_class.start(['validate', '--file', 'spec/support/ECSFile']) }.to output(/Your ECSFile looks fine! 🎉/).to_stdout
+    end
+
+    it 'runs deploy' do
+      expect(runner).to receive(:update_crons!)
+      expect(runner).to receive(:update_services!).with(timeout: 500)
+      expect_any_instance_of(described_class).to receive(:runner).at_least(:once).and_return(runner)
+      expect { described_class.start(['deploy', '--file', 'spec/support/ECSFile']) }.to output(/[WARNING]/).to_stdout
+    end
+
+    it 'runs deploy-services' do
+      expect(runner).to receive(:update_services!)
+      expect_any_instance_of(described_class).to receive(:runner).and_return(runner)
+      expect { described_class.start(['deploy-services', '--file', 'spec/support/ECSFile']) }.to output(/[WARNING]/).to_stdout
+    end
+
+    it 'runs ssh' do
+      expect(runner).to receive(:ssh)
+      expect_any_instance_of(described_class).to receive(:runner).and_return(runner)
+
+      described_class.start(['ssh', '--file', 'spec/support/ECSFile'])
+    end
+
+    it 'runs deploy-scheduled-tasks' do
+      expect(runner).to receive(:update_crons!)
+      expect_any_instance_of(described_class).to receive(:runner).and_return(runner)
+
+      described_class.start(['deploy-scheduled-tasks', '--file', 'spec/support/ECSFile'])
+    end
+  end
+end

data/spec/ecs_deploy_cli/dsl/container_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe EcsDeployCli::DSL::Container do
+  context 'defines container 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[:name]).to eq('test')
+    end
+
+    it '#memory configures memory' do
+      subject.memory limit: 1024, reservation: 900
+      expect(subject.as_definition[:memory]).to eq(1024)
+      expect(subject.as_definition[:memory_reservation]).to eq(900)
+    end
+
+    it '#env configures a single env' do
+      subject.env key: 'SOME', value: 'env'
+      subject.env key: 'SOME2', value: 'env2'
+      expect(subject.as_definition[:environment]).to eq(
+        [
+          {
+            'name' => 'SOME', 'value' => 'env'
+          },
+          {
+            'name' => 'SOME2', 'value' => 'env2'
+          }
+        ]
+      )
+    end
+
+    it '#cloudwatch_logs configures cloudwatch logs' do
+      subject.cloudwatch_logs 'yourproject'
+      expect(subject.as_definition[:log_configuration]).to eq(
+        {
+          log_driver: 'awslogs',
+          options: { 'awslogs-group' => '/ecs/yourproject', 'awslogs-region' => 'eu-central-1', 'awslogs-stream-prefix' => 'ecs' }
+        }
+      )
+    end
+
+    it '#secret configures secrets' do
+      subject.secret key: 'RAILS_MASTER_KEY', value: 'railsMasterKey'
+
+      expect(subject.as_definition[:secrets]).to eq(
+        [
+          {
+            name: 'RAILS_MASTER_KEY',
+            value_from: 'arn:aws:ssm:eu-central-1:123123:parameter/railsMasterKey'
+          }
+        ]
+      )
+    end
+
+    it '#merge: merges two containers' do
+      other = described_class.new('base', { aws_profile_id: '123123', aws_region: 'eu-central-1' })
+      other.expose host_port: 0, protocol: 'tcp', container_port: 3000
+
+      subject.secret key: 'RAILS_MASTER_KEY', value: 'railsMasterKey'
+      subject.merge(other)
+
+      expect(subject.as_definition[:secrets]).to eq(
+        [
+          {
+            name: 'RAILS_MASTER_KEY',
+            value_from: 'arn:aws:ssm:eu-central-1:123123:parameter/railsMasterKey'
+          }
+        ]
+      )
+
+      expect(subject.as_definition[:port_mappings]).to eq(
+        [
+          { host_port: 0, protocol: 'tcp', container_port: 3000 }
+        ]
+      )
+    end
+
+    it '#expose: configures port mapping' do
+      subject.expose host_port: 0, protocol: 'tcp', container_port: 3000
+      expect(subject.as_definition[:port_mappings]).to eq(
+        [
+          { host_port: 0, protocol: 'tcp', container_port: 3000 }
+        ]
+      )
+    end
+
+    it '#load_envs loads env files' do
+      subject.load_envs 'spec/support/env_file.yml'
+      expect(subject.as_definition[:environment]).to eq(
+        [
+          {
+            'name' => 'RAILS_ENV', 'value' => 'production'
+          },
+          {
+            'name' => 'API_KEY', 'value' => '123123123'
+          }
+        ]
+      )
+    end
+
+    it 'fallbacks not handled methods to an option in the container definition' do
+      subject.image 'some_image:version'
+      expect(subject.as_definition[:image]).to eq('some_image:version')
+    end
+  end
+end

data/spec/ecs_deploy_cli/dsl/cron_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe EcsDeployCli::DSL::Cron do
+  context 'defines cron data' do
+    subject { described_class.new('test', { aws_profile_id: '123123', aws_region: 'eu-central-1' }) }
+
+    let(:container) do
+      EcsDeployCli::DSL::Container.new('web', { aws_profile_id: '123123', aws_region: 'eu-central-1' }).as_definition
+    end
+
+    let(:task) do
+      task = EcsDeployCli::DSL::Task.new('some', { aws_profile_id: '123123', aws_region: 'eu-central-1' })
+      task.containers :web
+
+      task.as_definition({ web: container })
+    end
+
+    it '#task' do
+      subject.task :some do
+        container :web do
+          command 'rails', 'run:task'
+          memory limit: 2048, reservation: 1024
+        end
+      end
+      subject.subnets 'subnet-1298ca5f'
+      subject.security_groups 'sg-1298ca5f'
+      subject.launch_type 'FARGATE'
+      subject.task_role 'ecsEventsRole'
+      subject.run_every '2 hours'
+      subject.assign_public_ip true
+
+      expect(subject.as_definition({ 'some' => task })).to eq(
+        {
+          task_name: 'some',
+          input: {
+            'containerOverrides' => [
+              { command: ['rails', 'run:task'], memory: 2048, memory_reservation: 1024, name: 'web' }
+            ],
+            'taskRoleArn' => 'arn:aws:iam::123123:role/ecsEventsRole'
+          },
+          rule: {
+            name: 'test',
+            schedule_expression: 'rate(2 hours)'
+          },
+          ecs_parameters: {
+            task_count: 1,
+            launch_type: 'FARGATE',
+            network_configuration: {
+              awsvpc_configuration: {
+                subnets: ['subnet-1298ca5f'],
+                assign_public_ip: 'ENABLED',
+                security_groups: ['sg-1298ca5f']
+              }
+            },
+            platform_version: 'LATEST'
+          }
+        }
+      )
+    end
+  end
+end

data/spec/ecs_deploy_cli/dsl/parser_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe EcsDeployCli::DSL::Parser do
+  context 'defines task data' do
+    subject { described_class.load('spec/support/ECSFile') }
+
+    # TODO: More tests
+    it 'validates required data in a ECSFile' do
+      expect { subject.resolve }.to raise_error('Missing required parameter aws_profile_id')
+    end
+
+    context 'with all required data available' do
+      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
+
+      it 'imports the ECSFile' do
+        services, tasks = subject.resolve
+        expect(services).to include('yourproject-service')
+        expect(tasks).to include(:yourproject)
+      end
+    end
+  end
+end

data/spec/ecs_deploy_cli/dsl/task_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe EcsDeployCli::DSL::Task do
+  context 'defines task data' do
+    subject { described_class.new('test', { aws_profile_id: '123123', aws_region: 'eu-central-1' }) }
+
+    it 'has family name equals test' do
+      expect(subject.as_definition({})[:family]).to eq('test')
+    end
+
+    it '#tag adds a tag' do
+      subject.tag 'product', 'yourproject'
+      subject.tag 'product2', 'yourproject2'
+      expect(subject.as_definition({})[:tags]).to eq(
+        [
+          { key: 'product', value: 'yourproject' },
+          { key: 'product2', value: 'yourproject2' }
+        ]
+      )
+    end
+
+    it '#execution_role' do
+      subject.execution_role 'someRole'
+      expect(subject.as_definition({})[:execution_role_arn]).to eq(
+        'arn:aws:iam::123123:role/someRole'
+      )
+    end
+
+    it 'fallbacks not handled methods to an option in the container definition' do
+      subject.cpu 256
+      expect(subject.as_definition({})[:cpu]).to eq('256')
+    end
+  end
+end

data/spec/ecs_deploy_cli/runner_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require 'aws-sdk-cloudwatchevents'
+require 'aws-sdk-ec2'
+
+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_ecs_client) { Aws::ECS::Client.new(stub_responses: true) }
+    let(:mock_ec2_client) { Aws::EC2::Client.new(stub_responses: true) }
+    let(:mock_cwe_client) do
+      Aws::CloudWatchEvents::Client.new(stub_responses: true)
+    end
+
+    it '#validate!' do
+      expect { subject.validate! }.to raise_error('Missing required parameter aws_profile_id')
+    end
+
+    context 'with envs set' do
+      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
+
+      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')]))
+
+        expect(mock_ec2_client).to receive(:describe_instances)
+                                   .with(instance_ids: ['i-123123'])
+                                   .and_return(
+                                     double(reservations: [
+                                       double(instances: [double(public_dns_name: 'test.com')])
+                                      ]
+                                    )
+                                   )
+
+        expect(Process).to receive(:fork) do |&block|
+          block.call
+        end
+        expect(Process).to receive(:wait)
+
+        expect(subject).to receive(:exec).with('ssh ec2-user@test.com')
+        expect(subject).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
+        expect(subject).to receive(:ec2_client).at_least(:once).and_return(mock_ec2_client)
+
+        subject.ssh
+      end
+
+      it '#update_crons!' do
+        mock_ecs_client.stub_responses(:register_task_definition, { task_definition: { family: 'some', revision: 1, task_definition_arn: 'arn:task:eu-central-1:xxxx' } })
+
+        mock_cwe_client.stub_responses(:list_targets_by_rule, { targets: [{ id: '123', arn: 'arn:123' }] })
+
+        expect(subject).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
+        expect(subject).to receive(:cwe_client).at_least(:once).and_return(mock_cwe_client)
+
+        subject.update_crons!
+      end
+
+      it '#update_services!' do
+        expect(mock_ecs_client).to receive(:register_task_definition).at_least(:once).and_return({ task_definition: { family: 'some', revision: '1' } })
+        expect(mock_ecs_client).to receive(:update_service)
+        expect(mock_ecs_client).to receive(:wait_until)
+
+        expect(subject).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
+
+        subject.update_services!
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'active_support'
+require 'rspec'
+require 'ecs_deploy_cli'
+# require 'kaminari-activerecord'
+
+I18n.enforce_available_locales = false
+RSpec::Expectations.configuration.warn_about_potential_false_positives = false
+
+Dir[File.expand_path('../support/*.rb', __FILE__)].each { |f| require f }
+
+RSpec.configure do |config|
+
+end
+
+

data/spec/support/ECSFile

@@ -0,0 +1,80 @@
+aws_region ENV.fetch('AWS_REGION', 'eu-central-1')
+
+# Used to create ARNs
+aws_profile_id ENV['AWS_PROFILE_ID']
+
+# Defining the cluster name
+cluster 'yourproject-cluster'
+
+# This is used as a template for the next two containers, it will not be used inside a task
+container :base_container do
+  image "#{ENV['REPO_URL']}:#{ENV['CURRENT_VERSION']}"
+  load_envs 'spec/support/env_file.yml'
+  load_envs 'spec/support/env_file.ext.yml'
+  secret key: 'RAILS_MASTER_KEY', value: 'railsMasterKey' # Taking the secret from AWS System Manager with name "arn:aws:ssm:__AWS_REGION__:__AWS_PROFILE_ID__:parameter/railsMasterKey"
+  working_directory '/app'
+  cloudwatch_logs 'yourproject' # Configuring cloudwatch logs
+end
+
+# The rails web application
+container :web, extends: :base_container do
+  cpu 512
+  memory limit: 3584, reservation: 3584
+  command 'bundle', 'exec', 'puma', '-C', 'config/puma.rb'
+
+  expose host_port: 0, protocol: 'tcp', container_port: 3000
+end
+
+# The rails job worker
+container :worker, extends: :base_container do
+  cpu 1536
+  memory limit: 3584, reservation: 3584
+  command 'bundle', 'exec', 'shoryuken', '-C', 'config/shoryuken.yml', '-R'
+end
+
+# A container to exec cron jobs
+container :cron, extends: :base_container do
+  command 'rails', 'runner'
+end
+
+# The main task, having two containers
+task :yourproject do
+  containers :web, :worker
+  cpu 2048
+  memory 3584
+
+  tag 'product', 'yourproject'
+end
+
+# The main service
+service :'yourproject-service' do
+  task :yourproject
+end
+
+# A task for cron jobs
+task :'yourproject-cron' do
+  containers :cron
+  cpu 256
+  memory 1024
+  execution_role 'ecsTaskExecutionRole'
+  network_mode 'awsvpc'
+  requires_compatibilities ['FARGATE']
+
+  tag 'product', 'yourproject'
+end
+
+# Scheduled tasks using Cloudwatch Events / Eventbridge
+cron :scheduled_emails do
+  task :'yourproject-cron' do
+    # Overrides
+    container :cron do
+      command 'rails', 'cron:exec'
+    end
+  end
+  subnets 'subnet-123123'
+  launch_type 'FARGATE'
+  task_role 'ecsEventsRole'
+  # Examples:
+  # run_every '2 hours'
+  run_at '0 * * * ? *'
+end

data/spec/support/env_file.ext.yml

@@ -0,0 +1,2 @@
+- name: 'OTHER_API_KEY'
+  value: '321321321'

data/spec/support/env_file.yml

@@ -0,0 +1,5 @@
+- name: 'RAILS_ENV'
+  value: 'production'
+
+- name: 'API_KEY'
+  value: '123123123'

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification
+name: ecs_deploy_cli
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mònade
+- ProGM
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-cloudwatchevents
+  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
+    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-ecs
+  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: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.93'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.93'
+description: Declare your cluster structure in a ECSFile and use the CLI to run deploys
+  and monitor its status.
+email: team@monade.io
+executables:
+- ecs-deploy
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/ecs-deploy
+- lib/ecs-deploy-cli.rb
+- lib/ecs_deploy_cli.rb
+- lib/ecs_deploy_cli/cli.rb
+- lib/ecs_deploy_cli/dsl/auto_options.rb
+- lib/ecs_deploy_cli/dsl/container.rb
+- lib/ecs_deploy_cli/dsl/cron.rb
+- lib/ecs_deploy_cli/dsl/parser.rb
+- lib/ecs_deploy_cli/dsl/service.rb
+- lib/ecs_deploy_cli/dsl/task.rb
+- lib/ecs_deploy_cli/runner.rb
+- lib/ecs_deploy_cli/version.rb
+- spec/ecs_deploy_cli/cli_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/task_spec.rb
+- spec/ecs_deploy_cli/runner_spec.rb
+- spec/spec_helper.rb
+- spec/support/ECSFile
+- spec/support/env_file.ext.yml
+- spec/support/env_file.yml
+homepage: https://rubygems.org/gems/ecs_deploy_cli
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.7
+signing_key: 
+specification_version: 4
+summary: A command line interface to make ECS deployments easier
+test_files:
+- spec/spec_helper.rb
+- spec/support/ECSFile
+- 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