broadside 2.0.0 → 3.0.0.pre.prerelease

data/lib/broadside/command.rb

@@ -0,0 +1,130 @@
+require 'pp'
+require 'shellwords'
+require 'tty-table'
+
+module Broadside
+  module Command
+    extend LoggingUtils
+
+    DEFAULT_TAIL_LINES = 10
+
+    class << self
+      def targets
+        table_header = nil
+        table_rows = []
+
+        Broadside.config.targets.each do |_, target|
+          task_definition = EcsManager.get_latest_task_definition(target.family)
+          service_tasks_running = EcsManager.get_task_arns(
+            target.cluster,
+            target.family,
+            service_name: target.family,
+            desired_status: 'RUNNING'
+          ).size
+
+          if task_definition.nil?
+            warn "Skipping deploy target '#{target.name}' as it does not have a configured task_definition."
+            next
+          end
+
+          container_definitions = task_definition[:container_definitions].select { |c| c[:name] == target.family }
+          warn "Only displaying 1/#{container_definitions.size} containers" if container_definitions.size > 1
+          container_definition = container_definitions.first
+
+          row_data = target.to_h.merge(
+            Image: container_definition[:image],
+            CPU: container_definition[:cpu],
+            Memory: container_definition[:memory],
+            Revision: task_definition[:revision],
+            Tasks: "#{service_tasks_running}/#{target.scale}"
+          )
+
+          table_header ||= row_data.keys.map(&:to_s)
+          table_rows << row_data.values
+        end
+
+        table = TTY::Table.new(header: table_header, rows: table_rows)
+        puts table.render(:ascii, padding: [0, 1])
+      end
+
+      def status(options)
+        target = Broadside.config.get_target_by_name!(options[:target])
+        cluster = target.cluster
+        family = target.family
+        pastel = Pastel.new
+        debug "Getting status information about #{family}"
+
+        output = [
+          pastel.underline('Current task definition information:'),
+          pastel.blue(PP.pp(EcsManager.get_latest_task_definition(family), ''))
+        ]
+
+        if options[:verbose]
+          output << [
+            pastel.underline('Current service information:'),
+            pastel.bright_blue(PP.pp(EcsManager.ecs.describe_services(cluster: cluster, services: [family]), ''))
+          ]
+        end
+
+        task_arns = EcsManager.get_task_arns(cluster, family)
+        if task_arns.empty?
+          output << ["No running tasks found.\n"]
+        else
+          ips = EcsManager.get_running_instance_ips(cluster, family)
+
+          if options[:verbose]
+            output << [
+              pastel.underline('Task information:'),
+              pastel.bright_cyan(PP.pp(EcsManager.ecs.describe_tasks(cluster: cluster, tasks: task_arns), ''))
+            ]
+          end
+
+          output << [
+            pastel.underline('Private IPs of instances running tasks:'),
+            pastel.cyan(ips.map { |ip| "#{ip}: #{Broadside.config.ssh_cmd(ip)}" }.join("\n")) + "\n"
+          ]
+        end
+
+        puts output.join("\n")
+      end
+
+      def logtail(options)
+        lines = options[:lines] || DEFAULT_TAIL_LINES
+        target = Broadside.config.get_target_by_name!(options[:target])
+        ip = get_running_instance_ip!(target, *options[:instance])
+        info "Tailing logs for running container at #{ip}..."
+
+        cmd = "docker logs -f --tail=#{lines} `#{docker_ps_cmd(target.family)}`"
+        exec(Broadside.config.ssh_cmd(ip) + " '#{cmd}'")
+      end
+
+      def ssh(options)
+        target = Broadside.config.get_target_by_name!(options[:target])
+        ip = get_running_instance_ip!(target, *options[:instance])
+        info "Establishing SSH connection to #{ip}..."
+
+        exec(Broadside.config.ssh_cmd(ip))
+      end
+
+      def bash(options)
+        target = Broadside.config.get_target_by_name!(options[:target])
+        ip = get_running_instance_ip!(target, *options[:instance])
+        info "Running bash for running container at #{ip}..."
+
+        cmd = "docker exec -i -t `#{docker_ps_cmd(target.family)}` bash"
+        exec(Broadside.config.ssh_cmd(ip, tty: true) + " '#{cmd}'")
+      end
+
+      private
+
+      def get_running_instance_ip!(target, instance_index = 0)
+        EcsManager.check_service_and_task_definition_state!(target)
+        EcsManager.get_running_instance_ips!(target.cluster, target.family).fetch(instance_index)
+      end
+
+      def docker_ps_cmd(family)
+        "docker ps -n 1 --quiet --filter name=#{Shellwords.shellescape(family)}"
+      end
+    end
+  end
+end

