ecs_deploy 1.0.7 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 932b0b421b5a352c6f5fd2a3f110baf393c6d0667fa951abfeeb97a0badbe074
-  data.tar.gz: 53ddcbcea0662a0e154192be3e71c5161309ba042146e81f9a5f29794e25988f
+  metadata.gz: 7ada66f2f084f7ea0e30b0b6808d2635480db1071ae13acfc16f6f7d4cc02fef
+  data.tar.gz: 2188aa1ed3727d1c7719bca93006383b831a6f6379ffa28b08aee8a97d5281e5
 SHA512:
-  metadata.gz: 88a77e68a9ef43fe818fe529af5f75b1dfaa4b9ccf0505fabe1c185f67eb051f041b6720239bda895fd812125aa960728585aff85f149b99a30331e16c47cef7
-  data.tar.gz: 4dd7312beb91fc54635d79e44b8795c00866085d3b117f8583fb5c082970dc521fd53423ef3aa5c2c942d5adf6656296034b1952cb32e5b55087d8102173e79e
+  metadata.gz: a3e3f662af6586e71f002853a3599adb107c7db5b8b44c4d7ce3d8d13c6d37ae2210ec9a0a0749813e926f78c4879a3a72d851f6dfd2c466e8ec296a9900f244
+  data.tar.gz: f96818f250b0644a3908822fa741b26bba564095feff3d78e9a28acc30baa9da5b435200d3c2bc83edf4a2e3e7b73e48e5702ade9f1f3ac7c614be1a9402a067

data/.github/workflows/test.yml

@@ -6,18 +6,17 @@ on:
 
 jobs:
   test:
-
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['2.5', '2.6', '2.7', '3.0', '3.1', '3.2']
+        ruby-version: ["3.2", "3.3", "3.4", "4.0"]
 
     steps:
-    - uses: actions/checkout@v3
-    - name: Set up Ruby
-      uses: ruby/setup-ruby@v1
-      with:
-        ruby-version: ${{ matrix.ruby-version }}
-        bundler-cache: true
-    - name: Run tests
-      run: bundle exec rake
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@0dafeac902942906541bc140009cdbf32665b601 # v1.315.0
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+      - name: Run tests
+        run: bundle exec rake

data/.gitignore

@@ -10,3 +10,5 @@
 
 .rspec_status
 .envrc
+
+.claude/settings.local.json

data/.rspec

@@ -0,0 +1 @@
+--format d

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+# v1.1
+
+## Unreleased
+
+### New feature
+
+- Add `ecs:describe_deployment`, `ecs:continue_deployment[hook_id]`, `ecs:rollback_deployment[hook_id]`, `ecs:stop_deployment[service_deployment_arn]` capistrano tasks for operating ECS-managed blue/green deployments (lifecycle hook approval / rollback / abort).
+
+### Breaking change
+
+- `ecs:deploy` capistrano task now passes the entire service hash through to `EcsDeploy::Service.new` instead of forwarding an explicit allow-list of keys. New SDK fields (e.g. `deployment_controller`, `platform_version`, `service_connect_configuration`, `volume_configurations`, `availability_zone_rebalancing`, `load_balancers[].advanced_configuration`) are supported automatically without gem updates. Any custom non-SDK keys previously placed in `set :ecs_services` entries will now reach the SDK and may cause errors — remove or rename them.
+
+### Enhancement
+
+- Add `wait_strategy` option to `EcsDeploy::Service` for ECS-managed blue/green deployments (`DeploymentController.Type=ECS` with `BLUE_GREEN`/`LINEAR`/`CANARY`). `wait_all_running` now auto-detects ECS-managed deployments and skips polling so Capistrano sessions do not block on multi-day Pause Hooks.
+- `EcsDeploy::Service#update_service` now forwards every field accepted by `Aws::ECS::Client#update_service` (aws-sdk-ecs 1.238+), including fields added after this gem release. Options that ECS cannot apply on an existing service (`launch_type`, `scheduling_strategy`, `role`, `client_token`, `deployment_controller`) are detected and logged as warnings when the user's value differs from the current service. `desired_count: 0` and `propagate_tags: "NONE"` are now honored (previously silently dropped by a truthiness check).
+- Bump minimum `aws-sdk-ecs` to `1.238` for `continue_service_deployment`, `stop_service_deployment`, `LINEAR`/`CANARY` strategy, `lifecycle_hooks`, and `LoadBalancer.advanced_configuration`.
+
 # v1.0
 
 ## Release v1.0.7 - 2024/08/08

data/README.md

@@ -186,6 +186,75 @@ And rollback
 | 6        | myapp:15 | myapp-service | deregister |
 | 7        | myapp:12 | myapp-service | current    |
 
