ecs_deploy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4bde853b69a4346173b9ea603cbdbfe7d6597f48
+  data.tar.gz: e41e68017918637cf37b93478e48f654fbef1349
+SHA512:
+  metadata.gz: b49db5e1393e599ea8f882f4c100c68e503f05e94ff5d1c089f617c4802055fe6c42b83fa894abf5d798cb03bd2d25d9aabee5e86a236b9e945db78b418c85fc
+  data.tar.gz: 48364e5d28e5e1b350d3e8cd3951d77ed88146c59bf1456dc18b5e258e74b86b1bdad13589e91c0a1fae0454c7b92c0d9810d42418de9880933bbc341afbfcb8

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+.envrc

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ecs_deploy.gemspec
+gemspec

data/README.md

@@ -0,0 +1,218 @@
+# EcsDeploy
+
+Helper script for deployment to Amazon ECS.
+
+This gem is experimental.
+
+Main purpose is combination with capistrano API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ecs_deploy', github: "reproio/ecs_deploy"
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+Use by Capistrano.
+
+```ruby
+# Capfile
+require 'ecs_deploy/capistrano'
+
+# deploy.rb
+set :ecs_default_cluster, "ecs-cluster-name"
+set :ecs_access_key_id, "dummy" # optional, if nil, use environment variable
+set :ecs_secret_access_key, "dummy" # optional, if nil, use environment variable
+set :ecs_region, %w(ap-northeast-1) # optional, if nil, use environment variable
+set :ecs_service_role, "customEcsServiceRole" # default: ecsServiceRole
+set :ecs_deploy_wait_timeout, 600 # default: 300
+
+set :ecs_tasks, [
+  {
+    name: "myapp-#{fetch(:rails_env)}",
+    container_definitions: [
+      {
+        name: "myapp",
+        image: "#{fetch(:docker_registry_host_with_port)}/myapp:#{fetch(:sha1)}",
+        cpu: 1024,
+        memory: 512,
+        port_mappings: [],
+        essential: true,
+        environment: [
+          {name: "RAILS_ENV", value: fetch(:rails_env)},
+        ],
+        mount_points: [
+          {
+            source_volume: "sockets_path",
+            container_path: "/app/tmp/sockets",
+            read_only: false,
+          },
+        ],
+        volumes_from: [],
+        log_configuration: {
+          log_driver: "fluentd",
+          options: {
+            "tag" => "docker.#{fetch(:rails_env)}.#{name}.{{.ID}}",
+          },
+        },
+      },
+      {
+        name: "nginx",
+        image: "#{fetch(:docker_registry_host_with_port)}/my-nginx",
+        cpu: 256,
+        memory: 256,
+        links: [],
+        port_mappings: [
+          {container_port: 443, host_port: 443, protocol: "tcp"},
+        ],
+        essential: true,
+        environment: {},
+        mount_points: [],
+        volumes_from: [
+          {source_container: "myapp-#{fetch(:rails_env)}", read_only: false},
+        ],
+        log_configuration: {
+          log_driver: "fluentd",
+          options: {
+            "tag" => "docker.#{fetch(:rails_env)}.#{name}.{{.ID}}",
+          },
+        },
+      }
+    ],
+    volumes: [{name: "sockets_path", host: {}}],
+    executions: [ # execution task on deploy timing
+      {container_overrides: [{name: "myapp", command: ["db_migrate"]}]},
+    ]
+  },
+]
+
+set :ecs_services, [
+  {
+    name: "myapp-#{fetch(:rails_env)}",
+    elb_name: "service-elb-name",
+    elb_service_port: 443,
+    elb_healthcheck_port: 443,
+    elb_container_name: "nginx",
+    desired_count: 1,
+    deployment_configuration: {maximum_percent: 200, minimum_healthy_percent: 50},
+  },
+]
+```
+
+```sh
+cap <stage> ecs:register_task_definition # register ecs_tasks as TaskDefinition
+cap <stage> ecs:deploy # create or update Service by ecs_services info
+
+cap <stage> ecs:rollback # deregister current task definition and update Service by previous revision of current task definition
+```
+
+### Rollback example
+
+| sequence | taskdef  | service       | desc    |
+| -------- | -------- | ------------- | ------  |
+| 1        | myapp:12 | myapp-service |         |
+| 2        | myapp:13 | myapp-service |         |
+| 3        | myapp:14 | myapp-service | current |
+
+After rollback
+
+| sequence | taskdef  | service       | desc       |
+| -------- | -------- | ------------- | ------     |
+| 1        | myapp:12 | myapp-service |            |
+| 2        | myapp:13 | myapp-service |            |
+| 3        | myapp:14 | myapp-service | deregister |
+| 4        | myapp:13 | myapp-service | current    |
+
+And rollback again
+
+| sequence | taskdef  | service       | desc       |
+| -------- | -------- | ------------- | ------     |
+| 1        | myapp:12 | myapp-service |            |
+| 2        | myapp:13 | myapp-service | previous   |
+| 3        | myapp:14 | myapp-service | deregister |
+| 4        | myapp:13 | myapp-service | deregister |
+| 5        | myapp:12 | myapp-service | current    |
+
+And deploy new version
+
+| sequence | taskdef  | service       | desc       |
+| -------- | -------- | ------------- | ------     |
+| 1        | myapp:12 | myapp-service |            |
+| 2        | myapp:13 | myapp-service |            |
+| 3        | myapp:14 | myapp-service | deregister |
+| 4        | myapp:13 | myapp-service | deregister |
+| 5        | myapp:12 | myapp-service |            |
+| 6        | myapp:15 | myapp-service | current    |
+
+And rollback
+
+| sequence | taskdef  | service       | desc       |
+| -------- | -------- | ------------- | ------     |
+| 1        | myapp:12 | myapp-service |            |
+| 2        | myapp:13 | myapp-service |            |
+| 3        | myapp:14 | myapp-service | deregister |
+| 4        | myapp:13 | myapp-service | deregister |
+| 5        | myapp:12 | myapp-service |            |
+| 6        | myapp:15 | myapp-service | deregister |
+| 7        | myapp:12 | myapp-service | current    |
+
+## Autoscaler
+
+Write config file (YAML format).
+
+```yaml
+# ポーリング時にupscale_triggersに指定した状態のalarmがあればstep分serviceとinstanceを増やす (max_task_countまで)
+# ポーリング時にdownscale_triggersに指定した状態のalarmがあればstep分serviceとinstanceを減らす (min_task_countまで)
+# max_task_countは段階的にリミットを設けられるようにする
+# 一回リミットに到達するとcooldown_for_reach_maxを越えても状態が継続したら再開するようにする
+
+polling_interval: 60
+
+auto_scaling_groups:
+  - name: ecs-cluster-nodes
+    region: ap-northeast-1
+    buffer: 1 # タスク数に対する余剰のインスタンス数
+
+services:
+  - name: repro-api-production
+    cluster: ecs-cluster
+    region: ap-northeast-1
+    auto_scaling_group_name: ecs-cluster-nodes
+    step: 1
+    idle_time: 240
+    max_task_count: [10, 25]
+    cooldown_time_for_reach_max: 600
+    min_task_count: 0
+    upscale_triggers:
+      - alarm_name: "ECS [repro-api-production] CPUUtilization"
+        state: ALARM
+      - alarm_name: "ELB repro-api-a HTTPCode_Backend_5XX"
+        state: ALARM
+        step: 2
+    downscale_triggers:
+      - alarm_name: "ECS [repro-api-production] CPUUtilization (low)"
+        state: OK
+```
+
+```sh
+ecs_auto_scaler <config yaml>
+```
+
+I recommends deploy `ecs_auto_scaler` on ECS too.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/joker1007/ecs_deploy.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ecs_deploy"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ecs_deploy.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ecs_deploy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ecs_deploy"
+  spec.version       = EcsDeploy::VERSION
+  spec.authors       = ["joker1007"]
+  spec.email         = ["kakyoin.hierophant@gmail.com"]
+
+  spec.summary       = %q{AWS ECS deploy helper}
+  spec.description   = %q{AWS ECS deploy helper}
+  spec.homepage      = "https://github.com/reproio/ecs_deploy"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "aws-sdk", "~> 2.2"
+  spec.add_runtime_dependency "terminal-table"
+  spec.add_runtime_dependency "paint"
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/exe/ecs_auto_scaler

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "ecs_deploy"
+require "ecs_deploy/auto_scaler"
+
+EcsDeploy::AutoScaler.run(*ARGV)