data/lib/broadside/configuration/aws_configuration.rb

@@ -0,0 +1,25 @@
+module Broadside
+  class AwsConfiguration
+    include ActiveModel::Model
+    include InvalidConfiguration
+
+    validates :region, presence: true, strict: ConfigurationError
+    validates :ecs_poll_frequency, numericality: { only_integer: true, strict: ConfigurationError }
+    validates_each(:credentials) do |_, _, val|
+      raise ConfigurationError, 'credentials is not of type Aws::Credentials' unless val.is_a?(Aws::Credentials)
+    end
+
+    attr_accessor(
+      :credentials,
+      :ecs_default_cluster,
+      :ecs_poll_frequency,
+      :region
+    )
+
+    def initialize
+      @credentials = Aws::SharedCredentials.new.credentials
+      @ecs_poll_frequency = 2
+      @region = 'us-east-1'
+    end
+  end
+end

data/lib/broadside/configuration/configuration.rb

@@ -0,0 +1,74 @@
+require 'logger'
+
+module Broadside
+  class Configuration
+    include ActiveModel::Model
+    include LoggingUtils
+    include InvalidConfiguration
+
+    attr_reader(
+      :aws,
+      :targets
+    )
+    attr_accessor(
+      :application,
+      :config_file,
+      :default_docker_image,
+      :logger,
+      :prehook,
+      :posthook,
+      :ssh,
+      :timeout
+    )
+
+    validates :application, :targets, :logger, presence: true
+    validates_each(:aws) { |_, _, val| val.validate }
+
+    validates_each(:ssh) do |record, attr, val|
+      record.errors.add(attr, 'is not a hash') unless val.is_a?(Hash)
+
+      if (proxy = val[:proxy])
+        record.errors.add(attr, 'bad proxy config') unless proxy[:host] && proxy[:port] && proxy[:port].is_a?(Integer)
+      end
+    end
+
+    def initialize
+      @aws = AwsConfiguration.new
+      @logger = ::Logger.new(STDOUT)
+      @logger.level = ::Logger::INFO
+      @logger.datetime_format = '%Y-%m-%d_%H:%M:%S'
+      @ssh = {}
+      @timeout = 600
+    end
+
+    # Transform deploy target configs to Target objects
+    def targets=(targets_hash)
+      raise ConfigurationError, ':targets must be a hash' unless targets_hash.is_a?(Hash)
+
+      @targets = targets_hash.inject({}) do |h, (target_name, config)|
+        h.merge(target_name => Target.new(target_name, config))
+      end
+    end
+
+    def get_target_by_name!(name)
+      @targets.fetch(name) { raise ArgumentError, "Deploy target '#{name}' does not exist!" }
+    end
+
+    def ssh_cmd(ip, options = {})
+      cmd = 'ssh -o StrictHostKeyChecking=no'
+      cmd << ' -t -t' if options[:tty]
+      cmd << " -i #{@ssh[:keyfile]}" if @ssh[:keyfile]
+      if (proxy = @ssh[:proxy])
+        cmd << ' -o ProxyCommand="ssh -q'
+        cmd << " -i #{proxy[:keyfile]}" if proxy[:keyfile]
+        cmd << ' '
+        cmd << "#{proxy[:user]}@" if proxy[:user]
+        cmd << "#{proxy[:host]} nc #{ip} #{proxy[:port]}\""
+      end
+      cmd << ' '
+      cmd << "#{@ssh[:user]}@" if @ssh[:user]
+      cmd << ip.to_s
+      cmd
+    end
+  end
+end