+## Native Blue/Green Deployment (ECS-managed)
+
+`ecs_deploy` supports ECS-managed blue/green deployments where ECS itself drives the rollout (no CodeDeploy required). Set `deployment_controller`, `deployment_configuration`, lifecycle hooks, and `load_balancers[].advanced_configuration` directly on the service entry. The Capistrano `ecs:deploy` task forwards the entire hash through to `EcsDeploy::Service.new` and then to `Aws::ECS::Client#create_service` / `#update_service`, so any new SDK field is supported automatically.
+
+When updating an existing service, `EcsDeploy::Service` forwards every field accepted by `Aws::ECS::Client#update_service`, including `deployment_configuration` and `load_balancers[].advanced_configuration`. Options that ECS treats as create-only (`launch_type`, `scheduling_strategy`, `role`, `client_token`, `deployment_controller`) are skipped and, if their value differs from the current service, logged as a warning. Unknown keys are forwarded verbatim and will surface as SDK errors — this is intentional so new SDK fields work without gem updates.
+
+```ruby
+set :ecs_services, [
+  {
+    name: "myapp-#{fetch(:rails_env)}",
+    cluster: "myapp-cluster",
+    task_definition_name: "myapp-#{fetch(:rails_env)}",
+    launch_type: "FARGATE",
+    platform_version: "LATEST",
+    desired_count: 1,
+    network_configuration: { awsvpc_configuration: { subnets: %w[subnet-...], security_groups: %w[sg-...], assign_public_ip: "DISABLED" } },
+    deployment_controller: { type: "ECS" },
+    deployment_configuration: {
+      strategy: "LINEAR",
+      linear_configuration: { step_percent: 50.0, step_bake_time_in_minutes: 60 },
+      bake_time_in_minutes: 5,
+      deployment_circuit_breaker: { enable: true, rollback: true },
+      lifecycle_hooks: [
+        {
+          hook_target_arn: "arn:aws:lambda:ap-northeast-1:<account-id>:function:my-pause-hook",
+          role_arn: "arn:aws:iam::<account-id>:role/ecsLifecycleHookRole",
+          lifecycle_stages: ["POST_TEST_TRAFFIC_SHIFT"],
+        },
+      ],
+    },
+    load_balancers: [{
+      target_group_arn: "arn:aws:elasticloadbalancing:...:targetgroup/blue/...",
+      container_name: "app",
+      container_port: 8080,
+      advanced_configuration: {
+        alternate_target_group_arn: "arn:aws:elasticloadbalancing:...:targetgroup/green/...",
+        production_listener_rule: "arn:aws:elasticloadbalancing:...:listener-rule/...", # for NLB, pass the Listener ARN directly
+        test_listener_rule: "arn:aws:elasticloadbalancing:...:listener-rule/...",
+        role_arn: "arn:aws:iam::<account-id>:role/ecsInfrastructureRole",
+      },
+    }],
+    health_check_grace_period_seconds: 300,
+
+    # gem-internal option (not sent to the SDK):
+    wait_strategy: :none, # default for ECS-managed deployments is auto-detected as :none
+  },
+]
+```
+
+| option | values | purpose |
+|--------|--------|---------|
+| `wait_strategy:` | `nil` (auto), `:legacy`, `:none`, `:service_deployment` | `nil` auto-detects ECS-managed deployments and skips waiting (multi-day Pause Hooks make blocking impractical). `:legacy` matches pre-1.1 behavior. `:service_deployment` polls `list_service_deployments` (not recommended for sessions). |
+
+### Operational tasks
+
+```sh
+bundle exec cap <stage> ecs:describe_deployment              # list in-flight deployments with lifecycle hook details
+bundle exec cap <stage> ecs:continue_deployment[hook-id]     # approve a paused lifecycle hook
+bundle exec cap <stage> ecs:rollback_deployment[hook-id]     # reject a paused lifecycle hook (ECS rolls back)
+bundle exec cap <stage> ecs:stop_deployment[arn]             # stop an in-progress deployment; STOP_TYPE=ABORT or ROLLBACK
+```
+
+### Caveats
+
+- `deployment_controller` is immutable on an existing service. To switch an existing `CODE_DEPLOY` service to `ECS`, delete and re-create the service.
+- The PAUSE lifecycle hook stages `TEST_TRAFFIC_SHIFT` and `PRODUCTION_TRAFFIC_SHIFT` are rejected by AWS (those stages are also entered during rollback). Use `PRE_*`/`POST_*` variants instead.
+- For NLB, `advanced_configuration.production_listener_rule` should hold the Listener ARN directly (NLBs do not have Listener Rules).
+- Pre-1.1 versions filtered the `set :ecs_services` hash to an allow-list of keys before calling `EcsDeploy::Service.new`. Starting with 1.1, the entire hash is forwarded. Any custom non-SDK keys previously placed there must be removed or renamed; otherwise the SDK will raise.
+
 ## Autoscaler
 
 The autoscaler of `ecs_deploy` supports auto scaling of ECS services and clusters.

data/ecs_deploy.gemspec

@@ -22,12 +22,12 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "aws-sdk-cloudwatch", "~> 1"
   spec.add_runtime_dependency "aws-sdk-cloudwatchevents", "~> 1"
   spec.add_runtime_dependency "aws-sdk-ec2", "~> 1"
-  spec.add_runtime_dependency "aws-sdk-ecs", "~> 1"
+  spec.add_runtime_dependency "aws-sdk-ecs", ">= 1.238", "< 2"
   spec.add_runtime_dependency "aws-sdk-sqs", "~> 1"
   spec.add_runtime_dependency "terminal-table"
   spec.add_runtime_dependency "paint"
 
-  spec.add_development_dependency "bundler", ">= 1.11", "< 3"
+  spec.add_development_dependency "bundler", ">= 1.11"
   spec.add_development_dependency "rake", ">= 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rexml" # For aws-sdk-*

data/lib/ecs_deploy/auto_scaler/null_cluster_resource_manager.rb

@@ -0,0 +1,13 @@
+module EcsDeploy
+  module AutoScaler
+    class NullClusterResourceManager
+      def acquire(capacity, timeout: nil)
+        true
+      end
+
+      def release(capacity)
+        true
+      end
+    end
+  end
+end

data/lib/ecs_deploy/auto_scaler/simple_scaling_config.rb

@@ -0,0 +1,33 @@
+require "ecs_deploy/auto_scaler/config_base"
+require "ecs_deploy/auto_scaler/null_cluster_resource_manager"
+
+module EcsDeploy
+  module AutoScaler
+    SimpleScalingConfig = Struct.new(:name, :region, :cluster, :service_configs) do
+      include ConfigBase
+
+      def initialize(attributes = {}, logger)
+        attributes = attributes.dup
+        services = attributes.delete("services")
+        super(attributes, logger)
+        self.service_configs = services.map do |s|
+          ServiceConfig.new(s.merge("cluster" => cluster, "region" => region), logger)
+        end
+      end
+
+      def update_desired_capacity(required_capacity)
+        @logger.debug "#{log_prefix} Skipping infrastructure scaling (managed by capacity provider)"
+      end
+
+      def cluster_resource_manager
+        @cluster_resource_manager ||= NullClusterResourceManager.new
+      end
+
+      private
+
+      def log_prefix
+        "[#{self.class.to_s.sub(/\AEcsDeploy::AutoScaler::/, "")} #{name} #{region}]"
+      end
+    end
+  end
+end