data/lib/ecs_deploy.rb

@@ -0,0 +1,28 @@
+require "ecs_deploy/version"
+require "ecs_deploy/configuration"
+
+require 'logger'
+require 'terminal-table'
+require 'paint'
+
+module EcsDeploy
+  def self.logger
+    @logger ||= Logger.new(STDOUT).tap do |l|
+      l.level = Logger.const_get(config.log_level.to_s.upcase)
+    end
+  end
+
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  def self.configure(&block)
+    if block_given?
+      yield config
+      @logger = nil
+    end
+  end
+end
+
+require "ecs_deploy/task_definition"
+require "ecs_deploy/service"

data/lib/ecs_deploy/auto_scaler.rb

@@ -0,0 +1,276 @@
+require 'yaml'
+require 'logger'
+require 'time'
+
+module EcsDeploy
+  module AutoScaler
+    class << self
+      attr_reader :logger, :error_logger
+
+      def run(yaml_path, log_file = nil, error_log_file = nil)
+        trap(:TERM) { exit 0 }
+        @logger = Logger.new(log_file || STDOUT)
+        STDOUT.sync = true unless log_file
+        @error_logger = Logger.new(error_log_file || STDERR)
+        STDERR.sync = true unless error_log_file
+        load_config(yaml_path)
+
+        until @stop
+          run_loop
+        end
+      end
+
+      def stop
+        @stop = true
+      end
+
+      def run_loop
+        service_configs.each do |s|
+          next if s.idle?
+
+          difference = 0
+          s.upscale_triggers.each do |trigger|
+            step = trigger.step || s.step
+            next if difference >= step
+
+            if trigger.match?
+              logger.info "Fire upscale trigger of #{s.name} by #{trigger.alarm_name} #{trigger.state}"
+              difference = step
+            end
+          end
+
+          if difference == 0 && s.desired_count > s.current_min_task_count
+            s.downscale_triggers.each do |trigger|
+              if trigger.match?
+                logger.info "Fire downscale trigger of #{s.name} by #{trigger.alarm_name} #{trigger.state}"
+                step = trigger.step || s.step
+                difference = [difference, -(step)].min
+              end
+            end
+          end
+
+          if s.current_min_task_count > s.desired_count + difference
+            difference = s.current_min_task_count - s.desired_count
+          end
+
+          if difference >= 0 && s.desired_count > s.max_task_count.max
+            difference = s.max_task_count.max - s.desired_count
+          end
+
+          if difference != 0
+            s.update_service(s.desired_count + difference)
+          end
+        end
+
+        service_configs.group_by { |s| [s.region, s.auto_scaling_group_name] }.each do |(region, auto_scaling_group_name), configs|
+          total_service_count = configs.inject(0) { |sum, s| sum + s.desired_count }
+          asg_config = auto_scaling_group_configs.find { |c| c.name == auto_scaling_group_name && c.region == region }
+          asg_config.update_auto_scaling_group(total_service_count)
+        end
+
+        TriggerConfig.clear_alarm_cache
+
+        sleep @polling_interval
+      end
+
+      def load_config(yaml_path)
+        @config = YAML.load_file(yaml_path)
+        @polling_interval = @config["polling_interval"]
+      end
+
+      def service_configs
+        @service_configs ||= @config["services"].map(&ServiceConfig.method(:new))
+      end
+
+      def auto_scaling_group_configs
+        @auto_scaling_group_configs ||= @config["auto_scaling_groups"].map(&AutoScalingConfig.method(:new))
+      end
+    end
+
+    module ConfigBase
+      module ClassMethods
+        def client_table
+          @client_table ||= {}
+        end
+      end
+
+      def initialize(attributes = {})
+        attributes.each do |key, val|
+          send("#{key}=", val)
+        end
+      end
+    end
+
+    SERVICE_CONFIG_ATTRIBUTES = %i(name cluster region auto_scaling_group_name step max_task_count min_task_count idle_time scheduled_min_task_count cooldown_time_for_reach_max upscale_triggers downscale_triggers desired_count)
+    ServiceConfig = Struct.new(*SERVICE_CONFIG_ATTRIBUTES) do
+      include ConfigBase
+      extend ConfigBase::ClassMethods
+
+      def initialize(attributes = {})
+        super(attributes)
+        self.idle_time ||= 60
+        self.max_task_count = Array(max_task_count)
+        self.upscale_triggers = upscale_triggers.to_a.map do |t|
+          TriggerConfig.new(t.merge(region: region))
+        end
+        self.downscale_triggers = downscale_triggers.to_a.map do |t|
+          TriggerConfig.new(t.merge(region: region))
+        end
+        self.max_task_count.sort!
+        self.desired_count = fetch_service.desired_count
+        @reach_max_at = nil
+        @last_updated_at = nil
+      end
+
+      def client
+        self.class.client_table[region] ||= Aws::ECS::Client.new(
+          access_key_id: EcsDeploy.config.access_key_id,
+          secret_access_key: EcsDeploy.config.secret_access_key,
+          region: region
+        )
+      end
+
+      def idle?
+        return false unless @last_updated_at
+        (Time.now - @last_updated_at) < idle_time
+      end
+
+      def current_min_task_count
+        return min_task_count if scheduled_min_task_count.nil? || scheduled_min_task_count.empty?
+
+        scheduled_min_task_count.find(-> { {"count" => min_task_count} }) { |s|
+          from = Time.parse(s["from"])
+          to = Time.parse(s["to"])
+          (from..to).cover?(Time.now)
+        }["count"]
+      end
+
+      def overheat?
+        return false unless @reach_max_at
+        (Time.now - @reach_max_at) > cooldown_time_for_reach_max
+      end
+
+      def fetch_service
+        res = client.describe_services(cluster: cluster, services: [name])
+        raise "Service \"#{name}\" is not found" if res.services.empty?
+        res.services[0]
+      rescue => e
+        AutoScaler.error_logger.error(e)
+        self.class.client_table[region] = nil
+      end
+
+      def update_service(next_desired_count)
+        current_level = max_task_level(desired_count)
+        next_level = max_task_level(next_desired_count)
+        if current_level < next_level && overheat? # next max
+          level = next_level
+          @reach_max_at = nil
+          AutoScaler.logger.info "Service \"#{name}\" is overheat, uses next max count"
+        elsif current_level < next_level && !overheat? # wait cooldown
+          level = current_level
+          @reach_max_at ||= Time.now
+          AutoScaler.logger.info "Service \"#{name}\" waits cooldown in #{(Time.now - @reach_max_at).to_i}sec"
+        elsif current_level == next_level && next_desired_count >= max_task_count[current_level] # reach current max
+          level = current_level
+          @reach_max_at ||= Time.now
+          AutoScaler.logger.info "Service \"#{name}\" waits cooldown in #{(Time.now - @reach_max_at).to_i}sec"
+        elsif current_level == next_level && next_desired_count < max_task_count[current_level]
+          level = current_level
+          @reach_max_at = nil
+          AutoScaler.logger.info "Service \"#{name}\" clears cooldown state"
+        elsif current_level > next_level
+          level = next_level
+          @reach_max_at = nil
+          AutoScaler.logger.info "Service \"#{name}\" clears cooldown state"
+        end
+
+        next_desired_count = [next_desired_count, max_task_count[level]].min
+        client.update_service(
+          cluster: cluster,
+          service: name,
+          desired_count: next_desired_count,
+        )
+        @last_updated_at = Time.now
+        self.desired_count = next_desired_count
+        AutoScaler.logger.info "Update service \"#{name}\": desired_count -> #{next_desired_count}"
+      rescue => e
+        AutoScaler.error_logger.error(e)
+        self.class.client_table[region] = nil
+      end
+
+      private
+
+      def max_task_level(count)
+        max_task_count.index { |i| count <= i } || max_task_count.size - 1
+      end
+    end
+
+    TriggerConfig = Struct.new(:alarm_name, :region, :state, :step) do
+      include ConfigBase
+      extend ConfigBase::ClassMethods
+
+      def self.alarm_cache
+        @alarm_cache ||= {}
+      end
+
+      def self.clear_alarm_cache
+        @alarm_cache.clear if @alarm_cache
+      end
+
+      def client
+        self.class.client_table[region] ||= Aws::CloudWatch::Client.new(
+          access_key_id: EcsDeploy.config.access_key_id,
+          secret_access_key: EcsDeploy.config.secret_access_key,
+          region: region
+        )
+      end
+
+      def match?
+        fetch_alarm.state_value == state
+      end
+
+      def fetch_alarm
+        alarm_cache = self.class.alarm_cache
+        return alarm_cache[region][alarm_name] if alarm_cache[region] && alarm_cache[region][alarm_name]
+
+        res = client.describe_alarms(alarm_names: [alarm_name])
+        raise "Alarm \"#{alarm_name}\" is not found" if res.metric_alarms.empty?
+        res.metric_alarms[0].tap do |alarm|
+          AutoScaler.logger.debug(alarm.to_json)
+          alarm_cache[region] ||= {}
+          alarm_cache[region][alarm_name] = alarm
+        end
+      rescue => e
+        AutoScaler.error_logger.error(e)
+        self.class.client_table[region] = nil
+      end
+    end
+
+    AutoScalingConfig = Struct.new(:name, :region, :buffer) do
+      include ConfigBase
+      extend ConfigBase::ClassMethods
+
+      def client
+        self.class.client_table[region] ||= Aws::AutoScaling::Client.new(
+          access_key_id: EcsDeploy.config.access_key_id,
+          secret_access_key: EcsDeploy.config.secret_access_key,
+          region: region
+        )
+      end
+
+      def update_auto_scaling_group(total_service_count)
+        desired_capacity = total_service_count + buffer.to_i
+        client.update_auto_scaling_group(
+          auto_scaling_group_name: name,
+          min_size: desired_capacity,
+          max_size: desired_capacity,
+          desired_capacity: desired_capacity,
+        )
+        AutoScaler.logger.info "Update auto scaling group \"#{name}\": desired_capacity -> #{desired_capacity}"
+      rescue => e
+        AutoScaler.error_logger.error(e)
+        self.class.client_table[region] = nil
+      end
+    end
+  end
+end

