🆕 Improve README, scheduled tasks implementation, more options

Author: ProGM

README.md

@@ -4,21 +4,37 @@
 
 A CLI + DSL to simplify deployments on ECS.
 
-It's partial, incomplete and unstable, DON'T use yet.
+It's partial, incomplete and unstable. Use it at your own risk.
 
-## Installation
+## Motivation
 
-Simply add the gem to your Gemfile
+Once you've configured your cluster on ECS, running Continous Deployment is not that easy.
 
-```ruby
-  gem 'ecs-deploy-cli', github: 'monade/ecs-deploy-cli'
-```
+A simple deployment requires:
+* Upload the Docker image
+* Update all your tasks
+* Update all services
+* Update eventual Scheduled Tasks manually
+
+We had some struggle with the official `ecs-cli` approach related with static compose files, requiring a lot of repetition (and potential errors) while defining tasks and envs.
+
+Moreover, you might want some business logic about how your cluster should be configured, like using ENV files, or switch between stages (production / staging), or adjusting container requirements based on external variables.
+
+So, why not creating a DSL built on top of our favourite language? <3
+
+## Installation
 
-Or install it globally to use it as a cli:
+You can install this gem globally
 ```bash
   $ gem install ecs-deploy-cli
 ```
 
+Or add the gem to your Gemfile:
+
+```ruby
+  gem 'ecs-deploy-cli'
+```
+
 ## Usage
 
 First, define a ECSFile in your project, to design your ECS cluster.
@@ -40,6 +56,7 @@ container :base_container do
   image "#{ENV['REPO_URL']}:#{ENV['CURRENT_VERSION']}"
   load_envs 'envs/base.yml'
   load_envs 'envs/production.yml'
+  env key: 'MANUAL_ENV', value: '123'
   secret key: 'RAILS_MASTER_KEY', value: 'railsMasterKey' # Taking the secret from AWS System Manager with name "arn:aws:ssm:__AWS_REGION__:__AWS_PROFILE_ID__:parameter/railsMasterKey"
   working_directory '/app'
   cloudwatch_logs 'yourproject' # Configuring cloudwatch logs
@@ -96,24 +113,60 @@ end
 # Scheduled tasks using Cloudwatch Events / Eventbridge
 cron :scheduled_emails do
   task :'yourproject-cron' do
-    # Overrides
-    container :web do
+    # Container overrides
+    container :cron do
       command 'rails', 'cron:exec'
     end
   end
+  subnets 'subnet-123123'
+  launch_type 'FARGATE'
+  # Task role override:
+  # task_role 'somerole'
+
   # Examples:
-  # every 1.hour
+  # run_every '2 hours'
   run_at '0 * * * ? *'
 end
 ```
 
 Now you can run the commands from the CLI.
 
-For instance, you can deploy all services:
+For instance, you can run deploy:
+```bash
+  $ ecs-deploy deploy
+```
+
+## CLI commands
+
+You can find the full command list by running `ecs-deploy help`.
+
+Check if your ECSFile is valid
+```bash
+  $ ecs-deploy validate
+```
+
+Deploy all services and scheduled tasks
+```bash
+  $ ecs-deploy deploy
+```
+
+Deploy just services
 ```bash
   $ ecs-deploy deploy-services
 ```
 
+Deploy just scheduled tasks
+```bash
+  $ ecs-deploy deploy-services
+```
+
+Run SSH on a cluster container instance:
+```bash
+  $ ecs-deploy ssh
+```
+
+## API
+
 You can also use it as an API:
 ```ruby
 require 'ecs_deploy_cli'
@@ -124,9 +177,9 @@ runner = EcsDeployCli::Runner.new(parser)
 runner.update_services!
 ```
 
-### TODOs
+## TODOs
 
-- Scheduled tasks implementation
-- SSH to ec2 instances
+- Create cloudwatch logs group if it doesn't exist yet
+- Create the service if not present?
+- Create scheduled tasks if not present?
 - More configuration options
-- Create the service if not present

ecs-deploy-cli.gemspec

@@ -7,8 +7,8 @@ Gem::Specification.new do |s|
   s.name        = 'ecs_deploy_cli'
   s.version     = EcsDeployCli::VERSION
   s.date        = '2021-03-31'
-  s.summary     = "A command line interface to make ECS deployments easier"
-  s.description = "Declare your cluster structure in a ECSFile and use the CLI to run deploys and monitor its status."
+  s.summary     = 'A command line interface to make ECS deployments easier'
+  s.description = 'Declare your cluster structure in a ECSFile and use the CLI to run deploys and monitor its status.'
   s.authors     = ['Mònade', 'ProGM']
   s.email       = 'team@monade.io'
   s.files = Dir['lib/**/*']
@@ -18,8 +18,10 @@ Gem::Specification.new do |s|
   s.license     = 'MIT'
   s.executables << 'ecs-deploy'
   s.add_dependency 'activesupport', ['>= 5', '< 7']
-  s.add_dependency 'thor'
-  s.add_dependency 'aws-sdk-ecs'
+  s.add_dependency 'aws-sdk-cloudwatchevents', '~> 1'
+  s.add_dependency 'aws-sdk-ec2', '~> 1'
+  s.add_dependency 'aws-sdk-ecs', '~> 1'
+  s.add_dependency 'thor', '~> 1.1'
   s.add_development_dependency 'rspec', '~> 3'
-  s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'rubocop', '~> 0.93'
 end

lib/ecs_deploy_cli.rb

@@ -2,6 +2,7 @@
 require 'logger'
 require 'thor'
 require 'aws-sdk-ecs'
+require 'active_support/core_ext/hash/indifferent_access'
 
 module EcsDeployCli
   def self.logger

lib/ecs_deploy_cli/cli.rb

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

lib/ecs_deploy_cli/dsl/auto_options.rb

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

lib/ecs_deploy_cli/dsl/container.rb

@@ -10,6 +10,10 @@ def initialize(name, config)
         _options[:name] = name.to_s
       end
 
+      def image(value)
+        _options[:image] = value
+      end
+
       def command(*command)
         _options[:command] = command
       end
@@ -18,6 +22,10 @@ def load_envs(name)
         _options[:environment] = (_options[:environment] || []) + YAML.safe_load(File.open(name))
       end
 
+      def env(key:, value:)
+        (_options[:environment] ||= []) << { 'name' => key, 'value' => value }
+      end
+
       def secret(key:, value:)
         (_options[:secrets] ||= []) << { name: key, value_from: "arn:aws:ssm:#{@config[:aws_region]}:#{@config[:aws_profile_id]}:parameter/#{value}" }
       end
@@ -26,6 +34,10 @@ def expose(**options)
         (_options[:port_mappings] ||= []) << options
       end
 
+      def cpu(value)
+        _options[:cpu] = value
+      end
+
       def memory(limit:, reservation:)
         _options[:memory] = limit
         _options[:memory_reservation] = reservation

lib/ecs_deploy_cli/dsl/cron.rb

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