data/lib/ecs_deploy/auto_scaler.rb

@@ -5,6 +5,7 @@ require "yaml"
 require "ecs_deploy/auto_scaler/auto_scaling_group_config"
 require "ecs_deploy/auto_scaler/instance_drainer"
 require "ecs_deploy/auto_scaler/service_config"
+require "ecs_deploy/auto_scaler/simple_scaling_config"
 require "ecs_deploy/auto_scaler/spot_fleet_request_config"
 
 module EcsDeploy
@@ -23,7 +24,7 @@ module EcsDeploy
         STDERR.sync = true unless error_log_file
         load_config(yaml_path)
 
-        ths = (auto_scaling_group_configs + spot_fleet_request_configs).map do |cluster_scaling_config|
+        ths = (auto_scaling_group_configs + spot_fleet_request_configs + simple_scaling_configs).map do |cluster_scaling_config|
           Thread.new(cluster_scaling_config, &method(:main_loop)).tap { |th| th.abort_on_exception = true }
         end
 
@@ -117,6 +118,16 @@ module EcsDeploy
         end.values.flat_map(&:values)
       end
 
+      def simple_scaling_configs
+        @simple_scaling_configs ||= (@config["simple_scaling"] || []).each.with_object({}) do |c, configs|
+          configs[c["name"]] ||= {}
+          if configs[c["name"]][c["region"]]
+            raise "Duplicate entry in simple_scaling (name: #{c["name"]}, region: #{c["region"]})"
+          end
+          configs[c["name"]][c["region"]] = SimpleScalingConfig.new(c, @logger)
+        end.values.flat_map(&:values)
+      end
+
       private
 
       def setup_signal_handlers

data/lib/ecs_deploy/capistrano.rb

@@ -96,36 +96,72 @@ namespace :ecs do
             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],
-            load_balancers: service[:load_balancers],
-            desired_count: service[:desired_count],
-            launch_type: service[:launch_type],
-            network_configuration: service[:network_configuration],
-            health_check_grace_period_seconds: service[:health_check_grace_period_seconds],
-            delete: service[:delete],
-            enable_ecs_managed_tags: service[:enable_ecs_managed_tags],
-            tags: service[:tags],
-            propagate_tags: service[:propagate_tags],
-            enable_execute_command: service[:enable_execute_command],
-          }
-          service_options[:deployment_configuration] = service[:deployment_configuration] if service[:deployment_configuration]
-          service_options[:placement_constraints] = service[:placement_constraints] if service[:placement_constraints]
-          service_options[:placement_strategy] = service[:placement_strategy] if service[:placement_strategy]
-          service_options[:capacity_provider_strategy] = service[:capacity_provider_strategy] if service[:capacity_provider_strategy]
-          service_options[:scheduling_strategy] = service[:scheduling_strategy] if service[:scheduling_strategy]
+          service_options = service.dup
+          service_options[:service_name] = service_options.delete(:name) if service_options.key?(:name)
+          service_options[:cluster] ||= fetch(:ecs_default_cluster)
+          service_options[:region] = r
+
           s = EcsDeploy::Service.new(**service_options)
           s.deploy
           s
-        end
+        end.compact
         EcsDeploy::Service.wait_all_running(services)
       end
     end
   end
 
+  desc "Describe in-flight ECS service deployments for services in :ecs_services"
+  task describe_deployment: [:configure] do
+    if fetch(:ecs_services)
+      regions = Array(fetch(:ecs_region))
+      regions = [EcsDeploy.config.default_region] if regions.empty?
+      EcsDeploy::ServiceDeployment.describe(
+        services: fetch(:ecs_services),
+        regions: regions,
+        default_cluster: fetch(:ecs_default_cluster),
+      )
+    end
+  end
+
+  desc "Continue an ECS service deployment paused at a lifecycle hook"
+  task :continue_deployment, [:hook_id] => [:configure] do |_t, args|
+    raise "hook_id is required: cap ... ecs:continue_deployment[hook_id]" unless args[:hook_id]
+    regions = Array(fetch(:ecs_region))
+    regions = [EcsDeploy.config.default_region] if regions.empty?
+    EcsDeploy::ServiceDeployment.invoke_lifecycle_hook(
+      hook_id: args[:hook_id],
+      action: "CONTINUE",
+      services: fetch(:ecs_services),
+      regions: regions,
+      default_cluster: fetch(:ecs_default_cluster),
+    )
+  end
+
+  desc "Roll back an ECS service deployment paused at a lifecycle hook"
+  task :rollback_deployment, [:hook_id] => [:configure] do |_t, args|
+    raise "hook_id is required: cap ... ecs:rollback_deployment[hook_id]" unless args[:hook_id]
+    regions = Array(fetch(:ecs_region))
+    regions = [EcsDeploy.config.default_region] if regions.empty?
+    EcsDeploy::ServiceDeployment.invoke_lifecycle_hook(
+      hook_id: args[:hook_id],
+      action: "ROLLBACK",
+      services: fetch(:ecs_services),
+      regions: regions,
+      default_cluster: fetch(:ecs_default_cluster),
+    )
+  end
+
+  desc "Stop an in-progress ECS service deployment (STOP_TYPE env: ABORT or ROLLBACK)"
+  task :stop_deployment, [:service_deployment_arn] => [:configure] do |_t, args|
+    raise "service_deployment_arn is required: cap ... ecs:stop_deployment[arn]" unless args[:service_deployment_arn]
+    region = Array(fetch(:ecs_region)).first || EcsDeploy.config.default_region
+    EcsDeploy::ServiceDeployment.stop(
+      service_deployment_arn: args[:service_deployment_arn],
+      region: region,
+      stop_type: ENV["STOP_TYPE"],
+    )
+  end
+
   task rollback: [:configure] do
     if fetch(:ecs_services)
       regions = Array(fetch(:ecs_region))