data/lib/broadside/configuration/invalid_configuration.rb

@@ -0,0 +1,9 @@
+module Broadside
+  module InvalidConfiguration
+    extend LoggingUtils
+
+    def method_missing(m, *args, &block)
+      warn "Unknown configuration '#{m}' provided, ignoring."
+    end
+  end
+end

data/lib/broadside/deploy.rb

@@ -1,111 +1,19 @@
 module Broadside
   class Deploy
-    include Utils
-    include VerifyInstanceVariables
+    include LoggingUtils
 
-    attr_reader(
-      :command,
-      :instance,
-      :lines,
-      :tag,
-      :target
-    )
+    attr_reader :target
 
-    def initialize(target, opts = {})
-      @target   = target
-      @command  = opts[:command]  || @target.command
-      @instance = opts[:instance] || @target.instance
-      @lines    = opts[:lines]    || 10
-      @rollback = opts[:rollback] || 1
-      @scale    = opts[:scale]    || @target.scale
-      @tag      = opts[:tag]
-    end
-
-    def short
-      deploy
-    end
-
-    def full
-      config.verify(:ssh)
-      verify(:tag)
-
-      info "Running predeploy commands for #{family}..."
-      run_commands(@target.predeploy_commands)
-      info 'Predeploy complete.'
-
-      deploy
-    end
-
-    def deploy
-      verify(:tag)
-
-      info "Deploying #{image_tag} to #{family}..."
-      yield
-      info 'Deployment complete.'
-    end
-
-    def rollback(count = @rollback)
-      info "Rolling back #{count} release for #{family}..."
-      yield
-      info 'Rollback complete.'
-    end
-
-    def scale
-      info "Rescaling #{family} with scale=#{@scale}"
-      yield
-      info 'Rescaling complete.'
-    end
-
-    def run
-      config.verify(:ssh)
-      verify(:tag, :command)
-      info "Running command [#{@command}] for #{family}..."
-      yield
-      info 'Complete.'
-    end
-
-    def status
-      info "Getting status information about #{family}"
-      yield
-      info 'Complete.'
-    end
-
-    def logtail
-      verify(:instance)
-      yield
-    end
-
-    def ssh
-      verify(:instance)
-      yield
-    end
-
-    def bash
-      verify(:instance)
-      yield
+    def initialize(options = {})
+      @target = Broadside.config.get_target_by_name!(options[:target])
+      @tag = options[:tag] || @target.tag
     end
 
     private
 
-    def family
-      "#{config.application}_#{@target.name}"
-    end
-
     def image_tag
-      raise ArgumentError, "Missing tag" unless @tag
-      "#{config.docker_image}:#{@tag}"
-    end
-
-    def gen_ssh_cmd(ip, options = { tty: false })
-      opts = config.ssh || {}
-      cmd = 'ssh -o StrictHostKeyChecking=no'
-      cmd << ' -t -t' if options[:tty]
-      cmd << " -i #{opts[:keyfile]}" if opts[:keyfile]
-      if opts[:proxy]
-        cmd << " -o ProxyCommand=\"ssh #{opts[:proxy][:host]} nc #{ip} #{opts[:proxy][:port]}\""
-      end
-      cmd << " #{opts[:user]}@#{ip}"
-      cmd
+      raise ArgumentError, 'Missing tag!' unless @tag
+      "#{@target.docker_image}:#{@tag}"
     end
   end
 end

data/lib/broadside/ecs/ecs_deploy.rb

