ecs_deploy 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f73db4d410c3327f1df2cf645d62e9be95c2995
-  data.tar.gz: 8f0296f5046ffa43bd5e6f3a2ec1ab98cdbb2dfd
+  metadata.gz: a5027056d7641256dc566be9a2fd16dff8046f42
+  data.tar.gz: 009c12a42f0fdcd18f3c8a53b35f0e48055112a8
 SHA512:
-  metadata.gz: a08753cf01846ea1f82c0532a44df97b13f4a338ac3c6e0baf1c0973345981a5ef6f85a5f4e7d3782840dc842ba722f33a9a50d4856a47f76bce55daccd4f28c
-  data.tar.gz: 78580a080cf36d910405bd0a46a4ce5c301951a4b004b38f4e16b3e0b6af4727e68644d9061050d190cb6abf32af63c9d4e9600eff0c87a011b8bde8ae97b2ca
+  metadata.gz: c53395003a3e8953aef1d63cdf7a59d89b1f45e90b0acef1a00ff4420a4e96139e854427e204650aecfbf02f6a064348a6dea9f5919ef6b161a4e962e9d2b6bf
+  data.tar.gz: 82ce007f7e3e5ac6f4c30a705a6c16ca16889302d4c316a08990fae786bb403f9679582788584a23032d6894f04bcb6b321c82155c759844283c2400279162e2

data/README.md

@@ -96,10 +96,18 @@ set :ecs_tasks, [
 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",
+    load_balancers: [
+      {
+        load_balancer_name: "service-elb-name",
+        container_port: 443,
+        container_name: "nginx",
+      },
+      {
+        target_group_arn: "alb_target_group_arn",
+        container_port: 443,
+        container_name: "nginx",
+      }
+    ],
     desired_count: 1,
     deployment_configuration: {maximum_percent: 200, minimum_healthy_percent: 50},
   },

data/ecs_deploy.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   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 "aws-sdk", "~> 2.4"
   spec.add_runtime_dependency "terminal-table"
   spec.add_runtime_dependency "paint"
 

data/lib/ecs_deploy/auto_scaler.rb

@@ -8,74 +8,83 @@ module EcsDeploy
       attr_reader :logger, :error_logger
 
       def run(yaml_path, log_file = nil, error_log_file = nil)
-        trap(:TERM) { exit 0 }
+        trap(:TERM) { @stop = true }
+        trap(:INT) { @stop = true }
         @logger = Logger.new(log_file || STDOUT)
+        @logger.level = Logger.const_get(ENV["ECS_AUTO_SCALER_LOG_LEVEL"].upcase) if ENV["ECS_AUTO_SCALER_LOG_LEVEL"]
         STDOUT.sync = true unless log_file
         @error_logger = Logger.new(error_log_file || STDERR)
+        @error_logger.level = Logger.const_get(ENV["ECS_AUTO_SCALER_LOG_LEVEL"].upcase) if ENV["ECS_AUTO_SCALER_LOG_LEVEL"]
         STDERR.sync = true unless error_log_file
         load_config(yaml_path)
+        service_configs
+        auto_scaling_group_configs
 
-        until @stop
-          run_loop
+        config_groups = service_configs.group_by { |s| [s.region, s.auto_scaling_group_name] }
+        ths = config_groups.map do |(region, auto_scaling_group_name), configs|
+          asg_config = auto_scaling_group_configs.find { |c| c.name == auto_scaling_group_name && c.region == region }
+          Thread.new(asg_config, configs, &method(:main_loop))
         end
-      end
 
-      def stop
-        @stop = true
+        ths.each(&:join)
       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
+      def main_loop(asg_config, configs)
+        loop_with_polling_interval("loop of #{asg_config.name}") do
+          ths = configs.map do |service_config|
+            Thread.new(service_config) do |s|
+              next if s.idle?
 
-            if trigger.match?
-              logger.info "Fire upscale trigger of #{s.name} by #{trigger.alarm_name} #{trigger.state}"
-              difference = step
-            end
-          end
+              @logger.debug "Start service scaling of #{s.name}"
 
-          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}"
+              difference = 0
+              s.upscale_triggers.each do |trigger|
                 step = trigger.step || s.step
-                difference = [difference, -(step)].min
+                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
-            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.current_min_task_count
+                s.downscale_triggers.each do |trigger|
+                  next unless trigger.match?
 
