ec2_bootstrap 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 50318b3c980d39aa1255261e3721ebcd5b167731
-  data.tar.gz: 4a43edf57231b9a9b5368f933f6925e3e08ce995
+  metadata.gz: 2edaecb9c4791dfaf2c8135fd9cfa8409f97d7c4
+  data.tar.gz: e40fbe8bcb044cc1671a3b684c95222c95ca5f26
 SHA512:
-  metadata.gz: 1395ad633953e8d5c09a39e55c0a81e0089df51dae759fb1672373556d80223150d86a21eae4dcb16fb3e06affeddf97eb149cb07d600c60a101bcd9222a9443
-  data.tar.gz: ad1a5bacefbeb3a9de43c9885fc6c0e50ab994bde1e37abf6b71a1c85c2aad1cdd7546ed68c9b0f62d16e93a48abe3999f23821c6919c295bc21f974b80b8626
+  metadata.gz: 939212801a7d6420941bba382494be32d2d1dca9be73b7b0cfc92840449b450b01f016ce98188e0245761354a4b2dc53afb9514eaee11e39bbd3d3ee72cc151d
+  data.tar.gz: a5c366803c0bd12bf50e96e8845d2fb1b923698eeb9e78aa0e9acb62c9af2560ac34ba60aa3c7f73a05896a0ec5069ea1c260a88440442225d37a98612842b12

data/README.md

@@ -20,16 +20,33 @@ Or install it yourself as:
 
 ## Configuration
 
