activeaws 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f3553817e80b5e63cb169014e7fb85b821b2c91e
+  data.tar.gz: 1e7ba39337ee5bbac9ec98c88b68faac0ccda2f2
+SHA512:
+  metadata.gz: 2e3c6938011af3672e7a0f6617d95de3c62369b89b0b551edcc39935ab873a861f28895132204cf60861afe8aca72cd32605d3dd7313d1fb32a20f3aa0a470ad
+  data.tar.gz: d12ca44e3d2325f8ce4ccdb325c608336f8ef3f9993b631e9accc9b753501ac4e93ac8febe2a25c20fc7f1988f10abe28339b3311871ab42a102c34ae490afd9

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/README_MEMO.md

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in active_aws.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 metheglin
+
+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,117 @@
+# ActiveAws
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activeaws'
+```
+
+If you want to load this library automatically with `Bundler.require`, please specify `require` option at Gemfile.
+
+```ruby
+gem 'activeaws', require: 'active_aws'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install activeaws
+
+## Usage
+
+```ruby
+require 'active_aws'
+```
+
+### Initialize
+
+```rb
+ActiveAws::Base.load_config!(
+  region: 'ap-northeast-1',
+  profile: 'rv-metheglin',
+)
+```
+
+```rb
+ActiveAws::Base.load_config!( File.expand_path("./aws.yml", __dir__) )
+```
+
+### Ec2
+
+```rb
+provisioner = ActiveAws::Ec2Provisioner.new(:test_instance_name) do |e|
+  e.instance_type = 't2.nano'
+  e.key_name = 'your-credential-key-name-here'
+  e.image_id = 'ami-xxxxxx'
+  e.security_group_ids = ['sg-xxxxxxx']
+  e.subnet_id = 'subnet-xxxxxxx'
+end
+ec2 = provisioner.exec!
+ec2.wait_until :instance_running
+```
+
+```rb
+ec2 = ActiveAws::Ec2.find( 'your-instance-id' )
+ec2.to_h
+```
+
+### CloudFormation
+
+```rb
+# Prepare `vpc.json` with like:
+# Ex): https://aws-quickstart.s3-ap-northeast-1.amazonaws.com/quickstart-linux-bastion/submodules/quickstart-aws-vpc/templates/aws-vpc.template
+class VpcProduction < ActiveAws::CloudFormationProvisioner
+
+  class << self
+    def generate
+      new(
+        "your-cloudformation-stack-name-here",
+        File.expand_path("vpc.json", __dir__),
+        {
+          "AvailabilityZones"   => "ap-northeast-1a,ap-northeast-1c,ap-northeast-1d",
+          "KeyPairName"         => "your-credential-key-name-here",
+          "PrivateSubnet1CIDR"  => "10.0.0.0/19",
+          "PrivateSubnet2CIDR"  => "10.0.32.0/19",
+          "PublicSubnet1CIDR"   => "10.0.128.0/20",
+          "PublicSubnet2CIDR"   => "10.0.144.0/20",
+          "RemoteAccessCIDR"    => "0.0.0.0/0",
+          "VPCCIDR"             => "10.0.0.0/16",
+        }
+      )
+    end
+  end
+
+  # # Please carefully use this method!! 
+  # # The CloudFormationProvisioner class doesn't implement `destroy!` on purpose.
+  # def destroy!
+  #   self.class.client.delete_stack(stack_name: normalized_name)
+  # end
+
+end
+```
+
+```rb
+prov = VpcProduction.generate
+prov.save!
+prov.wait_until :stack_create_complete
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/metheglin/activeaws.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/active_aws.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "active_aws/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "activeaws"
+  spec.version       = ActiveAws::VERSION
+  spec.authors       = ["metheglin"]
+  spec.email         = ["pigmybank@gmail.com"]
+
+  spec.summary       = "Managing aws resources with active way."
+  spec.homepage      = "https://github.com/metheglin/activeaws"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against " \
+  #     "public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_dependency "activesupport", "~> 5"
+  spec.add_dependency "aws-sdk", "~> 2"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "active_aws"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/active_aws/base.rb

@@ -0,0 +1,54 @@
+require 'yaml'
+require_relative './configure'
+
+module ActiveAws
+  class Base
+
+    @attributes = []
+
+    class << self
+      attr_accessor :attributes
+      attr_reader :root_configure
+      
+      def inherited( klass )
+        klass.attributes = @attributes
+      end
+
+      def load_config!( args )
+        @config = if args.is_a? Hash
+          args
+        elsif File.file?( args.to_s )
+          YAML.load_file( args.to_s )
+        else
+          raise ArgumentError
+        end
+        @root_configure = Configure.new( **@config.symbolize_keys )
+      end
+
+      def configure
+        Base.root_configure
+      end
+    end
+
+    def initialize( **params )
+      self.class.attributes.each do |k|
+        method = "#{k}="
+        self.send(method, params[k]) if params[k].present?
+      end
+      yield( self ) if block_given?
+    end
+
+    def name
+      name_tag = tags.detect{|t| t[:key].to_s == "Name"}
+      return nil unless name_tag
+      name_tag[:value]
+    end
+
+    def to_h
+      self.class.attributes.reduce({}) do |acc,k|
+        acc[k] = self.send( k )
+        acc
+      end
+    end
+  end
+end

data/lib/active_aws/cloud_formation_provisioner.rb

@@ -0,0 +1,77 @@
+module ActiveAws
+  class CloudFormationProvisioner < Base
+
+    attr_reader :name, :template_path, :parameters
+
+    class << self
+      def client
+        Aws::CloudFormation::Client.new( **configure.default_client_params )
+      end
+
+      def find( stack_name )
+        response = client.describe_stacks( stack_name: stack_name )
+      end
+    end
+
+    def initialize( name, template_path, parameters={} )
+      @name = name
+      @template_path = template_path
+      @parameters = parameters
+    end
+
+    def template_body
+      @template_body ||= File.read( template_path )
+    end
+
+    def normalized_name
+      # self.class.configure.cfn_stack_name_prefix + name
+      name
+    end
+
+    def normalized_parameters
+      parameters.map do |k,v|
+        {
+          parameter_key: k,
+          parameter_value: v,
+        }
+      end
+    end
+
+    def to_h
+      {
+        stack_name: normalized_name,
+        template_body: template_body,
+        parameters: normalized_parameters,
+        capabilities: ["CAPABILITY_IAM"],
+        # on_failure: "DELETE",
+      }
+    end
+
+    def exists?
+      res = self.class.client.describe_stacks( stack_name: normalized_name )
+      return res.stacks.length > 0
+    rescue => e
+      return false
+    end
+
+    def save!
+      response = if exists?
+        self.class.client.update_stack( self.to_h )
+      else
+        self.class.client.create_stack( self.to_h )
+      end
+    end
+
+    # `waiter_name` can be checked with the command below.
+    # ActiveAws::CloudFormationProvisioner.client.waiter_names
+    # 
+    # Usage:
+    # prov.wait_until :instance_running do |i|
+    #   i.max_attempts = 5
+    #   i.delay = 5
+    # end
+    def wait_until( waiter_name, &block )
+      self.class.client.wait_until(waiter_name, stack_name: normalized_name, &block)
+    end
+  end
+end

data/lib/active_aws/configure.rb

@@ -0,0 +1,29 @@
+module ActiveAws
+  class Configure
+    attr_accessor :profile, 
+      :access_key, 
+      :secret_key, 
+      :region
+
+    def initialize( **params )
+      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
+
+    def default_client_params
+      {
+        region: region,
+        credentials: credentials,
+      }
+    end
+  end
+end

data/lib/active_aws/ec2.rb

@@ -0,0 +1,89 @@
+module ActiveAws
+  class Ec2 < Base
+
+    @attributes = [
+      :block_device_mappings,
+      :image_id, :instance_id, :instance_type, :key_name,
+      :launch_time, :network_interfaces, 
+      :private_ip_address, :private_dns_name,
+      :public_ip_address, :public_dns_name,
+      :root_device_name, :security_groups, :subnet_id, :tags, :vpc_id,
+    ]
+
+    attr_accessor *attributes
+
+    class << self
+      def client
+        Aws::EC2::Client.new( **configure.default_client_params )
+      end
+
+      def find( instance_id )
+        response = client.describe_instances({
+          instance_ids: [instance_id], 
+        })
+        return nil unless response.reservations[0]
+        new( **response.reservations[0].instances[0].to_h )
+      end
+
+      def find_by_name( name )
+        response = client.describe_instances({
+          filters: [{ name: "tag:Name", values: [name] }], 
+        })
+        return nil unless response.reservations[0]
+        new( **response.reservations[0].instances[0].to_h )
+      end
+
+      # Usage:
+      # Ec2::where( :"tag:Role" => "web" )
+      # Ec2::where( :"instance-type" => "t2.micro" )
+      def where( **args )
+        filter_params = args.map{|k, v| { name: k, values: Array.wrap(v) }}
+        response = client.describe_instances({
+          filters: filter_params, 
+        })
+        instance_params = response.reservations.map{|r| r.instances }.flatten
+        instance_params.map{|i| new( **i.to_h )}
+      end
+    end
+
+    def name
+      name_tag = tags.detect{|t| t[:key].to_s == "Name"}
+      return nil unless name_tag
+      name_tag[:value]
+    end
+
+    def reload
+      self.class.find( instance_id )
+    end
+
+    def create_image!( name: nil, description: nil, no_reboot: true, block_device_mappings: nil )
+      name ||= "#{self.name}-#{Time.current.strftime('%Y%m%d%H%M')}"
+      description ||= name
+      block_device_mappings ||= [{
+        device_name: '/dev/xvda',
+        ebs: {
+          volume_size: 8,
+        },
+      }]
+      self.class.client.create_image({
+        block_device_mappings: block_device_mappings,
+        description: description,
+        instance_id: instance_id,
+        name: name,
+        no_reboot: no_reboot,
+      })
+    end
+
+    # `waiter_name` can be checked with the command below.
+    # ActiveAws::Ec2.client.waiter_names
+    # 
+    # Usage:
+    # ec2.wait_until :instance_running do |i|
+    #   i.max_attempts = 5
+    #   i.delay = 5
+    # end
+    def wait_until( waiter_name=:instance_running, &block )
+      self.class.client.wait_until(waiter_name, instance_ids: [instance_id], &block)
+    end
+  end
+end

data/lib/active_aws/ec2_provisioner.rb

@@ -0,0 +1,76 @@
+module ActiveAws
+  class Ec2Provisioner < Base
+
+    ATTRIBUTES = [
+      :instance_type, 
+      :key_name, 
+      :image_id, 
+      :security_group_ids,
+      :subnet_id,
+      :user_data,
+      :block_device_mappings,
+      :tag_specifications,
+      :network_interfaces,
+      :launch_template,
+    ]
+
+    attr_accessor :name
+    attr_accessor *ATTRIBUTES
+    attr_reader :tag_specs
+
+    def initialize( name, **params )
+      @name = name
+
+      ATTRIBUTES.each do |k|
+        method = "#{k}="
+        self.send(method, params[k]) if params[k].present?
+      end
+
+      yield( self ) if block_given?
+    end
+
+    def tag_specs
+      specifications = @tag_specifications || []
+      unless specifications.detect{|a| a[:resource_type] == "instance"}
+        specifications << {
+          resource_type: "instance",
+          tags: []
+        }
+      end
+      TagSpec.parse( specifications )
+    end
+
+    def exec!( extra_tags={} )
+      ec2 = ActiveAws::Ec2.find_by_name( name )
+      return ec2 if ec2
+      forced_exec!( extra_tags )
+    end
+
+    def forced_exec!( extra_tags={} )
+      client = ActiveAws::Ec2.client
+      response = client.run_instances( self.to_h )
+      ActiveAws::Ec2.new( **response.instances[0] )
+    end
+
+    def to_h( extra_tags={} )
+      extra_tags = extra_tags.merge({ "Name" => self.name })
+      attrs = ATTRIBUTES.reduce({}) do |acc,k|
+        acc[k] = self.send( k )
+        acc
+      end
+      attrs = attrs.merge(
+        max_count: 1,
+        min_count: 1,
+        tag_specifications: tag_specs.map {|ts|
+          ts = if ts.resource_type == "instance"
+            ts.merge( extra_tags )
+          else
+            ts
+          end
+          ts.to_param
+        }
+      )
+      attrs
+    end
+  end
+end

data/lib/active_aws/elastic_load_balancing_v2.rb

@@ -0,0 +1,60 @@
+module ActiveAws
+  class ElasticLoadBalancingV2 < Base
+    @attributes = [
+      :load_balancer_arn,
+      :dns_name, :canonical_hosted_zone_id, :created_time, 
+      :load_balancer_name,
+      :scheme, :vpc_id, 
+      :state, :type, :availability_zones,
+      :security_groups
+    ]
+
+    attr_accessor *attributes
+
+    class << self
+      def client
+        Aws::ElasticLoadBalancingV2::Client.new( **configure.default_client_params )
+      end
+
+      def find( load_balancer_arn )
+        response = client.describe_load_balancers({
+          load_balancer_arns: [load_balancer_arn], 
+        })
+        return nil unless response
+        new( **response.load_balancers[0].to_h )
+      end
+
+      def find_by_name( name )
+        response = client.describe_load_balancers({
+          names: [name], 
+        })
+        return nil unless response
+        new( **response.load_balancers[0].to_h )
+      end
+    end
+
+    def name
+      load_balancer_name
+    end
+
+    def reload
+      self.class.find( load_balancer_arn )
+    end
+
+    def target_groups
+      TargetGroup.where( load_balancer_arn: load_balancer_arn )
+    end
+
+    # `waiter_name` can be checked with the command below.
+    # ActiveAws::ElasticLoadBalancingV2.client.waiter_names
+    # 
+    # Usage:
+    # alb.wait_until :load_balancer_available do |i|
+    #   i.max_attempts = 5
+    #   i.delay = 5
+    # end
+    def wait_until( waiter_name=:load_balancer_available, &block )
+      self.class.client.wait_until(waiter_name, load_balancer_arns: [load_balancer_arn], &block)
+    end
+  end
+end

data/lib/active_aws/tag_spec.rb

@@ -0,0 +1,37 @@
+module ActiveAws
+  class TagSpec
+
+    class << self
+      def parse( tag_specifications )
+        tag_specifications.map do |spec|
+          spec = spec.deep_symbolize_keys
+          self.new(
+            spec[:resource_type], 
+            spec[:tags].map{|t| [t[:key], t[:value]]}.to_h 
+          )
+        end
+      end
+    end
+
+    attr_reader :resource_type, :tags
+    def initialize( resource_type, tags )
+      @resource_type = resource_type
+      @tags = tags
+    end
+
+    def add_tag!( key, value )
+      @tags[key.to_s] = value
+    end
+
+    def merge( extra_tags )
+      self.class.new( resource_type, tags.merge(extra_tags) )
+    end
+
+    def to_param
+      {
+        resource_type: resource_type,
+        tags: tags.map{|k,v| { key: k, value: v}}
+      }
+    end
+  end
+end

data/lib/active_aws/target_group.rb

@@ -0,0 +1,92 @@
+module ActiveAws
+  class TargetGroup < Base
+
+    @attributes = [
+      :target_group_arn,
+      :target_group_name, 
+      :protocol, :port, :vpc_id,
+      :health_check_protocol, :health_check_port, 
+      :health_check_interval_seconds, :health_check_timeout_seconds,
+      :healthy_threshold_count, :unhealthy_threshold_count,
+      :health_check_path, :matcher, 
+      :load_balancer_arns, :load_balancer_arns, 
+      :target_type,
+    ]
+
+    attr_accessor *attributes
+
+    class << self
+      def client
+        Aws::ElasticLoadBalancingV2::Client.new( **configure.default_client_params )
+      end
+
+      def find( target_group_arn )
+        response = client.describe_target_groups({
+          target_group_arns: [target_group_arn], 
+        })
+        return nil unless response
+        new( **response.target_groups[0].to_h )
+      end
+
+      def find_by_name( name )
+        response = client.describe_target_groups({
+          names: [name], 
+        })
+        return nil unless response
+        new( **response.target_groups[0].to_h )
+      end
+
+      # Usage:
+      # where( load_balancer_arn: ["xxxx"] )
+      def where( **args )
+        filter_params = args.map{|k, v| { name: k, values: Array.wrap(v) }}
+        response = client.describe_target_groups( args )
+        response.target_groups.map{|i| new( **i.to_h )}
+      end
+    end
+
+    def name
+      target_group_name
+    end
+
+    def reload
+      self.class.find( target_group_arn )
+    end
+
+    def health_descriptions
+      response = self.class.client.describe_target_health({
+        target_group_arn: target_group_arn
+      })
+      response.target_health_descriptions
+    end
+
+    def target_ids
+      health_descriptions.map{|a| a.target.id }
+    end
+
+    def register!( ids )
+      response = self.class.client.register_targets({
+        target_group_arn: target_group_arn,
+        targets: ids.map{|a| { id: a }}, 
+      })
+    end
+
+    def deregister!( ids )
+      response = self.class.client.deregister_targets({
+        target_group_arn: target_group_arn,
+        targets: ids.map{|a| { id: a }}, 
+      })
+    end
+
+    def set!( ids )
+      present_ids     = target_ids
+      register_ids    = ids.select{|a| ! present_ids.include?( a ) }
+      deregister_ids  = present_ids.select{|a| ! ids.include?( a ) }
+      # pp register_ids
+      # pp deregister_ids
+      register!( register_ids ) if register_ids.present?
+      deregister!( deregister_ids ) if deregister_ids.present?
+      target_ids
+    end
+  end
+end

data/lib/active_aws/version.rb

@@ -0,0 +1,3 @@
+module ActiveAws
+  VERSION = "0.1.0"
+end

data/lib/active_aws.rb

@@ -0,0 +1,17 @@
+require "active_aws/version"
+
+require 'aws-sdk'
+require 'active_support'
+require 'active_support/core_ext'
+
+require_relative 'active_aws/configure'
+require_relative 'active_aws/base'
+require_relative 'active_aws/tag_spec'
+require_relative 'active_aws/ec2'
+require_relative 'active_aws/ec2_provisioner'
+require_relative 'active_aws/cloud_formation_provisioner'
+require_relative 'active_aws/elastic_load_balancing_v2'
+require_relative 'active_aws/target_group'
+
+module ActiveAws
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: activeaws
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- metheglin
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+description: 
+email:
+- pigmybank@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- active_aws.gemspec
+- bin/console
+- bin/setup
+- lib/active_aws.rb
+- lib/active_aws/base.rb
+- lib/active_aws/cloud_formation_provisioner.rb
+- lib/active_aws/configure.rb
+- lib/active_aws/ec2.rb
+- lib/active_aws/ec2_provisioner.rb
+- lib/active_aws/elastic_load_balancing_v2.rb
+- lib/active_aws/tag_spec.rb
+- lib/active_aws/target_group.rb
+- lib/active_aws/version.rb
+homepage: https://github.com/metheglin/activeaws
+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.6.11
+signing_key: 
+specification_version: 4
+summary: Managing aws resources with active way.
+test_files: []