@@ -1,156 +1,127 @@
-require 'aws-sdk'
 require 'open3'
-require 'pp'
-require 'rainbow'
-require 'shellwords'
 
 module Broadside
   class EcsDeploy < Deploy
+    delegate :cluster, to: :target
+    delegate :family, to: :target
+
     DEFAULT_CONTAINER_DEFINITION = {
       cpu: 1,
       essential: true,
-      memory: 1000
+      memory: 1024
     }
 
-    def initialize(target, opts = {})
-      super
-      config.ecs.verify(:cluster, :poll_frequency)
+    def short
+      deploy
     end
 
-    def deploy
-      super do
-        unless EcsManager.service_exists?(@target.cluster, family)
-          exception "No service for #{family}! Please bootstrap or manually configure the service."
-        end
-        unless EcsManager.get_latest_task_definition_arn(family)
-          exception "No task definition for '#{family}'! Please bootstrap or manually configure the task definition."
-        end
+    def full
+      info "Running predeploy commands for #{family}..."
+      run_commands(@target.predeploy_commands, started_by: 'predeploy')
+      info 'Predeploy complete.'
 
-        update_task_revision
-
-        begin
-          update_service
-        rescue SignalException::Interrupt
-          error 'Caught interrupt signal, rolling back...'
-          rollback(1)
-          error 'Deployment did not finish successfully.'
-          raise
-        rescue StandardError => e
-          error e.inspect, "\n", e.backtrace.join("\n")
-          error 'Deploy failed! Rolling back...'
-          rollback(1)
-          error 'Deployment did not finish successfully.'
-          raise e
-        end
-      end
+      deploy
     end
 
     def bootstrap
-      unless EcsManager.get_latest_task_definition_arn(family)
-        unless @target.task_definition_config
-          raise ArgumentError, "No first task definition and no :task_definition_config in '#{family}' configuration"
-        end
-
+      if EcsManager.get_latest_task_definition_arn(family)
+        info "Task definition for #{family} already exists."
+      else
+        raise ConfigurationError, "No :task_definition_config for #{family}" unless @target.task_definition_config
         info "Creating an initial task definition for '#{family}' from the config..."
 
         EcsManager.ecs.register_task_definition(
           @target.task_definition_config.merge(
             family: family,
-            container_definitions: [DEFAULT_CONTAINER_DEFINITION.merge(container_definition)]
+            container_definitions: [DEFAULT_CONTAINER_DEFINITION.merge(configured_container_definition)]
           )
         )
       end
 
-      run_commands(@target.bootstrap_commands)
+      run_commands(@target.bootstrap_commands, started_by: 'bootstrap')
 
-      if EcsManager.service_exists?(@target.cluster, family)
+      if EcsManager.service_exists?(cluster, family)
         info("Service for #{family} already exists.")
       else
-        unless @target.service_config
-          raise ArgumentError, "Service doesn't exist and no :service_config in '#{family}' configuration"
-        end
-
+        raise ConfigurationError, "No :service_config for #{family}" unless @target.service_config
         info "Service '#{family}' doesn't exist, creating..."
-        EcsManager.create_service(@target.cluster, family, @target.service_config)
+        EcsManager.create_service(cluster, family, @target.service_config)
       end
     end
 
-    def rollback(count = @rollback)
-      super do
-        begin
-          EcsManager.deregister_last_n_tasks_definitions(family, count)
-          update_service
-        rescue StandardError
-          error 'Rollback failed to complete!'
-          raise
-        end
-      end
-    end
+    def rollback(options = {})
+      count = options[:rollback] || 1
+      info "Rolling back #{count} release(s) for #{family}..."
+      EcsManager.check_service_and_task_definition_state!(@target)
 
-    def scale
-      super do
-        update_service
+      begin
+        EcsManager.deregister_last_n_tasks_definitions(family, count)
+        update_service(options)
+      rescue StandardError
+        error 'Rollback failed to complete!'
+        raise
       end