-Requires AWS credentials in a format compatible with the [EC2 Knife plugin](https://github.com/chef/knife-ec2/blob/master/README.md).
+This is a simple gem that wraps the functionality of the [EC2 Knife plugin](https://github.com/chef/knife-ec2/blob/master/README.md) and the [aws-sdk gem](https://github.com/aws/aws-sdk-ruby). As a result, there is very little code and a very fussy config file.
 
-Also requires a YAML config file that looks like the example `config.example.yml`. The config file must include a top-level `nodes` key whose value is an array of hashes. Each node must include the keys `node_name` and `knife_ec2_flags`.
+### Required Config
+
+Requires AWS credentials in a format compatible with the EC2 Knife plugin.
+
+Also requires a YAML config file that looks like the example `config.example.yml`. The config file must include a top-level `instances` key whose value is an array of hashes. Each individual instance must include the keys `instance_name` and `knife_ec2_flags`. The latter is a hash of flags that are passed directly to Knife EC2. The `private-ip-address` flag is required. Each instance also requires the `image` flag, but if you include a `default_ami` section at the top level of your config, `ec2_bootstrap` will set a default AMI so you don't need to define an image for each instance (see "Optional Config" below for more info). To check what flags are currently accepted by Knife EC2, run:
+
+	$ knife ec2 server create --help
+
+For any `knife_ec2_flags` values that are lists, they need to be formatted as one long string with values separated by commas. Ex: `security-group-ids: sg-12345678,sg-abcdef12`.
+
+### Optional Config
 
 You may also want to include some form of cloud-init config. To do this, you can do one of two things:
 
-1. Include a top-level `cloud_config` key with the contents you'd like in the cloud config files used for each node, and ec2_bootstrap will generate separate config files for each node that all include the node's hostname and fqdn.
-2. If you'd prefer to write your own cloud config files, you can include the cloud config's path in a `user-data` key in the node's `knife_ec2_flags` hash.
+1. Include the cloud config's path in a `user-data` key in the `knife_ec2_flags` hash for every instance.
+2. Include a top-level `cloud_config` key with the contents you'd like in the cloud config files used for each node. `ec2_bootstrap` will use this to generate separate config files for each node that all include the node's hostname and fqdn. This will be used as the default cloud-init config for any instances that don't have their own defined.
+
+The Knife EC2 plugin does not currently support passing in a JSON attributes file. As a result, if you'd like to pass in a JSON attributes file without having to parse it yourself, you can include the `json_attributes_file` key in an instance's hash. Alternatively, you can include the JSON directly by adding it under the `json-attributes` key in the instance's `knife_ec2_flags`. The `json-attributes` key in `knife_ec2_flags` takes precedence over the `json_attributes_file` key.
+
+For the `image` flag within an instance's `knife_ec2_flags`, you have two choices:
+
+1. Include the flag for every instance.
+2. Include a top-level `default_ami` hash. `ec2_bootstrap` will use the parameters within `default_ami` to search for the most recent available AMI that matches your criteria, then will use that image when as the default for any instances that don't have their own `image` field defined.
 
-For any `knife_EC2_flags` values that are lists, they need to be formatted as one long string with values separated by commas. Ex: `security-group-ids: sg-12345678,sg-abcdef12`.
+You can add any of the options listed in [Amazon's aws-sdk gem docs](http://docs.aws.amazon.com/sdkforruby/api/Aws/EC2/Resource.html#images-instance_method) to search for AMIs through `ec2_bootstrap`. If you don't include a `region` key, `ec2_bootstrap` will default to us-east-1. If you choose to include `filters`, it should be a hash where all values are arrays. All other keys besides `region` and `filters` should also have arrays as values.
 
 ## Usage
 

data/bin/ec2_bootstrap

@@ -36,4 +36,4 @@ unless config_file
 	exit 1
 end
 
-EC2Bootstrap.from_config_file(config_file, options[:dryrun], options[:verbose]).create_instances
+EC2Bootstrap.from_config_file(config_file, dryrun: options[:dryrun], verbose: options[:verbose]).create_instances

data/lib/ec2_bootstrap.rb

@@ -4,39 +4,61 @@ require 'logger'
 
 require 'ec2_bootstrap/version'
 require 'ec2_bootstrap/instance'
+require 'ec2_bootstrap/ami'
 
 class EC2Bootstrap
 
-	attr_accessor :cloud_config
-	attr_accessor :instances
 	attr_accessor :dryrun
+	attr_accessor :cloud_config
+	attr_accessor :instances_config
+	attr_accessor :default_ami_config
 
-	def initialize(config, dryrun=true, verbose=false)
-		@logger = Logger.new(STDOUT)
-		verbose ? @logger.level = Logger::DEBUG : @logger.level = Logger::INFO
-
-		@cloud_config = config['cloud_config']
-		@instances = self.make_instances(config['instances'])
+	def initialize(config, dryrun: true, verbose: false, logger: nil)
+		@logger = logger || self.new_logger(verbose)
 		@dryrun = dryrun
+		@cloud_config = config['cloud_config']
+		@instances_config = config['instances']
+		@default_ami_config = config['default_ami']
 	end
 
 	def self.from_config(config, *args)
-		instances = config['instances']
-		raise KeyError, "Config file is missing 'instances' key." unless instances
-		raise TypeError, "'instances' config must be an array of hashes." unless instances.is_a?(Array) && instances.first.is_a?(Hash)
-		config['instances'] = instances.map {|i| i.map {|key, value| [key.to_sym, value]}.to_h}
+		self.validate_config(config)
+
+		config['instances'].map! {|i| i.map {|key, value| [key.to_sym, value]}.to_h}
 
 		return self.new(config, *args)
 	end
 
 	def self.from_config_file(config_path, *args)
 		config = YAML.load(File.read(config_path))
+		return self.from_config(config, *args)
+	end
 
-		self.from_config(config, *args)
+	def self.validate_config(config)
+		instances = config['instances']
+		raise KeyError, "Config file is missing 'instances' key." unless instances
+		raise TypeError, "'instances' config must be an array of hashes." unless instances.is_a?(Array) && instances.first.is_a?(Hash)
+
+		if config['default_ami']
+			raise TypeError, "'default_ami' config must be a hash." unless config['default_ami'].is_a?(Hash)
+		end
+
+		return true
 	end
 
-	def make_instances(instances_config)
-		return instances_config.map {|i| self.instance_class.new(i.merge(logger: @logger))}
+	def new_logger(verbose)
+		logger = Logger.new(STDOUT)
+		verbose ? logger.level = Logger::DEBUG : logger.level = Logger::INFO
+		return logger
+	end
+
+	def ami_class
+		return AMI
+	end
+
+	def make_instances(default_image_id)
+		generic_args = {logger: @logger, image: default_image_id, dryrun: @dryrun, cloud_config: @cloud_config}
+		return @instances_config.map {|i| self.instance_class.new(i.merge(generic_args))}
 	end
 
 	def instance_class
@@ -44,15 +66,14 @@ class EC2Bootstrap
 	end
 
 	def create_instances
-		@logger.debug("This was a dry run. No EC2 instances were created.") if @dryrun
-
-		@instances.each do |instance|
-			@logger.debug("Instance name: #{instance.name}")
+		@logger.info("This was a dry run. No EC2 instances were  created.") if @dryrun
 
-			instance.generate_cloud_config(@cloud_config, @dryrun) if @cloud_config
+		default_image_id = @default_ami_config ? ami_class.from_config(@default_ami_config, @logger).find_newest_image_id : nil
+		instances = self.make_instances(default_image_id)
 
+		instances.each do |instance|
 			knife_shell_command = instance.format_knife_shell_command
-			@logger.debug("Knife shell command:\n#{knife_shell_command}")
+			@logger.debug("Knife shell command for #{instance.name}:\n#{knife_shell_command}")
 			
 			unless @dryrun
 				status = self.shell_out_command(knife_shell_command)

data/lib/ec2_bootstrap/ami.rb

@@ -0,0 +1,45 @@
+require 'aws-sdk'
+
+class EC2Bootstrap
+	class AMI
+
+		DEFAULT_AWS_REGION = 'us-east-1'
+
+		DEFAULT_IMAGE_FILTERS = [
+				{name: 'image-type', values: ['machine']},
+				{name: 'state', values: ['available']}
+		]
+
+		def initialize(config, logger)
+			@region = config.delete('region') || DEFAULT_AWS_REGION
+			@search_options = config
+			@logger = logger
+		end
+
+		def self.from_config(config, logger)
+			if config['filters']
+				config['filters'] = config['filters'].to_a.map {|filter| {name: filter.first, values: filter.last}}
+				config['filters'] += DEFAULT_IMAGE_FILTERS
+			end
+			return self.new(config, logger)
+		end
+
+		def find_newest_image_id
+			images = self.fetch_eligible_images
+
+			newest_image = images.max_by{|i| Time.parse(i.creation_date)}
+			newest_image_id = newest_image ? newest_image.id : nil
+
+			@logger.error("Couldn't find any AMIs matching your specifications. Can't set a default AMI.") unless newest_image_id
+			@logger.info("Using #{newest_image_id} as the default AMI.") if newest_image_id
+
+			return newest_image_id
+		end
+
+		def fetch_eligible_images
+			ENV['AWS_REGION'] = @region
+			return Aws::EC2::Resource.new.images(@search_options)
+		end
+
+	end
+end

data/lib/ec2_bootstrap/instance.rb

@@ -3,26 +3,40 @@ require 'json'
 class EC2Bootstrap
 	class Instance
 
+		REQUIRED_KNIFE_EC2_FLAGS = ['image', 'private-ip-address']
+
 		attr_accessor :name
 		attr_accessor :knife_ec2_flags
 
-		def initialize(instance_name:, knife_ec2_flags:, logger:, domain: nil, json_attributes_file:nil)
+		def initialize(instance_name:, knife_ec2_flags:, logger:, dryrun:, domain: nil, json_attributes_file:nil, image: nil, cloud_config: nil)
 			@name = instance_name
-			@json_attributes_file = json_attributes_file
-			@knife_ec2_flags = build_knife_ec2_flags_hash(knife_ec2_flags)
 			@logger = logger
+
+			@logger.debug("Instance name: #{@name}")
+
+			@dryrun = dryrun
+			@json_attributes_file = json_attributes_file
+			@image = image
 			@domain = domain
+
+			@knife_ec2_flags = build_knife_ec2_flags_hash(knife_ec2_flags, cloud_config)
 		end
 
-		def build_knife_ec2_flags_hash(knife_ec2_flags)
-			knife_ec2_flags['json-attributes'] = "'#{self.load_json_attributes(@json_attributes_file)}'" if @json_attributes_file
+		def build_knife_ec2_flags_hash(knife_ec2_flags, cloud_config)
+			knife_ec2_flags['json-attributes'] = "'#{self.load_json_attributes(@json_attributes_file)}'" if @json_attributes_file and not knife_ec2_flags['json-attributes']
+			knife_ec2_flags['user-data'] = self.generate_cloud_init(cloud_config) if cloud_config and not knife_ec2_flags['user-data']
+			knife_ec2_flags['image'] = @image unless knife_ec2_flags['image']
 
 			additional_knife_flags = {
 				'node-name' => @name,
 				'tags' => "Name=#{@name}"
 			}
 
-			return knife_ec2_flags.merge(additional_knife_flags)
+			knife_flags_hash = knife_ec2_flags.merge(additional_knife_flags)
+
+			self.validate_knife_flags(knife_flags_hash)
+
+			return knife_flags_hash
 		end
 
 		# Load the JSON and then dump it back out to ensure it's valid JSON.
@@ -32,28 +46,35 @@ class EC2Bootstrap
 			return JSON.dump(JSON.load(File.read(file_path)))
 		end
 
+		# Ensure that all REQUIRED_EC2_FLAGS have values other than nil.
+		def validate_knife_flags(given_knife_flags)
+			missing_flags = REQUIRED_KNIFE_EC2_FLAGS.select {|flag| given_knife_flags[flag].nil? }
+			raise KeyError, "Instance #{@name} is missing one or more required flags. Missing flags are: #{missing_flags}." unless missing_flags.empty?
+			return true
+		end
+
 		def format_knife_shell_command
 			prefix = 'knife ec2 server create '
 			knife_flag_array = @knife_ec2_flags.map {|key, value| ['--' + key, value]}.flatten.compact
 			return prefix + knife_flag_array.join(' ')
 		end
 
-		def generate_cloud_config(cloud_config, dryrun)
+		def generate_cloud_init(cloud_config)
 			cloud_config['hostname'] = @name
 			cloud_config['fqdn'] = "#{@name}.#{@domain}" if @domain
 
 			formatted_cloud_config = cloud_config.to_yaml.gsub('---', '#cloud-config')
 			cloud_config_path = "cloud_config_#{@name}.txt"
 
-			if dryrun
+			if @dryrun
 				msg = "If this weren't a dry run, I would write the following contents to #{cloud_config_path}:\n#{formatted_cloud_config}"
-				@logger.debug(msg)
+				@logger.info(msg)
 			else
 				self.write_cloud_config_to_file(cloud_config_path, formatted_cloud_config)
-				@logger.debug("Wrote cloud config to #{cloud_config_path}.")
+				@logger.info("Wrote cloud config to #{cloud_config_path}.")
 			end
 
-			@knife_ec2_flags['user-data'] = cloud_config_path
+			return cloud_config_path
 		end
 
 		def write_cloud_config_to_file(path, contents)

data/lib/ec2_bootstrap/version.rb

@@ -1,3 +1,3 @@
 module Ec2Bootstrap
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/spec/ec2_bootstrap/instance_spec.rb

@@ -6,7 +6,8 @@ describe 'EC2Bootstrap::Instance' do
 		{
 			'availability-zone' => 'us-east-1a',
 			'environment' => 'production',
-			'flavor' => 'm4.large'
+			'flavor' => 'm4.large',
+			'private-ip-address' => '255.255.255.255'
 		}
 	end
 
@@ -16,28 +17,72 @@ describe 'EC2Bootstrap::Instance' do
 		logger
 	end
 
-	let(:instance) do
-		EC2Bootstrap::InstanceMock.new(
+	let(:default_image) do
+		'ami-11111111'
+	end
+
+	let(:instance_args) do
+		{
 			instance_name: 'pumpkin',
 			domain: 'chocolate.muffins.com',
 			knife_ec2_flags: knife_flags_hash,
-			logger: logger
-		)
+			logger: logger,
+			image: default_image,
+			dryrun: true
+		}
 	end
 
-	it 'properly formats the knife shell command' do
-		knife_command = 'knife ec2 server create --availability-zone us-east-1a --environment production --flavor m4.large'
+	context 'picking an image' do
+
+		it "uses the default AMI if it doesn't have one set" do
+			instance = EC2Bootstrap::InstanceMock.new(instance_args)
+			expect(instance.knife_ec2_flags['image']).to eq(default_image)
+		end
+
+		it "doesn't override an existing image flag with the default" do
+			image = 'ami-12345678'
+			knife_flags_hash_with_image_flag = knife_flags_hash.merge({'image' => image})
+			instance_args_with_image_flag = instance_args.merge({knife_ec2_flags: knife_flags_hash_with_image_flag})
+			instance = EC2Bootstrap::InstanceMock.new(instance_args_with_image_flag)
+			expect(instance.knife_ec2_flags['image']).to eq(image)
+		end
+
+		it "raises a KeyError if there is no image" do
+			instance_args_without_default_image = instance_args.reject {|k,v| k == :image}
+			expect {EC2Bootstrap::InstanceMock.new(instance_args_without_default_image)}.to raise_error(KeyError)
+		end
 
-		expect(instance.format_knife_shell_command).to include(knife_command)
 	end
 
-	it 'can generate its own cloud config' do
-		cloud_config = {
-			'manage_etc_hosts': 'true',
-			'bootcmd': ['do stuff', 'do some more stuff']
-		}
+	context 'generating cloud config' do
+
+		let(:default_cloud_config) do
+			{
+				'manage_etc_hosts': 'true',
+				'bootcmd': ['do stuff', 'do some more stuff']
+			}
+		end
+
+		it "generates a cloud config file if one isn't set and default cloud config exists" do
+			instance = EC2Bootstrap::InstanceMock.new(instance_args.merge({cloud_config: default_cloud_config}))
+			expect(instance.knife_ec2_flags['user-data']).to be_a(String)
+		end
+
+		it "doesn't override existing cloud config with the default" do
+			cloud_init_file = 'my_custom_cloud_config.txt'
+			knife_flags_hash_with_user_data_flag = knife_flags_hash.merge({'user-data' => cloud_init_file})
+			instance_args_with_user_data_flag = instance_args.merge({knife_ec2_flags: knife_flags_hash_with_user_data_flag, cloud_config: default_cloud_config})
+			instance = EC2Bootstrap::InstanceMock.new(instance_args_with_user_data_flag)
+			expect(instance.knife_ec2_flags['user-data']).to eq(cloud_init_file)
+		end
+
+	end
 
-		expect(instance.generate_cloud_config(cloud_config, false)).to eq("cloud_config_#{instance.name}.txt")
+	it 'properly formats the knife shell command' do
+		knife_command = 'knife ec2 server create --availability-zone us-east-1a --environment production --flavor m4.large'
+
+		instance = EC2Bootstrap::InstanceMock.new(instance_args)
+		expect(instance.format_knife_shell_command).to include(knife_command)
 	end
 
 end

data/spec/ec2_bootstrap_spec.rb

@@ -2,8 +2,19 @@ require_relative 'spec_helper'
 
 describe 'EC2Bootstrap' do
 
+	let(:knife_flags) do
+		{
+			'image' => 'ami-12345678',
+			'private-ip-address' => '255.255.255.255'
+		}
+	end
+
 	let(:yaml_content) do
 		{
+			'default_ami' => {
+				'region' => 'us-west-1',
+				'owners' => ['111111111111']
+			},
 			'cloud_config' => {
 				'manage_etc_hosts' => 'true',
 				'bootcmd' => ['do stuff', 'do some more stuff']
@@ -11,17 +22,17 @@ describe 'EC2Bootstrap' do
 			'instances' => [
 				{
 					'instance_name' => 'cat',
-					'knife_ec2_flags' => {},
+					'knife_ec2_flags' => knife_flags,
 					'domain' => 'cats.com'
 				},
 				{
 					'instance_name' => 'mouse',
 					'json_attributes_file' => {},
-					'knife_ec2_flags' => {}
+					'knife_ec2_flags' => knife_flags
 				},
 				{
 					'instance_name' => 'whale',
-					'knife_ec2_flags' => {}
+					'knife_ec2_flags' => knife_flags
 				}
 			]
 		}
@@ -32,63 +43,45 @@ describe 'EC2Bootstrap' do
 		it "raises a KeyError if the yaml content lacks an 'instances' key" do
 			yaml = yaml_content.reject {|k,v| k == 'instances'}
 
-			expect {EC2BootstrapMock.from_config(yaml, false)}.to raise_error(KeyError)
+			expect {EC2BootstrapMock.from_config(yaml)}.to raise_error(KeyError)
 		end
 
 		it "raises a TypeError if the 'instances' value is not an array of hashes" do
 			yaml = yaml_content.merge({'instances' => ['a thing', 'another thing']})
 
-			expect {EC2BootstrapMock.from_config(yaml, false)}.to raise_error(TypeError)
+			expect {EC2BootstrapMock.from_config(yaml)}.to raise_error(TypeError)
+		end
+
+		it "raises a TypeError if 'default_ami' exists but is not a hash" do
+			yaml = yaml_content.merge({'default_ami' => ['an', 'array']})
+
+			expect {EC2BootstrapMock.from_config(yaml)}.to raise_error(TypeError)
 		end
 
 		it 'loads successfully if the yaml content is properly formatted' do
-			bootstrap = EC2BootstrapMock.from_config(yaml_content, false)
+			bootstrap = EC2BootstrapMock.from_config(yaml_content)
 
 			expect(bootstrap.cloud_config).to eq(yaml_content['cloud_config'])
-			expect(bootstrap.instances).to be_an(Array)
-			expect(bootstrap.instances.first).to be_a(EC2Bootstrap::InstanceMock)
-			expect(bootstrap.dryrun).to be_falsey
+			expect(bootstrap.instances_config).to eq(yaml_content['instances'])
+			expect(bootstrap.default_ami_config).to eq(yaml_content['default_ami'])
 		end
 
 	end
 
-	context 'creating instances' do
-		context 'generating cloud config' do
-
-			it "doesn't generate cloud config if it wasn't included at the top level of the yaml config" do
-				yaml = yaml_content.reject {|k,v| k == 'cloud_config'}
-				bootstrap = EC2BootstrapMock.from_config(yaml, false)
-				instance = bootstrap.instances.first
-
-				expect(instance).to_not receive(:generate_cloud_config)
-				bootstrap.create_instances
-			end
-
-			it 'generates cloud config if it was included at the top level in the yaml config' do
-				bootstrap = EC2BootstrapMock.from_config(yaml_content, false)
-				instance = bootstrap.instances.first
+	context 'shelling out knife EC2 command' do
 
-				expect(instance).to receive(:generate_cloud_config)
-				bootstrap.create_instances
-			end
+		it "doesn't shell out if it's a dryrun" do
+			bootstrap = EC2BootstrapMock.from_config(yaml_content, dryrun: true)
 
+			expect(bootstrap).to_not receive(:shell_out_command)
+			bootstrap.create_instances
 		end
 
-		context 'shelling out knife EC2 command' do
-
-			it "doesn't shell out if it's a dryrun" do
-				bootstrap = EC2BootstrapMock.from_config(yaml_content, true)
-
-				expect(bootstrap).to_not receive(:shell_out_command)
-				bootstrap.create_instances
-			end
-
-			it "shells out if it's not a dryrun" do
-				bootstrap = EC2BootstrapMock.from_config(yaml_content, false)
+		it "shells out if it's not a dryrun" do
+			bootstrap = EC2BootstrapMock.from_config(yaml_content, dryrun: false)
 
-				expect(bootstrap).to receive(:shell_out_command)
-				bootstrap.create_instances
-			end
+			expect(bootstrap).to receive(:shell_out_command)
+			bootstrap.create_instances
 		end
 	end
 

data/spec/spec_helper.rb

@@ -3,6 +3,16 @@ require 'rspec'
 
 class EC2BootstrapMock < EC2Bootstrap
 
+	def new_logger(verbose)
+		logger = Logger.new(STDOUT)
+		logger.level = Logger::ERROR
+		return logger
+	end
+
+	def ami_class
+		return AMIMock
+	end
+
 	def instance_class
 		return InstanceMock
 	end
@@ -25,9 +35,21 @@ class EC2Bootstrap
 		end
 
 	end
+
+	class AMIMock < AMI
+
+		def fetch_eligible_images
+			ids = ['ami-01234567', 'ami-abcdef12', 'ami-87654321']
+			return ids.map {|id| Struct::AmazonAMI.new(id, Time.now.to_s)}
+		end
+
+	end
 end
 
 RSpec.configure do |config|
 	config.run_all_when_everything_filtered = true
 	config.filter_run :focus
+	config.before(:suite) do
+		Struct.new('AmazonAMI', :id, :creation_date)
+	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ec2_bootstrap
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Cozy Services Ltd.
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-18 00:00:00.000000000 Z
+date: 2016-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -81,6 +81,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.12'
+- !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: Bootstrap EC2 instances with custom config.
 email:
 - opensource@cozy.co
@@ -94,6 +108,7 @@ files:
 - Rakefile
 - bin/ec2_bootstrap
 - lib/ec2_bootstrap.rb
+- lib/ec2_bootstrap/ami.rb
 - lib/ec2_bootstrap/instance.rb
 - lib/ec2_bootstrap/version.rb
 - spec/ec2_bootstrap/instance_spec.rb