data/lib/ecs_deploy/scheduled_task.rb

@@ -7,28 +7,21 @@ module EcsDeploy
 
     attr_reader :cluster, :region, :schedule_rule_name
 
-    def initialize(
-      cluster:, rule_name:, schedule_expression:, enabled: true, description: nil, target_id: nil,
-      task_definition_name:, revision: nil, task_count: nil, role_arn:, network_configuration: nil, launch_type: nil, platform_version: nil, group: nil,
-      region: nil, container_overrides: nil
-    )
+    def initialize(cluster:, rule_name:, schedule_expression:, task_definition_name:, role_arn:, region: nil, **options)
       @cluster = cluster
       @rule_name = rule_name
       @schedule_expression = schedule_expression
-      @enabled = enabled
-      @description = description
-      @target_id = target_id || task_definition_name
       @task_definition_name = task_definition_name
-      @task_count = task_count || 1
-      @revision = revision
       @role_arn = role_arn
-      @network_configuration = network_configuration
-      @launch_type = launch_type || "EC2"
-      @platform_version = platform_version
-      @group = group
+
+      @options = options.dup
+      @options[:enabled] = @options.fetch(:enabled, true)
+      @options[:target_id] ||= task_definition_name
+      @options[:task_count] ||= 1
+      @options[:launch_type] ||= "EC2"
+
       region ||= EcsDeploy.config.default_region
       params ||= EcsDeploy.config.ecs_client_params
-      @container_overrides = container_overrides
 
       @client = region ? Aws::ECS::Client.new(params.merge(region: region)) : Aws::ECS::Client.new(params)
       @region = @client.config.region
@@ -50,7 +43,7 @@ module EcsDeploy
     end
 
     def task_definition_arn
-      suffix = @revision ? ":#{@revision}" : ""
+      suffix = @options[:revision] ? ":#{@options[:revision]}" : ""
       name = "#{@task_definition_name}#{suffix}"
       @client.describe_task_definition(task_definition: name).task_definition.task_definition_arn
     end
@@ -59,30 +52,25 @@ module EcsDeploy
       res = @cloud_watch_events.put_rule(
         name: @rule_name,
         schedule_expression: @schedule_expression,
-        state: @enabled ? "ENABLED" : "DISABLED",
-        description: @description,
+        state: @options[:enabled] ? "ENABLED" : "DISABLED",
+        description: @options[:description],
       )
       EcsDeploy.logger.info "created cloudwatch event rule [#{res.rule_arn}] [#{@region}] [#{Paint['OK', :green]}]"
     end
 
     def put_targets
       target = {
-        id: @target_id,
+        id: @options[:target_id],
         arn: cluster_arn,
         role_arn: @role_arn,
-        ecs_parameters: {
+        ecs_parameters: @options.except(:enabled, :description, :target_id, :revision, :container_overrides).merge(
           task_definition_arn: task_definition_arn,
-          task_count: @task_count,
-          network_configuration: @network_configuration,
-          launch_type: @launch_type,
-          platform_version: @platform_version,
-          group: @group,
-        },
+        ),
       }
       target[:ecs_parameters].compact!
 
-      if @container_overrides
-        target.merge!(input: { containerOverrides: @container_overrides }.to_json)
+      if @options[:container_overrides]
+        target.merge!(input: { containerOverrides: @options[:container_overrides] }.to_json)
       end
 
       res = @cloud_watch_events.put_targets(
@@ -90,7 +78,7 @@ module EcsDeploy
         targets: [target]
       )
       if res.failed_entry_count.zero?
-        EcsDeploy.logger.info "created cloudwatch event target [#{@target_id}] [#{@region}] [#{Paint['OK', :green]}]"
+        EcsDeploy.logger.info "created cloudwatch event target [#{@options[:target_id]}] [#{@region}] [#{Paint['OK', :green]}]"
       else
         res.failed_entries.each do |entry|
           EcsDeploy.logger.error "failed to create cloudwatch event target [#{@region}] target_id=#{entry.target_id} error_code=#{entry.error_code} error_message=#{entry.error_message}"

data/lib/ecs_deploy/service.rb

@@ -7,44 +7,38 @@ module EcsDeploy
 
     class TooManyAttemptsError < StandardError; end
 
-    attr_reader :cluster, :region, :service_name, :delete, :deploy_started_at
-
-    def initialize(
-      cluster:, service_name:, task_definition_name: nil, revision: nil,
-      load_balancers: nil,
-      desired_count: nil, deployment_configuration: {maximum_percent: 200, minimum_healthy_percent: 100},
-      launch_type: nil,
-      placement_constraints: [],
-      placement_strategy: [],
-      capacity_provider_strategy: nil,
-      network_configuration: nil,
-      health_check_grace_period_seconds: nil,
-      scheduling_strategy: 'REPLICA',
-      enable_ecs_managed_tags: nil,
-      tags: nil,
-      propagate_tags: nil,
-      region: nil,
-      delete: false,
-      enable_execute_command: false
-    )
+    attr_reader :cluster, :region, :service_name, :delete, :deploy_started_at, :wait_strategy
+
+    # Options that Aws::ECS::Client#update_service will not honor on an existing
+    # service:
+    # - launch_type / scheduling_strategy: not in update_service's parameter list
+    # - role / client_token: create-only, no update-side equivalent
+    # - deployment_controller: accepted by update_service in aws-sdk-ecs 1.238+
+    #   but AWS rejects any change to the controller type at runtime
+    CREATE_ONLY_KEYS = %i[launch_type scheduling_strategy role client_token deployment_controller].freeze
+
+    VALID_WAIT_STRATEGIES = %i[legacy none service_deployment].freeze
+    ECS_NATIVE_BLUE_GREEN_STRATEGIES = %w[BLUE_GREEN LINEAR CANARY].freeze
+
+    def initialize(cluster:, service_name:, region: nil, **options)
       @cluster = cluster
       @service_name = service_name