-          if difference >= 0 && s.desired_count > s.max_task_count.max
-            difference = s.max_task_count.max - s.desired_count
-          end
+                  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
 
-          if difference != 0
-            s.update_service(s.desired_count + difference)
+              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(difference)
+              end
+            end
           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
+          ths.each(&:join)
 
-        TriggerConfig.clear_alarm_cache
+          @logger.debug "Start asg scaling of #{asg_config.name}"
 
-        sleep @polling_interval
+          total_service_count = configs.inject(0) { |sum, s| sum + s.desired_count }
+          asg_config.update_auto_scaling_group(total_service_count, configs[0])
+          asg_config.detach_and_terminate_orphan_instances(configs[0])
+        end
       end
 
       def load_config(yaml_path)
         @config = YAML.load_file(yaml_path)
-        @polling_interval = @config["polling_interval"]
+        @polling_interval = @config["polling_interval"] || 30
       end
 
       def service_configs
@@ -85,15 +94,32 @@ module EcsDeploy
       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 ||= {}
+      private
+
+      def wait_polling_interval?(last_executed_at)
+        current = Process.clock_gettime(Process::CLOCK_MONOTONIC, :second)
+        diff = current - last_executed_at
+        diff <= @polling_interval
+      end
+
+      def loop_with_polling_interval(name)
+        @logger.debug "Start #{name}"
+
+        last_executed_at = 0
+        loop do
+          break if @stop
+          sleep 1
+          next if wait_polling_interval?(last_executed_at)
+          yield
+          last_executed_at = Process.clock_gettime(Process::CLOCK_MONOTONIC, :second)
         end
+
+        @logger.debug "Stop #{name}"
       end
+    end
 
+    module ConfigBase
       def initialize(attributes = {})
         attributes.each do |key, val|
           send("#{key}=", val)
@@ -104,7 +130,6 @@ module EcsDeploy
     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)
@@ -123,16 +148,22 @@ module EcsDeploy
       end
 
       def client
-        self.class.client_table[region] ||= Aws::ECS::Client.new(
+        Thread.current["ecs_auto_scaler_ecs_#{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 clear_client
+        Thread.current["ecs_auto_scaler_ecs_#{region}"] = nil
+      end
+
       def idle?
         return false unless @last_updated_at
-        (Time.now - @last_updated_at) < idle_time
+
+        diff = Process.clock_gettime(Process::CLOCK_MONOTONIC, :second) - @last_updated_at
+        diff < idle_time
       end
 
       def current_min_task_count
@@ -147,7 +178,7 @@ module EcsDeploy
 
       def overheat?
         return false unless @reach_max_at
-        (Time.now - @reach_max_at) > cooldown_time_for_reach_max
+        (Process.clock_gettime(Process::CLOCK_MONOTONIC, :second) - @reach_max_at) > cooldown_time_for_reach_max
       end
 
       def fetch_service
@@ -156,10 +187,11 @@ module EcsDeploy
         res.services[0]
       rescue => e
         AutoScaler.error_logger.error(e)
-        self.class.client_table[region] = nil
+        clear_client
       end
 
-      def update_service(next_desired_count)
+      def update_service(difference)
+        next_desired_count = desired_count + difference
         current_level = max_task_level(desired_count)
         next_level = max_task_level(next_desired_count)
         if current_level < next_level && overheat? # next max
@@ -168,12 +200,14 @@ module EcsDeploy
           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"
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC, :second)
+          @reach_max_at ||= now
+          AutoScaler.logger.info "Service \"#{name}\" waits cooldown elapsed #{(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"
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC, :second)
+          @reach_max_at ||= now
+          AutoScaler.logger.info "Service \"#{name}\" waits cooldown elapsed #{(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
@@ -190,12 +224,38 @@ module EcsDeploy
           service: name,
           desired_count: next_desired_count,
         )
-        @last_updated_at = Time.now
+        client.wait_until(:services_stable, cluster: cluster, services: [name]) do |w|
+          w.before_wait do
+            AutoScaler.logger.debug "wait service stable [#{name}]"
+          end
+        end if difference < 0
+        @last_updated_at = Process.clock_gettime(Process::CLOCK_MONOTONIC, :second)
         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