-    end
 
-    def run
-      super do
-        run_commands(@command)
-      end
+      info 'Rollback complete.'
     end
 
-    def status
-      super do
-        ips = EcsManager.get_running_instance_ips(@target.cluster, family)
-        info "\n---------------",
-          "\nDeployed task definition information:\n",
-          Rainbow(PP.pp(EcsManager.get_latest_task_definition(family), '')).blue,
-          "\nPrivate ips of instances running containers:\n",
-          Rainbow(ips.join(' ')).blue,
-          "\n\nssh command:\n#{Rainbow(gen_ssh_cmd(ips.first)).cyan}",
-          "\n---------------\n"
-      end
+    def scale(options = {})
+      info "Rescaling #{family} with scale=#{@scale}..."
+      update_service(options)
+      info 'Rescaling complete.'
     end
 
-    def logtail
-      super do
-        ip = get_running_instance_ip
-        debug "Tailing logs for running container at ip #{ip}..."
-        search_pattern = Shellwords.shellescape(family)
-        cmd = "docker logs -f --tail=#{@lines} `docker ps -n 1 --quiet --filter name=#{search_pattern}`"
-        tail_cmd = gen_ssh_cmd(ip) + " '#{cmd}'"
-        exec tail_cmd
-      end
-    end
+    def run_commands(commands, options = {})
+      return if commands.nil? || commands.empty?
+      update_task_revision
 
-    def ssh
-      super do
-        ip = get_running_instance_ip
-        debug "Establishing an SSH connection to ip #{ip}..."
-        exec gen_ssh_cmd(ip)
-      end
-    end
+      begin
+        commands.each do |command|
+          command_name = "'#{command.join(' ')}'"
+          task_arn = EcsManager.run_task(cluster, family, command, options).tasks[0].task_arn
+          info "Launched #{command_name} task #{task_arn}, waiting for completion..."
 
-    def bash
-      super do
-        ip = get_running_instance_ip
-        debug "Running bash for running container at ip #{ip}..."
-        search_pattern = Shellwords.shellescape(family)
-        cmd = "docker exec -i -t `docker ps -n 1 --quiet --filter name=#{search_pattern}` bash"
-        bash_cmd = gen_ssh_cmd(ip, tty: true) + " '#{cmd}'"
-        exec bash_cmd
+          EcsManager.ecs.wait_until(:tasks_stopped, cluster: cluster, tasks: [task_arn]) do |w|
+            w.max_attempts = nil
+            w.delay = Broadside.config.aws.ecs_poll_frequency
+            w.before_attempt do |attempt|
+              info "Attempt #{attempt}: waiting for #{command_name} to complete..."
+            end
+          end
+
+          exit_status = EcsManager.get_task_exit_status(cluster, task_arn, family)
+          raise EcsError, "#{command_name} failed to start:\n'#{exit_status[:reason]}'" if exit_status[:exit_code].nil?
+          raise EcsError, "#{command_name} nonzero exit code: #{exit_status[:exit_code]}!" unless exit_status[:exit_code].zero?
+
+          info "#{command_name} task container logs:\n#{get_container_logs(task_arn)}"
+          info "#{command_name} task #{task_arn} complete"
+        end
+      ensure
+        EcsManager.deregister_last_n_tasks_definitions(family, 1)
       end
     end
 
     private
 
-    def get_running_instance_ip
-      EcsManager.get_running_instance_ips(@target.cluster, family).fetch(@target.instance)
+    def deploy
+      current_scale = EcsManager.current_service_scale(@target)
+      update_task_revision
+
+      begin
+        update_service
+      rescue Interrupt, StandardError => e
+        msg = e.is_a?(Interrupt) ? 'Caught interrupt signal' : "#{e.class}: #{e.message}"
+        error "#{msg}, rolling back..."
+        # In case of failure during deploy, rollback to the previously configured scale
+        rollback(scale: current_scale)
+        error 'Deployment did not finish successfully.'
+        raise e
+      end
     end
 