-      @task_definition_name = task_definition_name || service_name
-      @load_balancers = load_balancers
-      @desired_count = desired_count
-      @deployment_configuration = deployment_configuration
-      @launch_type = launch_type
-      @placement_constraints = placement_constraints
-      @placement_strategy = placement_strategy
-      @capacity_provider_strategy = capacity_provider_strategy
-      @network_configuration = network_configuration
-      @health_check_grace_period_seconds = health_check_grace_period_seconds
-      @scheduling_strategy = scheduling_strategy
-      @revision = revision
-      @enable_ecs_managed_tags = enable_ecs_managed_tags
-      @tags = tags
-      @propagate_tags = propagate_tags
-      @enable_execute_command = enable_execute_command
+      @options = options.dup
+      @task_definition_name = @options.delete(:task_definition_name) || service_name
+      @revision = @options.delete(:revision)
+      @delete = @options.delete(:delete) || false
+      @wait_strategy = @options.delete(:wait_strategy)
+      # Snapshot the keys the user actually passed in, so warnings only fire on
+      # options the caller explicitly set (not on defaults injected below).
+      @user_provided_keys = (options.keys - %i[task_definition_name revision delete wait_strategy]).freeze
+      if @wait_strategy && !VALID_WAIT_STRATEGIES.include?(@wait_strategy)
+        raise ArgumentError, "Invalid wait_strategy #{@wait_strategy.inspect}, expected nil or one of #{VALID_WAIT_STRATEGIES.inspect}"
+      end
+      @options[:deployment_configuration] ||= {maximum_percent: 200, minimum_healthy_percent: 100}
+      @options[:placement_constraints] ||= []
+      @options[:placement_strategy] ||= []
+      @options[:scheduling_strategy] ||= 'REPLICA'
+      @options[:enable_execute_command] ||= false
 
       @response = nil
 
@@ -52,8 +46,6 @@ module EcsDeploy
       params ||= EcsDeploy.config.ecs_client_params
       @client = region ? Aws::ECS::Client.new(params.merge(region: region)) : Aws::ECS::Client.new(params)
       @region = @client.config.region
-
-      @delete = delete
     end
 
     def current_task_definition_arn
@@ -64,75 +56,100 @@ module EcsDeploy
     def deploy
       @deploy_started_at = Time.now
       res = @client.describe_services(cluster: @cluster, services: [@service_name])
-      service_options = {
+
+      if res.services.select{ |s| s.status == 'ACTIVE' }.empty?
+        return if @delete
+        create_service
+      else
+        return delete_service if @delete
+        update_service(res.services[0])
+      end
+    end
+
+    private def create_service
+      service_options = @options.merge(
         cluster: @cluster,
+        service_name: @service_name,
         task_definition: task_definition_name_with_revision,
-        deployment_configuration: @deployment_configuration,
-        network_configuration: @network_configuration,
-        health_check_grace_period_seconds: @health_check_grace_period_seconds,
-        capacity_provider_strategy: @capacity_provider_strategy,
-        enable_execute_command: @enable_execute_command,
-        enable_ecs_managed_tags: @enable_ecs_managed_tags,
-        placement_constraints: @placement_constraints,
-        placement_strategy: @placement_strategy,
-      }
+      )
+      service_options[:desired_count] = service_options[:desired_count].to_i
 
-      if @load_balancers && EcsDeploy.config.ecs_service_role
-        service_options.merge!({
-          role: EcsDeploy.config.ecs_service_role,
-        })
+      if service_options[:load_balancers] && EcsDeploy.config.ecs_service_role
+        service_options[:role] = EcsDeploy.config.ecs_service_role
       end
 
-      if @load_balancers
-        service_options.merge!({
-          load_balancers: @load_balancers,
-        })
+      if service_options[:scheduling_strategy] == 'DAEMON'
+        service_options.delete(:desired_count)
+        service_options.delete(:placement_strategy)
       end
 
-      if res.services.select{ |s| s.status == 'ACTIVE' }.empty?
-        return if @delete
+      @response = @client.create_service(service_options)
+      EcsDeploy.logger.info "created service [#{@service_name}] [#{@cluster}] [#{@region}] [#{Paint['OK', :green]}]"
+    end
 
-        service_options.merge!({
-          service_name: @service_name,
-          desired_count: @desired_count.to_i,
-          launch_type: @launch_type,
-          tags: @tags,
-          propagate_tags: @propagate_tags,
-        })
-
-        if @scheduling_strategy == 'DAEMON'
-          service_options[:scheduling_strategy] = @scheduling_strategy
-          service_options.delete(:desired_count)
-          service_options.delete(:placement_strategy)
-        end
-        @response = @client.create_service(service_options)
-        EcsDeploy.logger.info "created service [#{@service_name}] [#{@cluster}] [#{@region}] [#{Paint['OK', :green]}]"
-      else
-        return delete_service if @delete
+    private def update_service(current_service)
+      warn_on_ignored_options(current_service)
 