data/lib/ecs_deploy/capistrano.rb

@@ -0,0 +1,134 @@
+require 'ecs_deploy'
+
+namespace :ecs do
+  task :configure do
+    EcsDeploy.configure do |c|
+      c.log_level = fetch(:ecs_log_level) if fetch(:ecs_log_level)
+      c.deploy_wait_timeout = fetch(:ecs_deploy_wait_timeout) if fetch(:ecs_deploy_wait_timeout)
+      c.ecs_service_role = fetch(:ecs_service_role) if fetch(:ecs_service_role)
+      c.default_region = Array(fetch(:ecs_region))[0] if fetch(:ecs_region)
+    end
+
+    if ENV["TARGET_CLUSTER"]
+      set :target_cluster, ENV["TARGET_CLUSTER"].split(",").map(&:strip)
+    end
+    if ENV["TARGET_TASK_DEFINITION"]
+      set :target_task_definition, ENV["TARGET_TASK_DEFINITION"].split(",").map(&:strip)
+    end
+  end
+
+  task register_task_definition: [:configure] do
+    if fetch(:ecs_tasks)
+      regions = Array(fetch(:ecs_region))
+      regions = [nil] if regions.empty?
+      regions.each do |r|
+        fetch(:ecs_tasks).each do |t|
+          task_definition = EcsDeploy::TaskDefinition.new(
+            region: r,
+            task_definition_name: t[:name],
+            container_definitions: t[:container_definitions],
+            volumes: t[:volumes]
+          )
+          task_definition.register
+
+          t[:executions].to_a.each do |exec|
+            exec[:cluster] ||= fetch(:ecs_default_cluster)
+            task_definition.run(exec)
+          end
+        end
+      end
+    end
+  end
+
+  task deploy: [:configure, :register_task_definition] do
+    if fetch(:ecs_services)
+      regions = Array(fetch(:ecs_region))
+      regions = [nil] if regions.empty?
+      regions.each do |r|
+        services = fetch(:ecs_services).map do |service|
+          if fetch(:target_cluster) && fetch(:target_cluster).size > 0
+            next unless fetch(:target_cluster).include?(service[:cluster])
+          end
+          if fetch(:target_task_definition) && fetch(:target_task_definition).size > 0
+            next unless fetch(:target_task_definition).include?(service[:task_definition_name])
+          end
+
+          service_options = {
+            region: r,
+            cluster: service[:cluster] || fetch(:ecs_default_cluster),
+            service_name: service[:name],
+            task_definition_name: service[:task_definition_name],
+            elb_name: service[:elb_name],
+            elb_service_port: service[:elb_service_port],
+            elb_healthcheck_port: service[:elb_healthcheck_port],
+            elb_container_name: service[:elb_container_name],
+            desired_count: service[:desired_count],
+          }
+          service_options[:deployment_configuration] = service[:deployment_configuration] if service[:deployment_configuration]
+          s = EcsDeploy::Service.new(service_options)
+          s.deploy
+          s
+        end
+        EcsDeploy::Service.wait_all_running(services)
+      end
+    end
+  end
+
+  task rollback: [:configure] do
+    if fetch(:ecs_services)
+      regions = Array(fetch(:ecs_region))
+      regions = [nil] if regions.empty?
+      regions.each do |r|
+        services = fetch(:ecs_services).map do |service|
+          if fetch(:target_cluster) && fetch(:target_cluster).size > 0
+            next unless fetch(:target_cluster).include?(service[:cluster])
+          end
+          if fetch(:target_task_definition) && fetch(:target_task_definition).size > 0
+            next unless fetch(:target_task_definition).include?(service[:task_definition_name])
+          end
+
+          task_definition_arns = EcsDeploy::TaskDefinition.new(
+            region: r,
+            task_definition_name: service[:task_definition_name] || service[:name],
+          ).recent_task_definition_arns
+
+          rollback_step = (ENV["STEP"] || 1).to_i
+
+          current_task_definition_arn = EcsDeploy::Service.new(
+            region: r,
+            cluster: service[:cluster] || fetch(:ecs_default_cluster),
+            service_name: service[:name],
+          ).current_task_definition_arn
+
+          current_arn_index = task_definition_arns.index do |arn|
+            arn == current_task_definition_arn
+          end
+
+          rollback_arn = task_definition_arns[current_arn_index + rollback_step]
+
+          EcsDeploy.logger.info "#{current_task_definition_arn} -> #{rollback_arn}"
+
+          raise "Past task_definition_arns is nothing" unless rollback_arn
+
+          service_options = {
+            region: r,
+            cluster: service[:cluster] || fetch(:ecs_default_cluster),
+            service_name: service[:name],
+            task_definition_name: rollback_arn,
+            elb_name: service[:elb_name],
+            elb_service_port: service[:elb_service_port],
+            elb_healthcheck_port: service[:elb_healthcheck_port],
+            elb_container_name: service[:elb_container_name],
+            desired_count: service[:desired_count],
+          }
+          service_options[:deployment_configuration] = service[:deployment_configuration] if service[:deployment_configuration]
+          s = EcsDeploy::Service.new(service_options)
+          s.deploy
+          EcsDeploy::TaskDefinition.deregister(current_task_definition_arn, region: r)
+          s
+        end
+        EcsDeploy::Service.wait_all_running(services)
+      end
+    end
+  end
+end

