ecs-easy-cluster 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6deb5e083c0a0a6c90456bb28a6538ecb009b87a
+  data.tar.gz: d14a41c0c460cef5c5cb1c466b36ff4352d27a34
+SHA512:
+  metadata.gz: 332a2068fbfe7169e026d490182b22dbef5fc70c45211660054585f33abe92254dbe10cca8493761da0733b5fb3aa8cd90613317441acf8234592c0f82cb58ca
+  data.tar.gz: 4fbdfe7f61a815c8339b695a58fa19edb20f802160dd581695441587fd2e9a3c1d99258f28debe10a80b757ad1abf79be6e42687026cd7ada9e62691b65e4fae

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 metheglin
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,72 @@
+# Ecs::Easy::Cluster
+
+ecs-easy-cluster is a easy clustering tool for AWS ECS.
+This tool focuses on executing tiny scripts, jobs or batches without considering the running environment.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ecs-easy-cluster'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ecs-easy-cluster
+
+## Usage
+
+```
+require "ecs-easy-cluster"
+
+#
+# Set basic info: credentials and region
+#
+configure = Ecs::Easy::Configure.new do |c|
+  c.profile = "your-aws-profile"
+  c.region = "your-aws-region"
+end
+
+#
+# Define ec2 instance profile
+#
+instance = Ecs::Easy::Instance.new do |i|
+  i.type      = "t2.nano"
+  i.keypair   = "your-keypair"
+  i.azs       = "ap-northeast-1a,ap-northeast-1c"
+  i.subnets   = "subnet-00000000,subnet-11111111"
+  i.vpc       = "vpc-00000000"
+  i.image_id  = "ami-00000000"
+  i.security_group = "sg-00000000"
+end
+
+# 
+# Define the scale setting of your cluster
+#
+cluster = Ecs::Easy::Cluster::MemScale.new("cluster-name", configure) do |c|
+  c.max_instances = 2
+  c.min_instances = 1
+  c.instance = instance
+end
+
+#
+# Make your task running
+#
+cluster.make_task_running!("your-task-definition-name")
+
+#
+# Shrink your scaled instances
+# ------------
+# !! CAUTION !!
+# This command terminates redundant instances even if some tasks are running on them.
+#
+cluster.shrink!
+```
+
+## Memo
+
+ecs/easy/cluster/cloudformation_template.json.erb is refered from the link below.
+https://github.com/aws/amazon-ecs-cli/blob/master/ecs-cli/modules/aws/clients/cloudformation/template.go

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/ecs-easy-cluster.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ecs/easy/cluster/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ecs-easy-cluster"
+  spec.version       = Ecs::Easy::Cluster::VERSION
+  spec.authors       = ["metheglin"]
+  spec.email         = ["pigmybank@gmail.com"]
+  spec.summary       = %q{easy-to-use AWS ECS Cluster.}
+  spec.description   = %q{easy-to-use AWS ECS Cluster.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "aws-sdk", "~> 2.4"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/lib/ecs/easy/cluster.rb

@@ -0,0 +1,38 @@
+require "ecs/easy/cluster/version"
+
+require "ostruct"
+require "aws-sdk"
+
+require "ecs/easy/configure"
+require "ecs/easy/instance"
+
+# configure = Ecs::Easy::Configure.new do |c|
+#   c.profile = ""
+#   c.region = ""
+# end
+# instance = Ecs::Easy::Instance.new do |i|
+#   i.instance_type = "t2.nano"
+#   i.keypair   = "your-keypair"
+#   i.azs       = "ap-northeast-1a,ap-northeast-1c"
+#   i.subnets   = "subnet-00000000,subnet-11111111"
+#   i.vpc       = "vpc-00000000"
+#   i.image_id  = "ami-00000000"
+#   i.security_group = "sg-00000000"
+# end
+# cluster = Ecs::Easy::Cluster::MemScale.new("cluster-name", configure) do |c|
+#   c.max_instances = 2
+#   c.min_instances = 1
+#   c.instance = instance
+# end
+# cluster.make_task_running!("your-task-definition-name")
+
+module Ecs
+  module Easy
+    module Cluster
+
+      autoload :Base, File.expand_path("../cluster/base.rb", __FILE__)
+      autoload :MemScale, File.expand_path("../cluster/mem_scale.rb", __FILE__)
+      
+    end
+  end
+end

data/lib/ecs/easy/cluster/base.rb

@@ -0,0 +1,168 @@
+module Ecs::Easy::Cluster
+  class Base
+
+    TEMPLATE_PATH = File.expand_path("../config/cloudFormation_template.json", __FILE__)
+    TEMPLATE_BODY = File.read( TEMPLATE_PATH )
+
+    attr_reader :name, :configure, :ecs_client, :stack_name, :cfn_client
+    attr_accessor :instance, :min_instances, :max_instances
+
+    def initialize( name, configure )
+      @name = name
+      @configure = configure
+      @ecs_client = Aws::ECS::Client.new(
+        region: configure.region,
+        credentials: configure.credentials
+      )
+      @stack_name = configure.cfn_stack_name_prefix + name
+      @cfn_client = Aws::CloudFormation::Client.new(
+        region: configure.region,
+        credentials: configure.credentials
+      )
+
+      # default
+      @min_instances = 1
+      @max_instances = 1
+
+      yield( self ) if block_given?
+    end
+
+    # Check if the cluster exists
+    # A cluster existence should be decided as cloudformation stack existence
+    def exists?
+      res = cfn_client.describe_stacks( stack_name: stack_name )
+      return res.stacks.length > 0
+    rescue => e
+      return false
+    end
+
+    # Check if all the container instances on the cluster are ready
+    def ready?
+      return false unless exists?
+      instance_arns = ecs_client.list_container_instances(cluster: name).container_instance_arns
+      return false if instance_arns.nil? or instance_arns.empty?
+      res = ecs_client.describe_container_instances(
+        cluster: name,
+        container_instances: instance_arns
+      )
+      # unless res.respond_to?("container_instances") or
+      #   res.container_instances.nil?
+      #   return false
+      # end
+      res.container_instances.all? {|i| i.status == "ACTIVE" }
+    end
+
+    # Check if the task exists on the cluster
+    def task_exists?( task )
+      task_arns = ecs_client.list_tasks(cluster: name).task_arns
+      task_arns.include?( task )
+    end
+
+    def num_instances
+      ecs_client.list_container_instances(cluster: name).container_instance_arns.length
+    end
+
+    # Wait until all the container instances ready
+    def wait_until_ready( retry_count=30, sleep_sec=2 )
+      retry_count.times do
+        break if ready?
+        sleep sleep_sec
+      end
+    end
+
+    def wait_until_task_running( arn )
+      raise "Task Not Found. Possibly the task is already stopped." unless task_exists?( arn )
+      ecs_client.wait_until(:tasks_running, tasks: [arn])
+    end
+
+    def run_task!( task_definition, overrides={} )
+      res = ecs_client.run_task(
+        cluster: name,
+        task_definition: task_definition,
+        overrides: overrides
+      )
+    end
+
+    def up!
+      unless exists?
+        ecs_client.create_cluster( cluster_name: name )
+
+        params = instance.cfn_parameters( name, "AsgMaxSize" => min_instances.to_s)
+        cfn_client.create_stack(
+          stack_name: stack_name,
+          template_body: TEMPLATE_BODY,
+          parameters: params,
+          capabilities: ["CAPABILITY_IAM"],
+          on_failure: "DELETE",
+        )
+        cfn_client.wait_until(
+          :stack_create_complete, 
+          stack_name: stack_name
+        )
+      end
+
+      return exists?
+    end
+
+    def destroy!
+      cfn_client.delete_stack(stack_name: stack_name)
+      cfn_client.wait_until(
+        :stack_delete_complete, 
+        stack_name: stack_name
+      )
+    end
+
+    def scale!
+      size = (num_instances+1 <= max_instances) ? num_instances+1 : max_instances
+
+      params = instance.cfn_parameters( name, "AsgMaxSize" => size.to_s)
+      cfn_client.update_stack(
+        stack_name: stack_name,
+        template_body: TEMPLATE_BODY,
+        parameters: params,
+        capabilities: ["CAPABILITY_IAM"],
+      )
+      cfn_client.wait_until(
+        :stack_update_complete, 
+        stack_name: stack_name
+      )
+
+      # Check the scale completion every 2 seconds until max 30 times
+      30.times do
+        return true if num_instances == size
+        sleep 2
+      end
+
+      return false
+    rescue Aws::Waiters::Errors::WaiterFailed => e
+      puts e
+    end
+
+    # Deregister some container instances if they are idling
+    # TODO: Support idling check of container instances
+    def shrink!
+      params = instance.cfn_parameters( name, "AsgMaxSize" => min_instances.to_s)
+      cfn_client.update_stack(
+        stack_name: stack_name,
+        template_body: TEMPLATE_BODY,
+        parameters: params,
+        capabilities: ["CAPABILITY_IAM"],
+      )
+      cfn_client.wait_until(
+        :stack_update_complete, 
+        stack_name: stack_name
+      )
+    rescue Aws::Waiters::Errors::WaiterFailed => e
+      puts e
+    end
+
+    private
+      def fail_reason( failures )
+        reasons = failures.map {|f| f.reason }
+        if reasons.include?( "RESOURCE:MEMORY" )
+          return "RESOURCE:MEMORY"
+        end
+      end
+
+  end
+end

data/lib/ecs/easy/cluster/config/cloudformation_template.json

@@ -0,0 +1,517 @@
+{
+  "AWSTemplateFormatVersion": "2010-09-09",
+  "Description": "AWS CloudFormation template to create resources required to run tasks on an ECS cluster.",
+  "Mappings": {
+    "VpcCidrs": {
+      "vpc": {"cidr" : "10.0.0.0/16"},
+      "pubsubnet1": {"cidr" : "10.0.0.0/24"},
+      "pubsubnet2": {"cidr" :"10.0.1.0/24"}
+    }
+  },
+  "Parameters": {
+    "EcsAmiId": {
+      "Type": "String",
+      "Description": "ECS EC2 AMI id",
+      "Default": ""
+    },
+    "EcsInstanceType": {
+      "Type": "String",
+      "Description": "ECS EC2 instance type",
+      "Default": "t2.micro",
+      "AllowedValues": [
+        "t2.nano",
+        "t2.micro",
+        "t2.small",
+        "t2.medium",
+        "t2.large",
+        "m3.medium",
+        "m3.large",
+        "m3.xlarge",
+        "m3.2xlarge",
+        "m4.large",
+        "m4.xlarge",
+        "m4.2xlarge",
+        "m4.4xlarge",
+        "m4.10xlarge",
+        "c4.large",
+        "c4.xlarge",
+        "c4.2xlarge",
+        "c4.4xlarge",
+        "c4.8xlarge",
+        "c3.large",
+        "c3.xlarge",
+        "c3.2xlarge",
+        "c3.4xlarge",
+        "c3.8xlarge",
+        "r3.large",
+        "r3.xlarge",
+        "r3.2xlarge",
+        "r3.4xlarge",
+        "r3.8xlarge",
+        "i2.xlarge",
+        "i2.2xlarge",
+        "i2.4xlarge",
+        "i2.8xlarge",
+        "g2.2xlarge",
+        "g2.8xlarge",
+        "d2.xlarge",
+        "d2.2xlarge",
+        "d2.4xlarge",
+        "d2.8xlarge"
+      ],
+      "ConstraintDescription": "must be a valid EC2 instance type."
+    },
+    "KeyName": {
+      "Type": "AWS::EC2::KeyPair::KeyName",
+      "Description": "Optional - Name of an existing EC2 KeyPair to enable SSH access to the ECS instances",
+      "Default": ""
+    },
+    "VpcId": {
+      "Type": "String",
+      "Description": "Optional - VPC Id of existing VPC. Leave blank to have a new VPC created",
+      "Default": "",
+      "AllowedPattern": "^(?:vpc-[0-9a-f]{8}|)$",
+      "ConstraintDescription": "VPC Id must begin with 'vpc-' or leave blank to have a new VPC created"
+    },
+    "SubnetIds": {
+      "Type": "CommaDelimitedList",
+      "Description": "Optional - Comma separated list of two (2) existing VPC Subnet Ids where ECS instances will run.  Required if setting VpcId.",
+      "Default": ""
+    },
+    "AsgMaxSize": {
+      "Type": "Number",
+      "Description": "Maximum size and initial Desired Capacity of ECS Auto Scaling Group",
+      "Default": "1"
+    },
+    "SecurityGroup": {
+      "Type": "String",
+      "Description": "Optional - Existing security group to associate the container instances. Creates one by default.",
+      "Default": ""
+    },
+    "SourceCidr": {
+      "Type": "String",
+      "Description": "Optional - CIDR/IP range for EcsPort - defaults to 0.0.0.0/0",
+      "Default": "0.0.0.0/0"
+    },
+    "EcsPort" : {
+      "Type" : "String",
+      "Description" : "Optional - Security Group port to open on ECS instances - defaults to port 80",
+      "Default" : "80"
+    },
+    "VpcAvailabilityZones": {
+      "Type": "CommaDelimitedList",
+      "Description": "Optional - Comma-delimited list of VPC availability zones in which to create subnets.  Required if setting VpcId.",
+      "Default": ""
+    },
+    "EcsCluster" : {
+      "Type" : "String",
+      "Description" : "ECS Cluster Name",
+      "Default" : "default"
+    }
+  },
+  "Conditions": {
+    "CreateVpcResources": {
+      "Fn::Equals": [
+        {
+          "Ref": "VpcId"
+        },
+        ""
+      ]
+    },
+    "CreateSecurityGroup": {
+      "Fn::Equals": [
+        {
+          "Ref": "SecurityGroup"
+        },
+        ""
+      ]
+    },
+    "CreateEC2LCWithKeyPair": {
+      "Fn::Not": [
+        {
+          "Fn::Equals": [
+            {
+              "Ref": "KeyName"
+            },
+            ""
+          ]
+        }
+      ]
+    },
+    "CreateEC2LCWithoutKeyPair": {
+      "Fn::Equals": [
+        {
+          "Ref": "KeyName"
+        },
+        ""
+      ]
+    },
+    "UseSpecifiedVpcAvailabilityZones": {
+      "Fn::Not": [
+        {
+          "Fn::Equals": [
+            {
+              "Fn::Join": [
+                "",
+                {
+                  "Ref": "VpcAvailabilityZones"
+                }
+              ]
+            },
+            ""
+          ]
+        }
+      ]
+    }
+  },
+  "Resources": {
+    "Vpc": {
+      "Condition": "CreateVpcResources",
+      "Type": "AWS::EC2::VPC",
+      "Properties": {
+        "CidrBlock": {
+          "Fn::FindInMap": ["VpcCidrs", "vpc", "cidr"]
+        }
+      }
+    },
+    "PubSubnetAz1": {
+      "Condition": "CreateVpcResources",
+      "Type": "AWS::EC2::Subnet",
+      "Properties": {
+        "VpcId": {
+          "Ref": "Vpc"
+        },
+        "CidrBlock": {
+          "Fn::FindInMap": ["VpcCidrs", "pubsubnet1", "cidr"]
+        },
+        "AvailabilityZone": {
+          "Fn::If": [
+            "UseSpecifiedVpcAvailabilityZones",
+            {
+              "Fn::Select": [
+                "0",
+                {
+                  "Ref": "VpcAvailabilityZones"
+                }
+              ]
+            },
+            {
+              "Fn::Select": [
+                "0",
+                {
+                  "Fn::GetAZs": {
+                    "Ref": "AWS::Region"
+                  }
+                }
+              ]
+            }
+          ]
+        }
+      }
+    },
+    "PubSubnetAz2": {
+      "Condition": "CreateVpcResources",
+      "Type": "AWS::EC2::Subnet",
+      "Properties": {
+        "VpcId": {
+          "Ref": "Vpc"
+        },
+        "CidrBlock": {
+          "Fn::FindInMap": ["VpcCidrs", "pubsubnet2", "cidr"]
+        },
+        "AvailabilityZone": {
+          "Fn::If": [
+            "UseSpecifiedVpcAvailabilityZones",
+            {
+              "Fn::Select": [
+                "1",
+                {
+                  "Ref": "VpcAvailabilityZones"
+                }
+              ]
+            },
+            {
+              "Fn::Select": [
+                "1",
+                {
+                  "Fn::GetAZs": {
+                    "Ref": "AWS::Region"
+                  }
+                }
+              ]
+            }
+          ]
+        }
+      }
+    },
+    "InternetGateway": {
+      "Condition": "CreateVpcResources",
+      "Type": "AWS::EC2::InternetGateway"
+    },
+    "AttachGateway": {
+      "Condition": "CreateVpcResources",
+      "Type": "AWS::EC2::VPCGatewayAttachment",
+      "Properties": {
+        "VpcId": {
+          "Ref": "Vpc"
+        },
+        "InternetGatewayId": {
+          "Ref": "InternetGateway"
+        }
+      }
+    },
+    "RouteViaIgw": {
+      "Condition": "CreateVpcResources",
+      "Type": "AWS::EC2::RouteTable",
+      "Properties": {
+        "VpcId": {
+          "Ref": "Vpc"
+        }
+      }
+    },
+    "PublicRouteViaIgw": {
+      "Condition": "CreateVpcResources",
+      "DependsOn": "AttachGateway",
+      "Type": "AWS::EC2::Route",
+      "Properties": {
+        "RouteTableId": {
+          "Ref": "RouteViaIgw"
+        },
+        "DestinationCidrBlock": "0.0.0.0/0",
+        "GatewayId": {
+          "Ref": "InternetGateway"
+        }
+      }
+    },
+    "PubSubnet1RouteTableAssociation": {
+      "Condition": "CreateVpcResources",
+      "Type": "AWS::EC2::SubnetRouteTableAssociation",
+      "Properties": {
+        "SubnetId": {
+          "Ref": "PubSubnetAz1"
+        },
+        "RouteTableId": {
+          "Ref": "RouteViaIgw"
+        }
+      }
+    },
+    "PubSubnet2RouteTableAssociation": {
+      "Condition": "CreateVpcResources",
+      "Type": "AWS::EC2::SubnetRouteTableAssociation",
+      "Properties": {
+        "SubnetId": {
+          "Ref": "PubSubnetAz2"
+        },
+        "RouteTableId": {
+          "Ref": "RouteViaIgw"
+        }
+      }
+    },
+    "EcsSecurityGroup": {
+      "Condition": "CreateSecurityGroup",
+      "Type": "AWS::EC2::SecurityGroup",
+      "Properties": {
+        "GroupDescription": "ECS Allowed Ports",
+        "VpcId": {
+          "Fn::If": [
+            "CreateVpcResources",
+            {
+              "Ref": "Vpc"
+            },
+            {
+              "Ref": "VpcId"
+            }
+          ]
+        },
+        "SecurityGroupIngress" : [ {
+            "IpProtocol" : "tcp",
+            "FromPort" : { "Ref" : "EcsPort" },
+            "ToPort" : { "Ref" : "EcsPort" },
+            "CidrIp" : { "Ref" : "SourceCidr" } 
+        } ]
+      }
+    },
+    "EcsInstancePolicy": {
+      "Type": "AWS::IAM::Role",
+      "Properties": {
+        "AssumeRolePolicyDocument": {
+          "Version": "2012-10-17",
+          "Statement": [
+            {
+              "Effect": "Allow",
+              "Principal": {
+                "Service": [
+                  "ec2.amazonaws.com"
+                ]
+              },
+              "Action": [
+                "sts:AssumeRole"
+              ]
+            }
+          ]
+        },
+        "Path": "/",
+        "ManagedPolicyArns": [
+          "arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role"
+        ]
+      }
+    },
+    "EcsInstanceProfile": {
+      "Type": "AWS::IAM::InstanceProfile",
+      "Properties": {
+        "Path": "/",
+        "Roles": [
+          {
+            "Ref": "EcsInstancePolicy"
+          }
+        ]
+      }
+    },
+    "EcsInstanceLc": {
+      "Condition": "CreateEC2LCWithKeyPair",
+      "Type": "AWS::AutoScaling::LaunchConfiguration",
+      "Properties": {
+  "ImageId": { "Ref" : "EcsAmiId" },
+        "InstanceType": {
+          "Ref": "EcsInstanceType"
+        },
+        "AssociatePublicIpAddress": true,
+        "IamInstanceProfile": {
+          "Ref": "EcsInstanceProfile"
+        },
+        "KeyName": {
+          "Ref": "KeyName"
+        },
+        "SecurityGroups": {
+          "Fn::If": [
+            "CreateSecurityGroup",
+            [ {
+              "Ref": "EcsSecurityGroup"
+            } ],
+            [ {
+              "Ref": "SecurityGroup"
+            } ]
+          ]
+        },
+        "UserData": {
+          "Fn::Base64": {
+            "Fn::Join": [
+              "",
+              [
+                "#!/bin/bash\n",
+                "echo ECS_CLUSTER=",
+                {
+                  "Ref": "EcsCluster"
+                },
+                " >> /etc/ecs/ecs.config\n"
+              ]
+            ]
+          }
+        }
+      }
+    },
+    "EcsInstanceLcWithoutKeyPair": {
+      "Condition": "CreateEC2LCWithoutKeyPair",
+      "Type": "AWS::AutoScaling::LaunchConfiguration",
+      "Properties": {
+  "ImageId": { "Ref" : "EcsAmiId" },
+        "InstanceType": {
+          "Ref": "EcsInstanceType"
+        },
+        "AssociatePublicIpAddress": true,
+        "IamInstanceProfile": {
+          "Ref": "EcsInstanceProfile"
+        },
+        "SecurityGroups": {
+          "Fn::If": [
+            "CreateSecurityGroup",
+            [ {
+              "Ref": "EcsSecurityGroup"
+            } ],
+            [ {
+              "Ref": "SecurityGroup"
+            } ]
+          ]
+        },
+        "UserData": {
+          "Fn::Base64": {
+            "Fn::Join": [
+              "",
+              [
+                "#!/bin/bash\n",
+                "echo ECS_CLUSTER=",
+                {
+                  "Ref": "EcsCluster"
+                },
+                " >> /etc/ecs/ecs.config\n"
+              ]
+            ]
+          }
+        }
+      }
+    },
+    "EcsInstanceAsg": {
+      "Type": "AWS::AutoScaling::AutoScalingGroup",
+      "Properties": {
+        "VPCZoneIdentifier": {
+          "Fn::If": [
+            "CreateVpcResources",
+            [
+              {
+                "Fn::Join": [
+                  ",",
+                  [
+                    {
+                      "Ref": "PubSubnetAz1"
+                    },
+                    {
+                      "Ref": "PubSubnetAz2"
+                    }
+                  ]
+                ]
+              }
+            ],
+            {
+              "Ref": "SubnetIds"
+            }
+          ]
+        },
+        "LaunchConfigurationName": {
+          "Fn::If": [
+            "CreateEC2LCWithKeyPair",
+            {
+              "Ref": "EcsInstanceLc"
+            },
+            {
+              "Ref": "EcsInstanceLcWithoutKeyPair"
+            }
+          ]
+        },
+        "MinSize": "1",
+        "MaxSize": {
+          "Ref": "AsgMaxSize"
+        },
+        "DesiredCapacity": {
+          "Ref": "AsgMaxSize"
+        },
+        "Tags": [
+          {
+            "Key": "Name",
+            "Value": {
+              "Fn::Join": [
+                "",
+                [
+                  "ECS Instance - ",
+                  {
+                    "Ref": "AWS::StackName"
+                  }
+                ]
+              ]
+            },
+            "PropagateAtLaunch": "true"
+          }
+        ]
+      }
+    }
+  }
+}

data/lib/ecs/easy/cluster/config/ec2_profile.json

@@ -0,0 +1,37 @@
+{
+  "t2.nano": { "mem": 0.5 },
+  "t2.micro": { "mem": 1 },
+  "t2.small": { "mem": 2 },
+  "t2.medium": { "mem": 4 },
+  "t2.large": { "mem": 8 },
+
+  "m4.large": { "mem": 8 },
+  "m4.xlarge": { "mem": 16 },
+  "m4.2xlarge": { "mem": 32 },
+  "m4.4xlarge": { "mem": 64 },
+  "m4.10xlarge": { "mem": 160 },
+
+  "m3.medium": { "mem": 3.75 },
+  "m3.large": { "mem": 7.5 },
+  "m3.xlarge": { "mem": 15 },
+  "m3.2xlarge": { "mem": 30 },
+
+  "c4.large": { "mem": 3.75 },
+  "c4.xlarge": { "mem": 7.5 },
+  "c4.2xlarge": { "mem": 15 },
+  "c4.4xlarge": { "mem": 30 },
+  "c4.8xlarge": { "mem": 60 },
+
+  "c3.large": { "mem": 3.75 },
+  "c3.xlarge": { "mem": 7.5 },
+  "c3.2xlarge": { "mem": 15 },
+  "c3.4xlarge": { "mem": 30 },
+  "c3.8xlarge": { "mem": 60 },
+
+  "r3.large": { "mem": 15.25 },
+  "r3.xlarge": { "mem": 30.5 },
+  "r3.2xlarge": { "mem": 61 },
+  "r3.4xlarge": { "mem": 122 },
+  "r3.8xlarge": { "mem": 244 }
+
+}

data/lib/ecs/easy/cluster/mem_scale.rb

@@ -0,0 +1,61 @@
+module Ecs::Easy::Cluster
+  class MemScale < Base 
+
+    EC2_PROFILE_PATH = File.expand_path("../config/ec2_profile.json", __FILE__)
+    INSTANCE_TYPES = JSON.parse(File.read( EC2_PROFILE_PATH ))
+
+    def make_task_running!( task_definition, overrides={} )
+      unless exists?
+        unless up!
+          raise "Failed to create the new cluster. You should check the CloudFormation events."
+        end
+      end
+
+      res = nil
+      3.times do
+        wait_until_ready
+        res = run_task!( task_definition, overrides )
+
+        if res.failures.empty?
+          break
+        else # Failure because some reasons
+          puts res.failures
+          case fail_reason(res.failures)
+          when "RESOURCE:MEMORY"
+            puts "No enough memory on current container instances to execute this task. Add another container instance automatically."
+
+            if num_instances >= max_instances
+              raise "Could\'t scale more instances because it reaches maximum instances. You should upgrade the maximum number of instance to execute multiple tasks at the same time."
+            end
+            unless acceptable_task?( task_definition )
+              raise "Could\'t accept this task because of the lack of memory. You should upgrade ec2 instance type."
+            end
+
+            scale!
+          else
+            raise "Unknown reason: #{res.failures}"
+          end
+        end
+      end
+
+      res
+    end
+
+    def acceptable_task?( task_definition )
+      # It preserves 128MB for ecs-agent
+      required_memory( task_definition ) <= current_instance_memory - (128*1024*1024)
+    end
+
+    private
+      def required_memory( task_definition )
+        res = ecs_client.describe_task_definition( task_definition: task_definition )
+        container_mems = res.task_definition.container_definitions.map(&:memory)
+        total_mem_mb = container_mems.inject(0){|sum,n| sum + n}
+        total_mem_mb * 1024 * 1024 # byte
+      end
+
+      def current_instance_memory
+        INSTANCE_TYPES[instance.type]["mem"] * 1024 * 1024 * 1024 # byte
+      end
+  end
+end

data/lib/ecs/easy/cluster/version.rb

@@ -0,0 +1,7 @@
+module Ecs
+  module Easy
+    module Cluster
+      VERSION = "0.0.1"
+    end
+  end
+end

data/lib/ecs/easy/configure.rb

@@ -0,0 +1,33 @@
+module Ecs
+  module Easy
+    class Configure
+
+      attr_accessor :profile, 
+        :access_key, 
+        :secret_key, 
+        :region, 
+        :compose_project_name_prefix, 
+        :compose_service_name_prefix, 
+        :cfn_stack_name_prefix
+
+      def initialize **params
+        @compose_project_name_prefix  = ""
+        @compose_service_name_prefix  = "ecscompose-service-"
+        @cfn_stack_name_prefix        = "amazon-ecs-cli-setup-"
+
+        params.each do |k,v|
+          self.send("#{k}=", v) if self.methods.include?(k)
+        end
+        yield( self ) if block_given?
+      end
+
+      def credentials
+        @credentials ||= profile ?
+          Aws::SharedCredentials.new( profile_name: profile ) :
+          Aws::Credentials.new( access_key, secret_key )
+        @credentials
+      end
+
+    end
+  end
+end

data/lib/ecs/easy/instance.rb

@@ -0,0 +1,63 @@
+module Ecs
+  module Easy
+    class Instance
+
+      attr_accessor :type, 
+        :keypair, 
+        :azs, # availability zones
+        :subnets, 
+        :vpc, 
+        :image_id, 
+        :security_group
+
+      def initialize **params
+        params.each do |k,v|
+          self.send("#{k}=", v) if self.methods.include?(k)
+        end
+        yield( self ) if block_given?
+      end
+
+      # Generate the parameters for cloudformation
+      def cfn_parameters( cluster_name, params={} )
+        base_params = [
+          {
+            parameter_key: "EcsAmiId",
+            parameter_value: image_id,
+          },
+          {
+            parameter_key: "EcsInstanceType",
+            parameter_value: type,
+          },
+          {
+            parameter_key: "KeyName",
+            parameter_value: keypair,
+          },
+          {
+            parameter_key: "VpcId",
+            parameter_value: vpc,
+          },
+          {
+            parameter_key: "SubnetIds",
+            parameter_value: subnets,
+          },
+          {
+            parameter_key: "SecurityGroup",
+            parameter_value: security_group,
+          },
+          {
+            parameter_key: "EcsCluster",
+            parameter_value: cluster_name,
+          },
+        ]
+        params.each do |k,v|
+          base_params << ({
+            "parameter_key" => k,
+            "parameter_value" => v,
+          })
+        end
+        base_params
+      end
+      
+    end
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: ecs-easy-cluster
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- metheglin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: easy-to-use AWS ECS Cluster.
+email:
+- pigmybank@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ecs-easy-cluster.gemspec
+- lib/ecs/easy/cluster.rb
+- lib/ecs/easy/cluster/base.rb
+- lib/ecs/easy/cluster/config/cloudformation_template.json
+- lib/ecs/easy/cluster/config/ec2_profile.json
+- lib/ecs/easy/cluster/mem_scale.rb
+- lib/ecs/easy/cluster/version.rb
+- lib/ecs/easy/configure.rb
+- lib/ecs/easy/instance.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: easy-to-use AWS ECS Cluster.
+test_files: []