-    # Creates a new task revision using current directory's env vars, provided tag, and configured options.
-    # Currently can only handle a single container definition.
+    # Creates a new task revision using current directory's env vars, provided tag, and @target.task_definition_config
     def update_task_revision
+      EcsManager.check_task_definition_state!(target)
       revision = EcsManager.get_latest_task_definition(family).except(
         :requires_attributes,
         :revision,
@@ -158,114 +129,78 @@ module Broadside
         :task_definition_arn
       )
       updatable_container_definitions = revision[:container_definitions].select { |c| c[:name] == family }
-      exception "Can only update one container definition!" if updatable_container_definitions.size != 1
+      raise Error, 'Can only update one container definition!' if updatable_container_definitions.size != 1
 
-      # Deep merge doesn't work well with arrays (e.g. :container_definitions), so build the container first.
-      updatable_container_definitions.first.merge!(container_definition)
+      # Deep merge doesn't work well with arrays (e.g. container_definitions), so build the container first.
+      updatable_container_definitions.first.merge!(configured_container_definition)
       revision.deep_merge!((@target.task_definition_config || {}).except(:container_definitions))
 
       task_definition = EcsManager.ecs.register_task_definition(revision).task_definition
       debug "Successfully created #{task_definition.task_definition_arn}"
     end
 
-    # reloads the service using the latest task definition
-    def update_service
+    def update_service(options = {})
+      scale = options[:scale] || @target.scale
+      raise ArgumentError, ':scale not provided' unless scale
+
+      EcsManager.check_service_and_task_definition_state!(target)
       task_definition_arn = EcsManager.get_latest_task_definition_arn(family)
-      debug "Updating #{family} with scale=#{@target.scale} using task #{task_definition_arn}..."
+      debug "Updating #{family} with scale=#{scale} using task_definition #{task_definition_arn}..."
 
       update_service_response = EcsManager.ecs.update_service({
-        cluster: @target.cluster,
-        desired_count: @target.scale,
+        cluster: cluster,
+        desired_count: scale,
         service: family,
         task_definition: task_definition_arn
       }.deep_merge(@target.service_config || {}))
 
       unless update_service_response.successful?
-        exception('Failed to update service during deploy.', update_service_response.pretty_inspect)
+        raise EcsError, "Failed to update service:\n#{update_service_response.pretty_inspect}"
       end
 
-      EcsManager.ecs.wait_until(:services_stable, { cluster: @target.cluster, services: [family] }) do |w|
-        w.max_attempts = config.timeout ? config.timeout / config.ecs.poll_frequency : nil
-        w.delay = config.ecs.poll_frequency
-        seen_event = nil
+      EcsManager.ecs.wait_until(:services_stable, cluster: cluster, services: [family]) do |w|
+        timeout = Broadside.config.timeout
+        w.delay = Broadside.config.aws.ecs_poll_frequency
+        w.max_attempts = timeout ? timeout / w.delay : nil
+        seen_event_id = nil
 
         w.before_wait do |attempt, response|
-          debug "(#{attempt}/#{w.max_attempts}) Polling ECS for events..."
-          # skip first event since it doesn't apply to current request
-          if response.services[0].events.first && response.services[0].events.first.id != seen_event && attempt > 1
-            seen_event = response.services[0].events.first.id
-            debug(response.services[0].events.first.message)
+          info "(#{attempt}/#{w.max_attempts || Float::INFINITY}) Polling ECS for events..."
+          # Skip first event since it doesn't apply to current request
+          if response.services[0].events.first && response.services[0].events.first.id != seen_event_id && attempt > 1
+            seen_event_id = response.services[0].events.first.id
+            info response.services[0].events.first.message
           end
         end
       end
     end
 