data/lib/ecs_deploy/configuration.rb

@@ -0,0 +1,17 @@
+module EcsDeploy
+  class Configuration
+    attr_accessor \
+      :log_level,
+      :access_key_id,
+      :secret_access_key,
+      :default_region,
+      :deploy_wait_timeout,
+      :ecs_service_role
+
+    def initialize
+      @log_level = :info
+      @deploy_wait_timeout = 300
+      @ecs_service_role = "ecsServiceRole"
+    end
+  end
+end

data/lib/ecs_deploy/service.rb

@@ -0,0 +1,101 @@
+require 'timeout'
+
+module EcsDeploy
+  class Service
+    CHECK_INTERVAL = 5
+    attr_reader :cluster, :region, :service_name
+
+    def initialize(
+      cluster:, service_name:, task_definition_name: nil, revision: nil,
+      elb_name: nil, elb_service_port: nil, elb_healthcheck_port: nil, elb_container_name: nil,
+      desired_count: nil, deployment_configuration: {maximum_percent: 200, minimum_healthy_percent: 100},
+      region: nil
+    )
+      @cluster = cluster
+      @service_name = service_name
+      @task_definition_name = task_definition_name || service_name
+      @elb_name = elb_name
+      @elb_service_port = elb_service_port
+      @elb_healthcheck_port = elb_healthcheck_port
+      @elb_container_name = elb_container_name
+      @desired_count = desired_count
+      @deployment_configuration = deployment_configuration
+      @revision = revision
+      @region = region || EcsDeploy.config.default_region || ENV["AWS_DEFAULT_REGION"]
+      @response = nil
+
+      @client = Aws::ECS::Client.new(region: @region)
+    end
+
+    def current_task_definition_arn
+      res = @client.describe_services(cluster: @cluster, services: [@service_name])
+      res.services[0].task_definition
+    end
+
+    def deploy
+      res = @client.describe_services(cluster: @cluster, services: [@service_name])
+      service_options = {
+        cluster: @cluster,
+        task_definition: task_definition_name_with_revision,
+        deployment_configuration: @deployment_configuration,
+      }
+      if res.services.empty?
+        service_options.merge!({service_name: @service_name})
+        if @elb_name
+          service_options.merge!({
+            role: EcsDeploy.config.ecs_service_role,
+            desired_count: @desired_count.to_i,
+            load_balancers: [
+              {
+                load_balancer_name: @elb_name,
+                container_name: @elb_container_name,
+                container_port: @elb_service_port,
+              }
+            ],
+          })
+        end
+        @response = @client.create_service(service_options)
+        EcsDeploy.logger.info "create service [#{@service_name}] [#{@region}] [#{Paint['OK', :green]}]"
+      else
+        service_options.merge!({service: @service_name})
+        service_options.merge!({desired_count: @desired_count}) if @desired_count
+        @response = @client.update_service(service_options)
+        EcsDeploy.logger.info "update service [#{@service_name}] [#{@region}] [#{Paint['OK', :green]}]"
+      end
+    end
+
+    def wait_running
+      return if @response.nil?
+
+      service = @response.service
+      deployment = nil
+
+      @client.wait_until(:services_stable, cluster: @cluster, services: [service.service_name]) do |w|
+        w.delay = 10
+
+        w.before_attempt do
+          EcsDeploy.logger.info "wait service stable [#{service.service_name}]"
+        end
+      end
+    end
+
+    def self.wait_all_running(services)
+      services.group_by { |s| [s.cluster, s.region] }.each do |(cl, region), ss|
+        client = Aws::ECS::Client.new(region: region)
+        service_names = ss.map(&:service_name)
+        client.wait_until(:services_stable, cluster: cl, services: service_names) do |w|
+          w.before_attempt do
+            EcsDeploy.logger.info "wait service stable [#{service_names.join(", ")}]"
+          end
+        end
+      end
+    end
+
+    private
+
+    def task_definition_name_with_revision
+      suffix = @revision ? ":#{@revision}" : ""
+      "#{@task_definition_name}#{suffix}"
+    end
+  end
+end