+        clear_client
+      end
+
+      def fetch_container_instances
+        arns = []
+        resp = nil
+        loop do
+          options = {cluster: cluster}
+          options.merge(next_token: resp.next_token) if resp && resp.next_token
+          resp = client.list_container_instances(options)
+          arns.concat(resp.container_instance_arns)
+          break unless resp.next_token
+        end
+
+        chunk_size = 50
+        container_instances = []
+        arns.each_slice(chunk_size) do |arn_chunk|
+          is = client.describe_container_instances(cluster: cluster, container_instances: arn_chunk).container_instances
+          container_instances.concat(is)
+        end
+
+        container_instances
       end
 
       private
@@ -207,69 +267,156 @@ module EcsDeploy
 
     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(
+        Thread.current["ecs_auto_scaler_cloud_watch_#{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 clear_client
+        Thread.current["ecs_auto_scaler_cloud_watch_#{region}"] = nil
+      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
+          AutoScaler.logger.debug("#{alarm.alarm_name} state is #{alarm.state_value}")
         end
       rescue => e
         AutoScaler.error_logger.error(e)
-        self.class.client_table[region] = nil
+        clear_client
       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(
+        Thread.current["ecs_auto_scaler_auto_scaling_#{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)
+      def clear_client
+        Thread.current["ecs_auto_scaler_auto_scaling_#{region}"] = nil
+      end
+
+      def ec2_client
+        Thread.current["ecs_auto_scaler_ec2_#{region}"] ||= Aws::EC2::Client.new(
+          access_key_id: EcsDeploy.config.access_key_id,
+          secret_access_key: EcsDeploy.config.secret_access_key,
+          region: region
+        )
+      end
+
+      def clear_ec2_client
+        Thread.current["ecs_auto_scaler_ec2_#{region}"] = nil
+      end
+
+      def instances(reload: false)
+        if reload || @instances.nil?
+          resp = client.describe_auto_scaling_groups({
+            auto_scaling_group_names: [name],
+          })
+          @instances = resp.auto_scaling_groups[0].instances
+        else
+          @instances
+        end
+      end
+
+      def update_auto_scaling_group(total_service_count, service_config)
         desired_capacity = total_service_count + buffer.to_i
-        client.update_auto_scaling_group(
+
+        current_asg = client.describe_auto_scaling_groups({
+          auto_scaling_group_names: [name],
+        }).auto_scaling_groups[0]
+
+        if current_asg.desired_capacity > desired_capacity
+          diff = current_asg.desired_capacity - desired_capacity
+          container_instances = service_config.fetch_container_instances
+          deregisterable_instances = container_instances.select do |i|
+            i.pending_tasks_count == 0 && i.running_tasks_count == 0
+          end
+
+          AutoScaler.logger.info "Fetch deregisterable instances: #{deregisterable_instances.map(&:ec2_instance_id).inspect}"
+
+          deregistered_instance_ids = []
+          deregisterable_instances.each do |i|
+            break if deregistered_instance_ids.size >= diff
+
+            begin
+              service_config.client.deregister_container_instance(cluster: service_config.cluster, container_instance: i.container_instance_arn, force: false)
+              deregistered_instance_ids << i.ec2_instance_id
+            rescue Aws::ECS::Errors::InvalidParameterException
+            end
+          end
+
+          AutoScaler.logger.info "Deregistered instances: #{deregistered_instance_ids.inspect}"
+
+          detach_and_terminate_instances(deregistered_instance_ids)
+
+          AutoScaler.logger.info "Update auto scaling group \"#{name}\": desired_capacity -> #{desired_capacity}"
+        elsif current_asg.desired_capacity < desired_capacity
+          client.update_auto_scaling_group(
+            auto_scaling_group_name: name,
+            min_size: 0,
+            max_size: [current_asg.max_size, desired_capacity].max,
+            desired_capacity: desired_capacity,
+          )
+          AutoScaler.logger.info "Update auto scaling group \"#{name}\": desired_capacity -> #{desired_capacity}"
+        end
+      rescue => e
+        AutoScaler.error_logger.error(e)
+        clear_client
+      end
+
+      def detach_and_terminate_instances(instance_ids)
+        return if instance_ids.empty?
+
+        client.detach_instances(
           auto_scaling_group_name: name,
-          min_size: desired_capacity,
-          max_size: desired_capacity,
-          desired_capacity: desired_capacity,
+          instance_ids: instance_ids,
+          should_decrement_desired_capacity: true
         )
-        AutoScaler.logger.info "Update auto scaling group \"#{name}\": desired_capacity -> #{desired_capacity}"
+
+        AutoScaler.logger.info "Detach instances from ASG #{name}: #{instance_ids.inspect}"
+        sleep 3
+
+        ec2_client.terminate_instances(instance_ids: instance_ids)
+
+        AutoScaler.logger.info "Terminated instances: #{instance_ids.inspect}"
+      rescue => e
+        AutoScaler.error_logger.error(e)
+        clear_client
+        clear_ec2_client
+      end
+
+      def detach_and_terminate_orphan_instances(service_config)
+        container_instance_ids = service_config.fetch_container_instances.map(&:ec2_instance_id)
+        orphans = instances(reload: true).reject { |i| container_instance_ids.include?(i.instance_id) }.map(&:instance_id)
+
+        return if orphans.empty?
+
+        targets = ec2_client.describe_instances(instance_ids: orphans).reservations[0].instances.select do |i|
+          (Time.now - i.launch_time) > 600
+        end
+
+        detach_and_terminate_instances(targets.map(&:instance_id))
       rescue => e
         AutoScaler.error_logger.error(e)
-        self.class.client_table[region] = nil
+        clear_client
+        clear_ec2_client
       end
     end
   end

data/lib/ecs_deploy/capistrano.rb

@@ -27,6 +27,7 @@ namespace :ecs do
             region: r,
             task_definition_name: t[:name],
             container_definitions: t[:container_definitions],
+            task_role_arn: t[:task_role_arn],
             volumes: t[:volumes]
           )
           task_definition.register
@@ -58,10 +59,7 @@ namespace :ecs do
             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],
+            load_balancers: service[:load_balancers],
             desired_count: service[:desired_count],
           }
           service_options[:deployment_configuration] = service[:deployment_configuration] if service[:deployment_configuration]
@@ -121,10 +119,7 @@ namespace :ecs do
             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],
+            load_balancers: service[:load_balancers],
             desired_count: service[:desired_count],
           }
           service_options[:deployment_configuration] = service[:deployment_configuration] if service[:deployment_configuration]