-        service_options.merge!({service: @service_name})
-        service_options.merge!({desired_count: @desired_count}) if @desired_count
-        service_options.merge!({propagate_tags: @propagate_tags}) if @propagate_tags
+      service_options = @options.except(*CREATE_ONLY_KEYS, :tags).merge(
+        cluster: @cluster,
+        service: @service_name,
+        task_definition: task_definition_name_with_revision,
+      )
+      # If the user did not set these explicitly, leave them out so ECS keeps
+      # its current values (desired_count is often managed by autoscaling;
+      # propagate_tags reflects an existing policy).
+      service_options.delete(:desired_count)  unless @options.key?(:desired_count)
+      service_options.delete(:propagate_tags) unless @options.key?(:propagate_tags)
+      service_options[:force_new_deployment] = true if need_force_new_deployment?(current_service)
+      service_options.delete(:placement_strategy) if @options[:scheduling_strategy] == 'DAEMON'
 
-        current_service = res.services[0]
-        service_options.merge!({force_new_deployment: true}) if need_force_new_deployment?(current_service)
+      update_tags(@service_name, @options[:tags])
 
-        update_tags(@service_name, @tags)
-        if @scheduling_strategy == 'DAEMON'
-          service_options.delete(:placement_strategy)
-        end
-        @response = @client.update_service(service_options)
-        EcsDeploy.logger.info "updated service [#{@service_name}] [#{@cluster}] [#{@region}] [#{Paint['OK', :green]}]"
+      @response = @client.update_service(service_options)
+      EcsDeploy.logger.info "updated service [#{@service_name}] [#{@cluster}] [#{@region}] [#{Paint['OK', :green]}]"
+    end
+
+    # Log a warning for user-supplied options that update_service cannot apply.
+    # Silently drop keys whose value matches the current service (harmless
+    # re-declaration of the current state); warn only when the user's value
+    # would actually change something.
+    private def warn_on_ignored_options(current_service)
+      CREATE_ONLY_KEYS.each do |key|
+        next unless @user_provided_keys.include?(key)
+        next if create_only_matches_current?(key, current_service)
+        EcsDeploy.logger.warn "[#{@service_name}] option #{key.inspect} cannot be applied by update_service (current: #{create_only_current_display(current_service, key).inspect}, requested: #{@options[key].inspect}), skipping"
+      end
+    end
+
+    private def create_only_matches_current?(key, current_service)
+      case key
+      when :launch_type
+        @options[key].to_s == current_service.launch_type.to_s
+      when :scheduling_strategy
+        @options[key].to_s == current_service.scheduling_strategy.to_s
+      when :deployment_controller
+        Hash(@options[key])[:type].to_s == current_service.deployment_controller&.type.to_s
+      else
+        # role / client_token have no meaningful "current" comparison; always warn.
+        false
+      end
+    end
+
+    private def create_only_current_display(current_service, key)
+      case key
+      when :launch_type          then current_service.launch_type
+      when :scheduling_strategy  then current_service.scheduling_strategy
+      when :deployment_controller then current_service.deployment_controller&.type
       end
     end
 
     private def need_force_new_deployment?(service)
-      return false unless @capacity_provider_strategy
+      return false unless @options[:capacity_provider_strategy]
       return true unless service.capacity_provider_strategy
 
-      return true if @capacity_provider_strategy.size != service.capacity_provider_strategy.size
+      return true if @options[:capacity_provider_strategy].size != service.capacity_provider_strategy.size
 
-      match_array = @capacity_provider_strategy.all? do |strategy|
+      match_array = @options[:capacity_provider_strategy].all? do |strategy|
         service.capacity_provider_strategy.find do |current_strategy|
           strategy[:capacity_provider] == current_strategy.capacity_provider &&
             strategy[:weight] == current_strategy.weight &&
@@ -144,7 +161,7 @@ module EcsDeploy
     end
 
     def delete_service
-      if @scheduling_strategy != 'DAEMON'
+      if @options[:scheduling_strategy] != 'DAEMON'
         @client.update_service(cluster: @cluster, service: @service_name, desired_count: 0)
         sleep 1
       end
@@ -184,30 +201,88 @@ module EcsDeploy
       end
     end
 
+    def skip_wait?
+      case @wait_strategy
+      when :none
+        true
+      when :legacy, :service_deployment
+        false
+      when nil
+        ecs_native_blue_green?
+      end
+    end
+
+    private def ecs_native_blue_green?
+      svc = @response&.service
+      return false unless svc&.deployment_controller&.type == "ECS"
+      strategy = svc.deployment_configuration&.strategy.to_s
+      ECS_NATIVE_BLUE_GREEN_STRATEGIES.include?(strategy)
+    end
+
     def self.wait_all_running(services)
-      services.group_by { |s| [s.cluster, s.region] }.flat_map do |(cl, region), ss|
-        params ||= EcsDeploy.config.ecs_client_params
+      threads = services.group_by { |s| [s.cluster, s.region] }.flat_map do |(cl, region), ss|
+        params = EcsDeploy.config.ecs_client_params
         client = Aws::ECS::Client.new(params.merge(region: region))