data/lib/ecs_deploy/task_definition.rb

@@ -0,0 +1,88 @@
+module EcsDeploy
+  class TaskDefinition
+    def self.deregister(arn, region: nil)
+      region = region || EcsDeploy.config.default_region || ENV["AWS_DEFAULT_REGION"]
+      client = Aws::ECS::Client.new(region: region)
+      client.deregister_task_definition({
+        task_definition: arn,
+      })
+      EcsDeploy.logger.info "deregister task definition [#{arn}] [#{region}] [#{Paint['OK', :green]}]"
+    end
+
+    def initialize(
+      task_definition_name:, region: nil,
+      volumes: [], container_definitions: []
+    )
+      @task_definition_name = task_definition_name
+      @region = region || EcsDeploy.config.default_region || ENV["AWS_DEFAULT_REGION"]
+
+      @container_definitions = container_definitions.map do |cd|
+        if cd[:docker_labels]
+          cd[:docker_labels] = cd[:docker_labels].map { |k, v| [k.to_s, v] }.to_h
+        end
+        if cd[:log_configuration] && cd[:log_configuration][:options]
+          cd[:log_configuration][:options] = cd[:log_configuration][:options].map { |k, v| [k.to_s, v] }.to_h
+        end
+        cd
+      end
+      @volumes = volumes
+
+      @client = Aws::ECS::Client.new(region: @region)
+    end
+
+    def recent_task_definition_arns
+      resp = @client.list_task_definitions(
+        family_prefix: @task_definition_name,
+        sort: "DESC"
+      )
+      resp.task_definition_arns
+    rescue
+      []
+    end
+
+    def register
+      @client.register_task_definition({
+        family: @task_definition_name,
+        container_definitions: @container_definitions,
+        volumes: @volumes,
+      })
+      EcsDeploy.logger.info "register task definition [#{@task_definition_name}] [#{@region}] [#{Paint['OK', :green]}]"
+    end
+
+    def run(info)
+      resp = @client.run_task({
+        cluster: info[:cluster],
+        task_definition: @task_definition_name,
+        overrides: {
+          container_overrides: info[:container_overrides] || []
+        },
+        count: info[:count] || 1,
+        started_by: "capistrano",
+      })
+      unless resp.failures.empty?
+        resp.failures.each do |f|
+          raise "#{f.arn}: #{f.reason}"
+        end
+      end
+
+      wait_targets = Array(info[:wait_stop])
+      unless wait_targets.empty?
+        @client.wait_until(:tasks_running, cluster: info[:cluster], tasks: resp.tasks.map { |t| t.task_arn })
+        @client.wait_until(:tasks_stopped, cluster: info[:cluster], tasks: resp.tasks.map { |t| t.task_arn })
+
+        resp = @client.describe_tasks(cluster: info[:cluster], tasks: resp.tasks.map { |t| t.task_arn })
+        resp.tasks.each do |t|
+          t.containers.each do |c|
+            next unless wait_targets.include?(c.name)
+
+            unless c.exit_code.zero?
+              raise "Task has errors: #{c.reason}"
+            end
+          end
+        end
+      end
+
+      EcsDeploy.logger.info "run task [#{@task_definition_name} #{info.inspect}] [#{@region}] [#{Paint['OK', :green]}]"
+    end
+  end
+end

data/lib/ecs_deploy/version.rb

@@ -0,0 +1,3 @@
+module EcsDeploy
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: ecs_deploy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- joker1007
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-06-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: paint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: AWS ECS deploy helper
+email:
+- kakyoin.hierophant@gmail.com
+executables:
+- ecs_auto_scaler
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ecs_deploy.gemspec
+- exe/ecs_auto_scaler
+- lib/ecs_deploy.rb
+- lib/ecs_deploy/auto_scaler.rb
+- lib/ecs_deploy/capistrano.rb
+- lib/ecs_deploy/configuration.rb
+- lib/ecs_deploy/service.rb
+- lib/ecs_deploy/task_definition.rb
+- lib/ecs_deploy/version.rb
+homepage: https://github.com/reproio/ecs_deploy
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: AWS ECS deploy helper
+test_files: []