data/lib/ecs_deploy/service.rb

@@ -7,17 +7,14 @@ module EcsDeploy
 
     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,
+      load_balancers: 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
+      @load_balancers = load_balancers
       @desired_count = desired_count
       @deployment_configuration = deployment_configuration
       @revision = revision
@@ -44,16 +41,10 @@ module EcsDeploy
           service_name: @service_name,
           desired_count: @desired_count.to_i,
         })
-        if @elb_name
+        if @load_balancers
           service_options.merge!({
             role: EcsDeploy.config.ecs_service_role,
-            load_balancers: [
-              {
-                load_balancer_name: @elb_name,
-                container_name: @elb_container_name,
-                container_port: @elb_service_port,
-              }
-            ],
+            load_balancers: @load_balancers,
           })
         end
         @response = @client.create_service(service_options)
@@ -70,7 +61,6 @@ module EcsDeploy
       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

data/lib/ecs_deploy/task_definition.rb

@@ -11,9 +11,11 @@ module EcsDeploy
 
     def initialize(
       task_definition_name:, region: nil,
-      volumes: [], container_definitions: []
+      volumes: [], container_definitions: [],
+      task_role_arn: nil
     )
       @task_definition_name = task_definition_name
+      @task_role_arn        = task_role_arn
       @region = region || EcsDeploy.config.default_region || ENV["AWS_DEFAULT_REGION"]
 
       @container_definitions = container_definitions.map do |cd|
@@ -45,6 +47,7 @@ module EcsDeploy
         family: @task_definition_name,
         container_definitions: @container_definitions,
         volumes: @volumes,
+        task_role_arn: @task_role_arn,
       })
       EcsDeploy.logger.info "register task definition [#{@task_definition_name}] [#{@region}] [#{Paint['OK', :green]}]"
     end

data/lib/ecs_deploy/version.rb

@@ -1,3 +1,3 @@
 module EcsDeploy
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/lib/ecs_deploy.rb

@@ -1,6 +1,7 @@
 require "ecs_deploy/version"
 require "ecs_deploy/configuration"
 
+require 'aws-sdk'
 require 'logger'
 require 'terminal-table'
 require 'paint'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ecs_deploy
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - joker1007
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-07-28 00:00:00.000000000 Z
+date: 2016-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '2.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '2.4'
 - !ruby/object:Gem::Dependency
   name: terminal-table
   requirement: !ruby/object:Gem::Requirement