-        ss.reject(&:delete).map(&:service_name).each_slice(MAX_DESCRIBE_SERVICES).map do |chunked_service_names|
-          Thread.new do
-            EcsDeploy.config.ecs_wait_until_services_stable_max_attempts.times do
-              EcsDeploy.logger.info "waiting for services to stabilize [#{chunked_service_names.join(", ")}] [#{cl}]"
-              resp = client.describe_services(cluster: cl, services: chunked_service_names)
-              resp.services.each do |s|
-                # cf. https://github.com/aws/aws-sdk-ruby/blob/master/gems/aws-sdk-ecs/lib/aws-sdk-ecs/waiters.rb#L91-L96
-                if s.deployments.size == 1 && s.running_count == s.desired_count
-                  chunked_service_names.delete(s.service_name)
-                end
-                service = ss.detect {|sc| sc.service_name == s.service_name }
-                service.log_events(s)
+
+        targets = ss.reject(&:delete).reject do |s|
+          if s.skip_wait?
+            EcsDeploy.logger.info "skip waiting for service [#{s.service_name}] [#{cl}]: ECS-managed deployment, monitor via ecs:describe_deployment"
+            true
+          else
+            false
+          end
+        end
+
+        legacy_targets = targets.reject { |s| s.wait_strategy == :service_deployment }
+        sd_targets = targets.select { |s| s.wait_strategy == :service_deployment }
+
+        legacy_threads(client, cl, ss, legacy_targets) + service_deployment_threads(client, cl, sd_targets)
+      end
+      threads.each(&:join)
+    end
+
+    def self.legacy_threads(client, cluster, all_services, targets)
+      targets.map(&:service_name).each_slice(MAX_DESCRIBE_SERVICES).map do |chunked_service_names|
+        Thread.new do
+          EcsDeploy.config.ecs_wait_until_services_stable_max_attempts.times do
+            EcsDeploy.logger.info "waiting for services to stabilize [#{chunked_service_names.join(", ")}] [#{cluster}]"
+            resp = client.describe_services(cluster: cluster, services: chunked_service_names)
+            resp.services.each do |s|
+              # cf. https://github.com/aws/aws-sdk-ruby/blob/master/gems/aws-sdk-ecs/lib/aws-sdk-ecs/waiters.rb#L91-L96
+              if s.deployments.size == 1 && s.running_count == s.desired_count
+                chunked_service_names.delete(s.service_name)
               end
-              break if chunked_service_names.empty?
-              sleep EcsDeploy.config.ecs_wait_until_services_stable_delay
+              service = all_services.detect { |sc| sc.service_name == s.service_name }
+              service&.log_events(s)
+            end
+            break if chunked_service_names.empty?
+            sleep EcsDeploy.config.ecs_wait_until_services_stable_delay
+          end
+          raise TooManyAttemptsError unless chunked_service_names.empty?
+        end
+      end
+    end
+
+    def self.service_deployment_threads(client, cluster, targets)
+      targets.map do |service|
+        Thread.new do
+          pending = true
+          EcsDeploy.config.ecs_wait_until_services_stable_max_attempts.times do
+            EcsDeploy.logger.info "waiting for service deployment to settle [#{service.service_name}] [#{cluster}]"
+            arns = client.list_service_deployments(
+              cluster: cluster,
+              service: service.service_name,
+              status: %w[IN_PROGRESS PENDING],
+            ).service_deployments.map(&:service_deployment_arn)
+            if arns.empty?
+              pending = false
+              break
             end
-            raise TooManyAttemptsError unless chunked_service_names.empty?
+            sleep EcsDeploy.config.ecs_wait_until_services_stable_delay
           end
+          raise TooManyAttemptsError if pending
         end
-      end.each(&:join)
+      end
     end
 
     private

data/lib/ecs_deploy/service_deployment.rb

@@ -0,0 +1,71 @@
+module EcsDeploy
+  module ServiceDeployment
+    IN_FLIGHT_STATUSES = %w[IN_PROGRESS PENDING].freeze
+    DESCRIBE_STATUSES = %w[IN_PROGRESS PENDING STOPPED].freeze
+
+    class HookNotFoundError < StandardError; end
+
+    module_function
+
+    def describe(services:, regions:, default_cluster:)
+      each_target(services: services, regions: regions, default_cluster: default_cluster) do |client, cluster, svc|
+        deployments = list_deployments(client, cluster, svc[:name], statuses: DESCRIBE_STATUSES)
+        next if deployments.empty?
+        deployments.each { |d| log_deployment(d) }
+      end
+    end
+
+    def invoke_lifecycle_hook(hook_id:, action:, services:, regions:, default_cluster:)
+      found = false
+      each_target(services: services, regions: regions, default_cluster: default_cluster) do |client, cluster, svc|
+        deployments = list_deployments(client, cluster, svc[:name], statuses: IN_FLIGHT_STATUSES)
+        deployments.each do |d|
+          next unless Array(d.lifecycle_hook_details).any? { |h| h.hook_id == hook_id }
+          client.continue_service_deployment(
+            service_deployment_arn: d.service_deployment_arn,
+            hook_id: hook_id,
+            action: action,
+          )
+          EcsDeploy.logger.info "#{action.downcase}d lifecycle_hook=#{hook_id} service_deployment_arn=#{d.service_deployment_arn}"
+          found = true
+        end
+      end
+      raise HookNotFoundError, "Lifecycle hook #{hook_id} not found in any in-progress service deployment" unless found
+    end
+
+    def stop(service_deployment_arn:, region:, stop_type: nil)
+      client = Aws::ECS::Client.new(EcsDeploy.config.ecs_client_params.merge(region: region))
+      params = { service_deployment_arn: service_deployment_arn }
+      params[:stop_type] = stop_type if stop_type
+      client.stop_service_deployment(params)
+      EcsDeploy.logger.info "stopped service_deployment_arn=#{service_deployment_arn}#{stop_type ? " stop_type=#{stop_type}" : ""}"
+    end
+
+    def each_target(services:, regions:, default_cluster:)
+      services.each do |svc|
+        cluster = svc[:cluster] || default_cluster
+        regions.each do |r|
+          client = Aws::ECS::Client.new(EcsDeploy.config.ecs_client_params.merge(region: r))
+          yield client, cluster, svc
+        end
+      end
+    end
+
+    def list_deployments(client, cluster, service_name, statuses:)
+      arns = client.list_service_deployments(
+        cluster: cluster,
+        service: service_name,
+        status: statuses,
+      ).service_deployments.map(&:service_deployment_arn)
+      return [] if arns.empty?
+      client.describe_service_deployments(service_deployment_arns: arns).service_deployments
+    end
+
+    def log_deployment(d)
+      EcsDeploy.logger.info "service_deployment_arn=#{d.service_deployment_arn} status=#{d.status} lifecycle_stage=#{d.lifecycle_stage}"
+      Array(d.lifecycle_hook_details).each do |hook|
+        EcsDeploy.logger.info "  hook_id=#{hook.hook_id} target=#{hook.target_type} status=#{hook.status} expires_at=#{hook.expires_at} timeout_action=#{hook.timeout_action}"
+      end
+    end
+  end
+end

