capistrano-elb-autoscaling 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9414a155b6afd51ac1d0a5357cab5599baf5c51bc4efeaf601d16acd54c310c0
+  data.tar.gz: c68a44e88ca7dedbf8072d932687a4385e966d5f0a58af39620a53254b3ad826
+SHA512:
+  metadata.gz: 3ccc33d9417dcefd95575116cadac35ca400cc9ab849894d81286419f7fafa77986dc3bc86d47d9b3e5b9bff4e7f89e9e311b34ad88c0ed65f7322b936178ef0
+  data.tar.gz: f77880fe0f5974c425646278a031f00075d02826e5dcb7e521bdcd1522eb378288a222993e6e269e8347050fb532ff22b2b646badbdb7d181ed5c826868c8d46

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,20 @@
+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,97 @@
+*Versions < 3 of ELBAS are no longer being maintained. I will only be maintaining the current feature-set which relies on Launch Templates and AWS SDK v3.*
+
+# Capistrano ELBAS (Elastic Load Balancer & AutoScaling)
+
+[![Gem Version](https://badge.fury.io/rb/elbas.svg)](https://badge.fury.io/rb/elbas)
+
+ELBAS was written to ease the deployment of Rails applications to AWS AutoScale
+groups. During your Capistrano deployment, ELBAS will:
+
+- Deploy your code to each running instance connected to a given AutoScale group
+- After deployment, create an AMI from one of the running instances
+- Update the AutoScale group's launch template with the AMI ID
+- Delete any outdated AMIs created by previous ELBAS deployments
+
+## Installation
+
+Add to Gemfile, then `bundle`:
+
+`gem 'elbas'`
+
+Add to Capfile:
+
+`require 'elbas/capistrano'`
+
+## Configuration
+
+Setup AWS credentials:
+
+```ruby
+set :aws_access_key, ENV['AWS_ACCESS_KEY_ID']
+set :aws_secret_key, ENV['AWS_SECRET_ACCESS_KEY']
+set :aws_region,     ENV['AWS_REGION']
+```
+
+## Usage
+
+Instead of using Capistrano's `server` method, use `autoscale` instead in
+`deploy/<environment>.rb` (replace <environment> with your environment). Provide
+the name of your AutoScale group instead of a hostname:
+
+```ruby
+autoscale 'my-autoscale-group', user: 'apps', roles: [:app, :web, :db]
+```
+
+If you have multiple autoscaling groups to deploy to, specify each of them:
+
+```ruby
+autoscale 'app-autoscale-group', user: 'apps', roles: [:app, :web]
+autoscale 'worker-autoscale-group', user: 'apps', roles: [:worker]
+```
+
+Run `cap production deploy`.
+
+**As of version 3, your AWS setup must use launch templates as opposed to launch
+configurations.** This allows ELBAS to simply create a new launch template version
+with the new AMI ID after a deployment. It no longer needs to update your
+AutoScale group or mess around with network settings, instance sizes, etc., as
+that information is all contained within the launch template. Failure to use a
+launch template will result in a `Elbas::Errors::NoLaunchTemplate` error.
+
+### Customizing Server Properties
+
+You can pass a block to `autoscale` and return properties for any specific server.
+The block accepts the server and the server's index as arguments.
+
+For example, if you want to apply the `:db` role to only the first server:
+
+```ruby
+autoscale 'my-autoscale-group', roles: [:app, :web] do |server, i|
+  { roles: [:app, :web, :db] } if i == 0
+end
+```
+
+Returning `nil` from this block will cause the server to use the properties
+passed to `autoscale`.
+
+Returning anything but `nil` will override the entire properties hash (as
+opposed to merging the two hashes together).
+
+### Listing Servers
+
+You may need to SSH into your servers while debugging deployed code, and
+not everyone has a jumpbox on a basic AutoScaling setup. ELBAS provides a command
+that will list the `ssh` command necessary to connect to each server in any given
+environment:
+
+```
+cap production elbas:ssh
+```
+
+Output will be something like:
+
+```
+[ELBAS] Adding server: ec2-12-34-567-890.compute-1.amazonaws.com
+[ELBAS] SSH commands:
+[ELBAS]     1) ssh deploy@ec2-12-34-567-890.compute-1.amazonaws.com
+```

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+task :default => :spec
+RSpec::Core::RakeTask.new

data/elbas.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'elbas/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'capistrano-elb-autoscaling'
+  spec.version       = Elbas::VERSION
+  spec.authors       = ['Heng Gek']
+  spec.email         = ['tanhengegk@gmail.com']
+  spec.summary       = 'Capistrano plugin for deploying to AWS Auto Scaling Group.'
+  spec.description   = spec.summary
+  spec.homepage      = 'https://github.com/tanhenggek/capistrano-elb-autoscaling'
+  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_development_dependency 'bundler'
+  spec.add_development_dependency 'byebug'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'webmock-rspec-helper'
+
+  spec.add_dependency 'aws-sdk-autoscaling', '~> 1'
+  spec.add_dependency 'aws-sdk-ec2', '~> 1'
+  spec.add_dependency 'capistrano', '> 3'
+end

data/lib/elbas/aws/ami.rb

@@ -0,0 +1,71 @@
+module Elbas
+  module AWS
+    class AMI < Base
+      include Taggable
+
+      DEPLOY_ID_TAG = 'ELBAS-Deploy-id'.freeze
+      DEPLOY_GROUP_TAG = 'ELBAS-Deploy-group'.freeze
+
+      attr_reader :id, :snapshots
+
+      def initialize(id, snapshots = [])
+        @id = id
+        @aws_counterpart = ::Aws::EC2::Image.new id, client: aws_client
+
+        @snapshots = snapshots.map do |snapshot|
+          Elbas::AWS::Snapshot.new snapshot&.ebs&.snapshot_id
+        end
+      end
+
+      def deploy_id
+        tags[DEPLOY_ID_TAG]
+      end
+
+      def deploy_group
+        tags[DEPLOY_GROUP_TAG]
+      end
+
+      def ancestors
+        aws_amis_in_deploy_group.select { |aws_ami|
+          deploy_id_from_aws_tags(aws_ami.tags) != deploy_id
+        }.map { |aws_ami|
+          self.class.new aws_ami.image_id, aws_ami.block_device_mappings
+        }
+      end
+
+      def delete
+        aws_client.deregister_image image_id: id
+        snapshots.each(&:delete)
+      end
+
+      def self.create(instance, no_reboot: true)
+        ami = instance.aws_counterpart.create_image({
+          name: "ELBAS-ami-#{Time.now.to_i}",
+          instance_id: instance.id,
+          no_reboot: no_reboot
+        })
+
+        new ami.id
+      end
+
+      private
+        def aws_namespace
+          ::Aws::EC2
+        end
+
+        def aws_amis_in_deploy_group
+          aws_client.describe_images({
+            owners: ['self'],
+            filters: [{
+              name: "tag:#{DEPLOY_GROUP_TAG}",
+              values: [deploy_group],
+            }]
+          }).images
+        end
+
+        def deploy_id_from_aws_tags(tags)
+          tags.detect { |tag| tag.key == DEPLOY_ID_TAG }&.value
+        end
+    end
+  end
+end

data/lib/elbas/aws/autoscale_group.rb

@@ -0,0 +1,52 @@
+module Elbas
+  module AWS
+    class AutoscaleGroup < Base
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+        @aws_counterpart = query_autoscale_group_by_name(name)
+      end
+
+      def instance_ids
+        aws_counterpart.instances.map(&:instance_id)
+      end
+
+      def instances
+        InstanceCollection.new instance_ids
+      end
+
+      def launch_template
+        lts = aws_launch_template || aws_launch_template_specification
+        raise Elbas::Errors::NoLaunchTemplate unless lts
+
+        LaunchTemplate.new(
+          lts.launch_template_id,
+          lts.launch_template_name,
+          lts.version
+        )
+      end
+
+      private
+        def aws_namespace
+          ::Aws::AutoScaling
+        end
+
+        def query_autoscale_group_by_name(name)
+          aws_client
+            .describe_auto_scaling_groups(auto_scaling_group_names: [name])
+            .auto_scaling_groups
+            .first
+        end
+
+        def aws_launch_template
+          aws_counterpart.launch_template
+        end
+
+        def aws_launch_template_specification
+          aws_counterpart.mixed_instances_policy&.launch_template
+            &.launch_template_specification
+        end
+    end
+  end
+end

data/lib/elbas/aws/base.rb

@@ -0,0 +1,39 @@
+module Elbas
+  module AWS
+    class Base
+      include Capistrano::DSL
+
+      attr_reader :aws_counterpart
+
+      def aws_client(namespace = aws_namespace)
+        @aws_client ||= begin
+          options = {}
+          options[:region] = aws_region if aws_region
+          options[:credentials] = aws_credentials if aws_credentials.set?
+
+          namespace::Client.new options
+        end
+      end
+
+      def aws_credentials
+        fetch :aws_credentials, ::Aws::Credentials.new(aws_access_key, aws_secret_key)
+      end
+
+      def aws_access_key
+        fetch :aws_access_key
+      end
+
+      def aws_secret_key
+        fetch :aws_secret_key
+      end
+
+      def aws_region
+        fetch :aws_region
+      end
+
+      def self.aws_client(namespace = aws_namespace)
+        Base.new.aws_client namespace
+      end
+    end
+  end
+end

data/lib/elbas/aws/instance.rb

@@ -0,0 +1,29 @@
+module Elbas
+  module AWS
+    class Instance < Base
+      STATE_RUNNING = 16.freeze
+
+      attr_reader :aws_counterpart, :id, :state
+
+      def initialize(id, public_dns, state)
+        @id = id
+        @public_dns = public_dns
+        @state = state
+        @aws_counterpart = aws_namespace::Instance.new id, client: aws_client
+      end
+
+      def hostname
+        @public_dns
+      end
+
+      def running?
+        state == STATE_RUNNING
+      end
+
+      private
+        def aws_namespace
+          ::Aws::EC2
+        end
+    end
+  end
+end

data/lib/elbas/aws/instance_collection.rb

@@ -0,0 +1,35 @@
+module Elbas
+  module AWS
+    class InstanceCollection < Base
+      include Enumerable
+
+      attr_reader :instances
+
+      def initialize(ids)
+        @ids = ids
+        @instances = query_instances_by_ids(ids).map do |i|
+          Instance.new(i.instance_id, i.public_dns_name, i.state.code)
+        end
+      end
+
+      def running
+        select(&:running?)
+      end
+
+      def each(&block)
+        instances.each(&block)
+      end
+
+      private
+        def aws_namespace
+          ::Aws::EC2
+        end
+
+        def query_instances_by_ids(ids)
+          aws_client
+            .describe_instances(instance_ids: @ids)
+            .reservations.flat_map(&:instances)
+        end
+    end
+  end
+end

data/lib/elbas/aws/launch_template.rb

@@ -0,0 +1,39 @@
+module Elbas
+  module AWS
+    class LaunchTemplate < Base
+      attr_reader :id, :name, :version
+
+      def initialize(id, name, version)
+        @id = id
+        @name = name
+        @version = version
+      end
+
+      def update(ami)
+        latest = aws_client.create_launch_template_version({
+          launch_template_data: { image_id: ami.id },
+          launch_template_id: self.id,
+          source_version: self.version
+        }).launch_template_version
+
+        response = aws_client.modify_launch_template({
+          default_version: latest.version_number.to_s,
+          launch_template_id: latest.launch_template_id
+        })
+        return unless response.successful?
+
+        self.class.new(
+          latest&.launch_template_id,
+          latest&.launch_template_name,
+          latest&.version_number
+        )
+      end
+
+      private
+
+      def aws_namespace
+        ::Aws::EC2
+      end
+    end
+  end
+end

data/lib/elbas/aws/snapshot.rb

@@ -0,0 +1,21 @@
+module Elbas
+  module AWS
+    class Snapshot < Base
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+      end
+
+      def delete
+        return unless id
+        aws_client.delete_snapshot snapshot_id: id
+      end
+
+      private
+        def aws_namespace
+          ::Aws::EC2
+        end
+    end
+  end
+end

data/lib/elbas/aws/taggable.rb

@@ -0,0 +1,18 @@
+module Elbas
+  module AWS
+    module Taggable
+      def tag(key, value)
+        @tags ||= {}
+
+        Elbas::Retryable.times(3).delay(5) do
+          aws_counterpart.create_tags tags: [{ key: key, value: value }]
+          @tags[key] = value
+        end
+      end
+
+      def tags
+        @tags || {}
+      end
+    end
+  end
+end

data/lib/elbas/capistrano.rb

@@ -0,0 +1,34 @@
+require 'capistrano/dsl'
+
+load File.expand_path("../tasks/elbas.rake", __FILE__)
+
+def autoscale(groupname, properties = {})
+  include Capistrano::DSL
+  include Elbas::Logger
+
+  set :aws_autoscale_group_names, Array(fetch(:aws_autoscale_group_names)).push(groupname)
+
+  asg = Elbas::AWS::AutoscaleGroup.new groupname
+  instances = asg.instances.running
+
+  info "Auto Scaling Group: #{groupname}"
+  instances.each.with_index do |instance, i|
+    info "Adding server: #{instance.hostname}"
+
+    props = nil
+    props = yield(instance, i) if block_given?
+    props ||= properties
+
+    server instance.hostname, props
+  end
+
+  if instances.any?
+    after 'deploy', 'elbas:deploy'
+  else
+    error <<~MESSAGE
+      Could not create AMI because no running instances were found in the specified
+      AutoScale group. Ensure that the AutoScale group name is correct and that
+      there is at least one running instance attached to it.
+    MESSAGE
+  end
+end

data/lib/elbas/errors/no_launch_template.rb

@@ -0,0 +1,6 @@
+module Elbas
+  module Errors
+    class NoLaunchTemplate < StandardError
+    end
+  end
+end

data/lib/elbas/logger.rb

@@ -0,0 +1,38 @@
+require 'capistrano/doctor/output_helpers'
+
+module Elbas
+  module Logger
+    include Capistrano::Doctor::OutputHelpers
+
+    PREFIX_TEXT = '[ELBAS] '.freeze
+
+    def info(message)
+      $stdout.puts [prefix, message, "\n"].join
+    end
+
+    def error(message)
+      $stderr.puts [error_prefix, message, "\n"].join
+    end
+
+    private
+      def prefix
+        @prefix ||= cyan(PREFIX_TEXT)
+      end
+
+      def error_prefix
+        @error_prefix ||= red(PREFIX_TEXT)
+      end
+
+      def cyan(text)
+        color_text text, :cyan
+      end
+
+      def red(text)
+        color_text text, :red
+      end
+
+      def color_text(text, coloring)
+        color.colorize text, coloring
+      end
+  end
+end

data/lib/elbas/retryable.rb

@@ -0,0 +1,41 @@
+module Elbas
+  class Retryable
+    include Elbas::Logger
+
+    def initialize
+      @max = 0
+      @delay = 0
+    end
+
+    def times(max, &block)
+      @max = max
+      run block if block_given?
+    end
+
+    def delay(seconds, &block)
+      @delay = seconds
+      run block if block_given?
+    end
+
+    def run(proc)
+      attempts ||= 0
+      attempts += 1
+      proc.call
+    rescue => e
+      info "Rescued error in retryable action: #{e.message}"
+      if attempts < @max
+        info "Retrying in #{@delay} seconds..."
+        sleep @delay
+        retry
+      end
+    end
+
+    def self.times(max, &block)
+      new.tap { |r| r.times max }
+    end
+
+    def self.delay(seconds, &block)
+      new.tap { |r| r.delay seconds }
+    end
+  end
+end

data/lib/elbas/tasks/elbas.rake

@@ -0,0 +1,38 @@
+require 'elbas'
+include Elbas::Logger
+
+namespace :elbas do
+  task :ssh do
+    include Capistrano::DSL
+
+    info "SSH commands:"
+    env.servers.to_a.each.with_index do |server, i|
+      info "    #{i + 1}) ssh #{fetch(:user)}@#{server.hostname}"
+    end
+  end
+
+  task :deploy do
+    fetch(:aws_autoscale_group_names).each do |aws_autoscale_group_name|
+      info "Auto Scaling Group: #{aws_autoscale_group_name}"
+      asg = Elbas::AWS::AutoscaleGroup.new aws_autoscale_group_name
+
+      info "Creating AMI from a running instance..."
+      ami = Elbas::AWS::AMI.create asg.instances.running.sample
+      ami.tag 'ELBAS-Deploy-group', asg.name
+      ami.tag 'ELBAS-Deploy-id', env.timestamp.to_i.to_s
+      info  "Created AMI: #{ami.id}"
+
+      info "Updating launch template with the new AMI..."
+      launch_template = asg.launch_template.update ami
+      info "Updated launch template, new default version = #{launch_template.version}"
+
+      info "Cleaning up old AMIs..."
+      ami.ancestors.each do |ancestor|
+        info "Deleting old AMI: #{ancestor.id}"
+        ancestor.delete
+      end
+
+      info "Deployment complete!"
+    end
+  end
+end

data/lib/elbas/version.rb

@@ -0,0 +1,3 @@
+module Elbas
+  VERSION = '1.0.0'.freeze
+end