-    def run_commands(commands)
-      return if commands.nil? || commands.empty?
-
-      update_task_revision
-
-      begin
-        Array.wrap(commands).each do |command|
-          command_name = command.join(' ')
-          run_task_response = EcsManager.run_task(@target.cluster, family, command)
-
-          unless run_task_response.successful? && run_task_response.tasks.try(:[], 0)
-            exception("Failed to run #{command_name} task.", run_task_response.pretty_inspect)
-          end
-
-          task_arn = run_task_response.tasks[0].task_arn
-          debug "Launched #{command_name} task #{task_arn}, waiting for completion..."
-
-          EcsManager.ecs.wait_until(:tasks_stopped, { cluster: @target.cluster, tasks: [task_arn] }) do |w|
-            w.max_attempts = nil
-            w.delay = config.ecs.poll_frequency
-            w.before_attempt do |attempt|
-              debug "Attempt #{attempt}: waiting for #{command_name} to complete..."
-            end
-          end
-
-          info "#{command_name} task container logs:\n#{get_container_logs(task_arn)}"
-
-          if (code = EcsManager.get_task_exit_code(@target.cluster, task_arn, family)) == 0
-            debug "#{command_name} task #{task_arn} exited with status code 0"
-          else
-            exception "#{command_name} task #{task_arn} exited with a non-zero status code #{code}!"
-          end
-        end
-      ensure
-        EcsManager.deregister_last_n_tasks_definitions(family, 1)
-      end
-    end
-
     def get_container_logs(task_arn)
-      ip = EcsManager.get_running_instance_ips(@target.cluster, family, task_arn).first
-      debug "Found ip of container instance: #{ip}"
+      ip = EcsManager.get_running_instance_ips!(cluster, family, task_arn).first
+      debug "Found IP of container instance: #{ip}"
 
-      find_container_id_cmd = "#{gen_ssh_cmd(ip)} \"docker ps -aqf 'label=com.amazonaws.ecs.task-arn=#{task_arn}'\""
+      find_container_id_cmd = "#{Broadside.config.ssh_cmd(ip)} \"docker ps -aqf 'label=com.amazonaws.ecs.task-arn=#{task_arn}'\""
       debug "Running command to find container id:\n#{find_container_id_cmd}"
-      container_id = `#{find_container_id_cmd}`.strip
+      container_ids = `#{find_container_id_cmd}`.split
 
-      get_container_logs_cmd = "#{gen_ssh_cmd(ip)} \"docker logs #{container_id}\""
-      debug "Running command to get logs of container #{container_id}:\n#{get_container_logs_cmd}"
+      logs = ''
+      container_ids.each do |container_id|
+        get_container_logs_cmd = "#{Broadside.config.ssh_cmd(ip)} \"docker logs #{container_id}\""
+        debug "Running command to get logs of container #{container_id}:\n#{get_container_logs_cmd}"
 
-      logs = nil
-      Open3.popen3(get_container_logs_cmd) do |_, stdout, stderr, _|
-        logs = "STDOUT:--\n#{stdout.read}\nSTDERR:--\n#{stderr.read}"
+        Open3.popen3(get_container_logs_cmd) do |_, stdout, stderr, _|
+          logs << "STDOUT (#{container_id}):\n--\n#{stdout.read}\nSTDERR (#{container_id}):\n--\n#{stderr.read}\n"
+        end
       end
+
       logs
     end
 
-    def container_definition
-      configured_containers = (@target.task_definition_config || {})[:container_definitions]
-      if configured_containers && configured_containers.size > 1
-        raise ArgumentError, 'Creating > 1 container definition not supported yet'
-      end
-
-      (configured_containers.try(:first) || {}).merge(
+    def configured_container_definition
+      (@target.task_definition_config.try(:[], :container_definitions).try(:first) || {}).merge(
         name: family,
-        command: @command,
-        environment: @target.env_vars,
+        command: @target.command,
+        environment: @target.ecs_env_vars,
         image: image_tag
       )
     end