data/lib/ecs_deploy/task_definition.rb

@@ -10,23 +10,19 @@ module EcsDeploy
       EcsDeploy.logger.info "deregistered task definition [#{arn}] [#{client.config.region}] [#{Paint['OK', :green]}]"
     end
 
-    def initialize(
-      task_definition_name:, region: nil,
-      network_mode: "bridge", volumes: [], container_definitions: [], placement_constraints: [],
-      task_role_arn: nil,
-      execution_role_arn: nil,
-      requires_compatibilities: nil,
-      cpu: nil, memory: nil,
-      tags: nil,
-      runtime_platform: {}
-    )
+    def initialize(task_definition_name:, region: nil, **options)
       @task_definition_name = task_definition_name
-      @task_role_arn        = task_role_arn
-      @execution_role_arn   = execution_role_arn
       region ||= EcsDeploy.config.default_region
       params ||= EcsDeploy.config.ecs_client_params
 
-      @container_definitions = container_definitions.map do |cd|
+      @options = options.dup
+      @options[:network_mode] ||= "bridge"
+      @options[:volumes] ||= []
+      @options[:container_definitions] ||= []
+      @options[:placement_constraints] ||= []
+      @options[:runtime_platform] ||= {}
+
+      @options[:container_definitions] = @options[: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
@@ -35,16 +31,11 @@ module EcsDeploy
         end
         cd
       end
-      @volumes = volumes
-      @network_mode = network_mode
-      @placement_constraints = placement_constraints
-      @requires_compatibilities = requires_compatibilities
-      @cpu = cpu&.to_s
-      @memory = memory&.to_s
-      @tags = tags
+      @options[:cpu] = @options[:cpu]&.to_s
+      @options[:memory] = @options[:memory]&.to_s
+
       @client = region ? Aws::ECS::Client.new(params.merge(region: region)) : Aws::ECS::Client.new(params)
       @region = @client.config.region
-      @runtime_platform = runtime_platform
     end
 
     def recent_task_definition_arns
@@ -58,19 +49,9 @@ module EcsDeploy
     end
 
     def register
-      res = @client.register_task_definition({
-        family: @task_definition_name,
-        network_mode: @network_mode,
-        container_definitions: @container_definitions,
-        volumes: @volumes,
-        placement_constraints: @placement_constraints,
-        task_role_arn: @task_role_arn,
-        execution_role_arn: @execution_role_arn,
-        requires_compatibilities: @requires_compatibilities,
-        cpu: @cpu, memory: @memory,
-        tags: @tags,
-        runtime_platform: @runtime_platform
-      })
+      res = @client.register_task_definition(
+        @options.merge(family: @task_definition_name)
+      )
       EcsDeploy.logger.info "registered task definition [#{@task_definition_name}] [#{@region}] [#{Paint['OK', :green]}]"
       res.task_definition
     end

data/lib/ecs_deploy/version.rb

@@ -1,3 +1,3 @@
 module EcsDeploy
-  VERSION = "1.0.7"
+  VERSION = "2.0.0"
 end

data/lib/ecs_deploy.rb

@@ -27,4 +27,5 @@ end
 
 require "ecs_deploy/task_definition"
 require "ecs_deploy/service"
+require "ecs_deploy/service_deployment"
 require "ecs_deploy/scheduled_task"

data/renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ]
+}

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ecs_deploy
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 2.0.0
 platform: ruby
 authors:
 - joker1007
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-09 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-autoscaling
@@ -70,16 +69,22 @@ dependencies:
   name: aws-sdk-ecs
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '1.238'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '1.238'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: aws-sdk-sqs
   requirement: !ruby/object:Gem::Requirement
@@ -129,9 +134,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.11'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -139,9 +141,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.11'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -194,6 +193,7 @@ extra_rdoc_files: []
 files:
 - ".github/workflows/test.yml"
 - ".gitignore"
+- ".rspec"
 - CHANGELOG.md
 - Gemfile
 - README.md
@@ -208,7 +208,9 @@ files:
 - lib/ecs_deploy/auto_scaler/cluster_resource_manager.rb
 - lib/ecs_deploy/auto_scaler/config_base.rb
 - lib/ecs_deploy/auto_scaler/instance_drainer.rb
+- lib/ecs_deploy/auto_scaler/null_cluster_resource_manager.rb
 - lib/ecs_deploy/auto_scaler/service_config.rb
+- lib/ecs_deploy/auto_scaler/simple_scaling_config.rb
 - lib/ecs_deploy/auto_scaler/spot_fleet_request_config.rb
 - lib/ecs_deploy/auto_scaler/trigger_config.rb
 - lib/ecs_deploy/capistrano.rb
@@ -216,12 +218,13 @@ files:
 - lib/ecs_deploy/instance_fluctuation_manager.rb
 - lib/ecs_deploy/scheduled_task.rb
 - lib/ecs_deploy/service.rb
+- lib/ecs_deploy/service_deployment.rb
 - lib/ecs_deploy/task_definition.rb
 - lib/ecs_deploy/version.rb
+- renovate.json
 homepage: https://github.com/reproio/ecs_deploy
 licenses: []
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -236,8 +239,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
-signing_key:
+rubygems_version: 4.0.6
 specification_version: 4
 summary: AWS ECS deploy helper
 test_files: []