aerosol 0.5.1 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e6cf29a31c88ffb04c424c3bcbbcb0645d74e071
-  data.tar.gz: 4e9f58b45fd64a4875e09ec9c3ce0645f82d6ecf
+  metadata.gz: b5404b6b9a731bb233826885c52ebf9f6c5cf108
+  data.tar.gz: 27a5a1de8fd53f6eff006e359c0d150a89d46b30
 SHA512:
-  metadata.gz: 25cb41164e46803c1abe915dd809c12fdf050b3427d6ded99353b1e7ca3a434eb3a74d60f24f1ef66896b3510ea1905483f66bb8c279d59bfce7588026ecc234
-  data.tar.gz: 525852da882273707a57af5161075dd36a9c1f1ad3abaa032ba8dcc80ed4697c20c7e67a9c4e713f497461e187e876cd481d1ff669e0be043d4fe0465eede0bf
+  metadata.gz: d0301f02c37e044904ac243048a66197c2c9b70787540c8957c1a179a4cdd5d0470129b9fd5635d1ea357a8e5cf7bb1de3bb02cfbd2428f94311c6f001b366b6
+  data.tar.gz: a8bf540a1255e40d080806250fb07294b98ac568bf773d1c3610fbd5c14b9a9cb3bc05d3795294b62c88fb379e67136184f6d1af5376eb0309dde81798d9c9fe

data/aerosol.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'activerecord', '>= 3.2.0'
   gem.add_dependency 'clamp', '~> 0.6'
   gem.add_dependency 'excon'
-  gem.add_dependency 'fog', '~> 1.21'
+  gem.add_dependency 'aws-sdk', '~> 2.0'
   gem.add_dependency 'grit'
   gem.add_dependency 'net-ssh'
   gem.add_dependency 'net-ssh-gateway'

data/lib/aerosol/auto_scaling.rb

@@ -3,21 +3,11 @@ class Aerosol::AutoScaling
   include Dockly::Util::Logger::Mixin
 
   logger_prefix '[aerosol auto_scaling]'
-  aws_attribute :aws_identifier            => 'AutoScalingGroupName',
-                :availability_zones        => 'AvailabilityZones',
-                :min_size                  => 'MinSize',
-                :max_size                  => 'MaxSize',
-                :default_cooldown          => 'DefaultCooldown',
-                :desired_capacity          => 'DesiredCapacity',
-                :health_check_grace_period => 'HealthCheckGracePeriod',
-                :health_check_type         => 'HealthCheckType',
-                :load_balancer_names       => 'LoadBalancerNames',
-                :placement_group           => 'PlacementGroup',
-                :tag_from_array            => 'Tags',
-                :created_time              => 'CreatedTime',
-                :vpc_zone_identifier       => 'VPCZoneIdentifier'
+  aws_attribute :auto_scaling_group_name, :availability_zones, :min_size, :max_size, :default_cooldown,
+                :desired_capacity, :health_check_grace_period, :health_check_type, :load_balancer_names,
+                :placement_group, :tags, :created_time, :vpc_zone_identifier
   aws_class_attribute :launch_configuration, Aerosol::LaunchConfiguration
-  primary_key :aws_identifier
+  primary_key :auto_scaling_group_name
 
   def initialize(options={}, &block)
     tag = options.delete(:tag)
@@ -29,21 +19,21 @@ class Aerosol::AutoScaling
     tags["Deploy"] ||= namespaced_name
   end
 
-  def aws_identifier(arg = nil)
+  def auto_scaling_group_name(arg = nil)
     if arg
-      raise "You cannot set the aws_identifer directly" unless from_aws
-      @aws_identifier = arg
+      raise "You cannot set the auto_scaling_group_name directly" unless from_aws
+      @auto_scaling_group_name = arg
     else
-      @aws_identifier || default_identifier
+      @auto_scaling_group_name || default_identifier
     end
   end
 
   def exists?
     info "auto_scaling: needed?: #{namespaced_name}: " +
-         "checking for auto scaling group: #{aws_identifier}"
+         "checking for auto scaling group: #{auto_scaling_group_name}"
     exists = super
     info "auto scaling: needed?: #{namespaced_name}: " +
-         "#{exists ? 'found' : 'did not find'} auto scaling group: #{aws_identifier}"
+         "#{exists ? 'found' : 'did not find'} auto scaling group: #{auto_scaling_group_name}"
     exists
   end
 
@@ -55,62 +45,65 @@ class Aerosol::AutoScaling
     launch_configuration.create
     info self.inspect
 
-    conn.create_auto_scaling_group(aws_identifier, availability_zones,
-                                  launch_configuration.aws_identifier,
-                                  max_size, min_size,
-                                  create_options)
-    make_fake_instances
-    sleep 10 # TODO: switch to fog models and .wait_for { ready? }
+    conn.create_auto_scaling_group({
+      auto_scaling_group_name: auto_scaling_group_name,
+      availability_zones: [*availability_zones],
+      launch_configuration_name: launch_configuration.launch_configuration_name,
+      max_size: max_size,
+      min_size: min_size
+    }.merge(create_options))
+    sleep 10
   end
 
   def destroy!
     info self.inspect
-    conn.delete_auto_scaling_group(aws_identifier, 'ForceDelete' => true)
+    conn.delete_auto_scaling_group(auto_scaling_group_name: auto_scaling_group_name, force_delete: true)
     begin
       (0..2).each { break if deleting?; sleep 1 }
       launch_configuration.destroy
     rescue => ex
-      info "Launch Config: #{launch_configuration} for #{aws_identifier} was not deleted."
+      info "Launch Config: #{launch_configuration} for #{auto_scaling_group_name} was not deleted."
       info ex.message
     end
   end
 
   def deleting?
-    asgs = conn.describe_auto_scaling_groups("AutoScalingGroupNames" => self.aws_identifier)
-        .body
-        .[]('DescribeAutoScalingGroupsResult')
-        .[]('AutoScalingGroups')
+    asgs = conn.describe_auto_scaling_groups(auto_scaling_group_names: auto_scaling_group_name).auto_scaling_groups
 
     return true if asgs.empty?
 
-    asgs.first['Status'].to_s.include?('Delete')
+    asgs.first.status.to_s.include?('Delete')
   end
 
   def all_instances
-    Aerosol::AWS.auto_scaling
-                .describe_auto_scaling_groups('AutoScalingGroupNames' => self.aws_identifier)
-                .body
-                .[]('DescribeAutoScalingGroupsResult')
-                .[]('AutoScalingGroups')
-                .first
-                .[]('Instances')
-                .map { |instance| Aerosol::Instance.from_hash(instance) }
+    conn.describe_auto_scaling_groups(auto_scaling_group_names: [*auto_scaling_group_name])
+        .auto_scaling_groups.first
+        .instances.map { |instance| Aerosol::Instance.from_hash(instance) }
   end
 
   def tag(val)
     tags.merge!(val)
   end
 
-  def tags
-    @tags ||= {}
+  def tags(ary=nil)
+    if !ary.nil?
+      if ary.is_a? Hash
+        ary.each do |key, value|
+          tag key => value
+        end
+      else
+        ary.each do |struct|
+          tag struct[:key] => struct[:value]
+        end
+      end
+    else
+      @tags ||= {}
+    end
   end
 
   def self.request_all_for_token(next_token)
-    options = next_token.nil? ? {} : { 'NexToken' => '' }
-    Aerosol::AWS.auto_scaling
-                .describe_auto_scaling_groups(options)
-                .body
-                .[]('DescribeAutoScalingGroupsResult')
+    options = next_token.nil? ? {} : { next_token: next_token }
+    Aerosol::AWS.auto_scaling.describe_auto_scaling_groups(options)
   end
 
   def self.request_all
@@ -119,9 +112,9 @@ class Aerosol::AutoScaling
 
     begin
       new_asgs = request_all_for_token(next_token)
-      asgs.concat(new_asgs['AutoScalingGroups'])
-      next_token = new_asgs['NextToken']
-    end while !next_token.nil?
+      asgs.concat(new_asgs.auto_scaling_groups)
+      next_token = new_asgs.next_token
+    end until next_token.nil?
 
     asgs
   end
@@ -133,7 +126,7 @@ class Aerosol::AutoScaling
 
   def to_s
     %{Aerosol::AutoScaling { \
-"aws_identifier" => "#{aws_identifier}", \
+"auto_scaling_group_name" => "#{auto_scaling_group_name}", \
 "availability_zones" => "#{availability_zones}", \
 "min_size" => "#{min_size}", \
 "max_size" => "#{max_size}", \
@@ -155,86 +148,20 @@ private
 
   def create_options
     {
-      'DefaultCooldown' => default_cooldown,
-      'DesiredCapacity' => desired_capacity,
-      'HealthCheckGracePeriod' => health_check_grace_period,
-      'HealthCheckType' => health_check_type,
-      'LoadBalancerNames' => load_balancer_names,
-      'PlacementGroup' => placement_group,
-      'Tags' => tags,
-      'VPCZoneIdentifier' => vpc_zone_identifier
+      default_cooldown: default_cooldown,
+      desired_capacity: desired_capacity,
+      health_check_grace_period: health_check_grace_period,
+      health_check_type: health_check_type,
+      load_balancer_names: load_balancer_names,
+      placement_group: placement_group,
+      tags: tags_to_array,
+      vpc_zone_identifier: vpc_zone_identifier
     }.reject { |k, v| v.nil? }
   end
 
-  def tag_from_array(ary)
-    if ary.is_a? Hash
-      ary.each do |key, value|
-        tag key => value
-      end
-    else
-      ary.each do |hash|
-        tag hash['Key'] => hash['Value']
-      end
-    end
-  end
-
-  # Unfortunately, Fog does not create fake instances after an auto scaling
-  # group is created.
-  def make_fake_instances
-    return unless Fog.mock?
-
-    asg_instances = []
-    all_instances = []
-    min_size.times do |n|
-      instance_id = Fog::AWS::Mock.instance_id
-      asg_instances << {
-        'AvailabilityZone'        => availability_zones,
-        'HealthStatus'            => 'Good',
-        'InstanceId'              => instance_id,
-        'LifecycleState'          => 'Pending',
-        'LaunchConfigurationName' => launch_configuration.aws_identifier
-      }
-
-      all_instances << {
-        'amiLaunchIndex'      => n,
-        'architecture'        => 'i386',
-        'blockDeviceMapping'  => [],
-        'clientToken'         => 'FAKE_CLIENT_TOKEN',
-        'dnsName'             => 'not-a-real-hostname',
-        'ebsOptimized'        => false,
-        'hypervisor'          => 'xen',
-        'imageId'             => launch_configuration.ami,
-        'instanceId'          => instance_id,
-        'instanceState'       => { 'code' => 0, 'name' => 'not pending?' },
-        'instanceType'        => launch_configuration.instance_type,
-        'kernelId'            => launch_configuration.kernel_id || Fog::AWS::Mock.kernel_id,
-        'keyName'             => launch_configuration.key_name,
-        'launchTime'          => Time.now,
-        'monitoring'          => { 'state' => false },
-        'placement'           => { 'availabilityZone' => availability_zones,
-                                   'groupName'        => self.aws_identifier,
-                                   'tenancy'          => 'default' },
-        'privateDnsName'      => nil,
-        'productCodes'        => [],
-        'reason'              => nil,
-        'rootDeviceType'      => 'instance-store',
-        'virtualizationType'  => 'paravirtual',
-        'groupIds'            => [],
-        'groupSet'            => launch_configuration.security_groups,
-        'iamInstanceProfile'  => launch_configuration.iam_role,
-        'networkInterfaces'   => [],
-        'ownerId'             => nil,
-        'privateIpAddress'    => nil,
-        'reservationId'       => Fog::AWS::Mock.reservation_id,
-        'stateReason'         => {},
-        'ipAddress'           => Fog::AWS::Mock.ip_address,
-        'privateIpAddress'    => Fog::AWS::Mock.private_ip_address
-      }
-    end
-    Aerosol::AWS.auto_scaling.data[:auto_scaling_groups][aws_identifier]
-                             .merge!('Instances' => asg_instances)
-    all_instances.each do |instance|
-      Aerosol::AWS.compute.data[:instances][instance['instanceId']] = instance
+  def tags_to_array
+    tags.map do |key, value|
+      { key: key, value: value }
     end
   end
 end

data/lib/aerosol/aws.rb

@@ -1,5 +1,3 @@
-require 'fog/aws'
-
 # This module holds the connections for all AWS services used by the gem.
 module Aerosol::AWS
   extend self
@@ -40,23 +38,16 @@ module Aerosol::AWS
   end
 
   def creds
-    attrs = Hash[env_attrs.map { |attr| [attr, public_send(attr)] }].reject { |k, v| v.nil? }
-    if attrs.empty?
-      if ENV['FOG_CREDENTIAL']
-        attrs = {} # let Fog use the env var
-      else
-        attrs = { :use_iam_profile => true }
-      end
-    end
-    attrs
+    Hash[env_attrs.map { |attr| [attr, public_send(attr)] }].reject { |k, v| v.nil? }
   end
 
   def reset_cache!
     services.each { |service| instance_variable_set(:"@#{service}", nil) }
   end
 
-  service :s3, Fog::Storage::AWS
-  service :compute, Fog::Compute::AWS
-  service :auto_scaling, Fog::AWS::AutoScaling
-  env_attr :aws_access_key_id, :aws_secret_access_key
+  service :sts, Aws::STS::Client
+  service :s3, Aws::S3::Client
+  service :compute, Aws::EC2::Client
+  service :auto_scaling, Aws::AutoScaling::Client
+  env_attr :credentials, :stub_responses
 end

data/lib/aerosol/aws_model.rb

@@ -42,9 +42,9 @@ module Aerosol::AWSModel
       @primary_key
     end
 
-    def aws_attribute(hash)
-      dsl_attribute(*hash.keys)
-      aws_attributes.merge!(hash)
+    def aws_attribute(*attrs)
+      dsl_attribute(*attrs)
+      aws_attributes.merge(attrs)
     end
 
     def aws_class_attribute(name, klass)
@@ -62,28 +62,28 @@ module Aerosol::AWSModel
 
     def all
       raise 'Please define .request_all to use .all' unless respond_to?(:request_all)
-      request_all.map { |hash| from_hash(hash) }
+      request_all.map { |struct| from_hash(struct.to_hash) }
     end
 
     def from_hash(hash)
       raise 'To use .from_hash, you must specify a primary_key' if primary_key.nil?
       refs = Hash[aws_class_attributes.map do |name, klass|
-        [name, klass.instances.values.find do |inst|
-          inst.send(klass.primary_key) &&
-            (inst.send(klass.primary_key) == hash[klass.aws_attributes[klass.primary_key]])
-        end]
+        value = klass.instances.values.find do |inst|
+          inst.send(klass.primary_key).to_s == hash[klass.primary_key].to_s unless inst.send(klass.primary_key).nil?
+        end
+        [name, value]
       end].reject { |k, v| v.nil? }
 
       instance = new!
       instance.from_aws = true
 
-      aws_attributes.each { |k, v| instance.send(k, hash[v]) unless hash[v].nil? }
+      aws_attributes.each { |attr| instance.send(attr, hash[attr]) unless hash[attr].nil? }
       refs.each { |name, inst| instance.send(name, inst.name) }
       instance
     end
 
     def aws_attributes
-      @aws_attributes ||= {}
+      @aws_attributes ||= Set.new
     end
 
     def aws_class_attributes

data/lib/aerosol/connection.rb

@@ -11,7 +11,7 @@ class Aerosol::Connection
   def with_connection(overridden_host=nil, &block)
     actual_host = overridden_host || host
     unless actual_host.is_a?(String)
-      actual_host = (actual_host.public_hostname || actual_host.private_ip_address)
+      actual_host = actual_host.address
     end
 
     if jump

data/lib/aerosol/deploy.rb

@@ -7,7 +7,7 @@ class Aerosol::Deploy
                 :instance_live_grace_period, :app_port,
                 :continue_if_stop_app_fails, :stop_app_retries,
                 :sleep_before_termination, :post_deploy_command,
-                :ssl, :log_files, :tail_logs
+                :ssl, :log_files, :tail_logs, :assume_role
 
   dsl_class_attribute :ssh, Aerosol::Connection
   dsl_class_attribute :migration_ssh, Aerosol::Connection
@@ -22,6 +22,7 @@ class Aerosol::Deploy
   default_value :ssl, false
   default_value :tail_logs, false
   default_value :log_files, ['/var/log/syslog']
+  default_value :assume_role, nil
 
   def live_check(arg = nil)
     case
@@ -60,6 +61,19 @@ class Aerosol::Deploy
     local_ssh || ssh
   end
 
+  def perform_role_assumption
+    return if assume_role.nil?
+    Aws.config.update(
+      credentials: Aws::AssumeRoleCredentials.new(
+        role_arn: assume_role, role_session_name: 'aerosol'
+      )
+    )
+  end
+
+  def sts
+    Aerosol::AWS.sts
+  end
+
   def run_post_deploy
     return if post_deploy_command.nil?
     info "running post deploy: #{post_deploy_command}"
@@ -81,7 +95,7 @@ class Aerosol::Deploy
       end
       ssh_command << "#{local_ssh_ref.user}@" unless local_ssh_ref.user.nil?
     end
-    ssh_command << "#{instance.public_hostname || instance.private_ip_address}"
+    ssh_command << "#{instance.address}"
   end
 
   def generate_ssh_commands
@@ -91,11 +105,11 @@ class Aerosol::Deploy
     ssh_commands = []
 
     with_prefix("[#{name}]") do |logger|
-      logger.info "found group: #{group.aws_identifier}"
+      logger.info "found group: #{group.auto_scaling_group_name}"
       instances = group.all_instances
       raise "Could not find any instances for auto scaling group #{group.namespaced_name}" if instances.empty?
       instances.each do |instance|
-        logger.info "printing ssh command for #{instance.public_hostname  || instance.private_ip_address}"
+        logger.info "printing ssh command for #{instance.address}"
         ssh_commands << generate_ssh_command(instance)
       end
     end

data/lib/aerosol/instance.rb

@@ -1,12 +1,9 @@
 class Aerosol::Instance
   include Aerosol::AWSModel
 
-  aws_attribute :availability_zone => 'AvailabilityZone',
-                :health_status     => 'HealthStatus',
-                :id                => 'InstanceId',
-                :lifecycle_state   => 'LifecycleState'
+  aws_attribute :availability_zone, :health_status, :instance_id, :lifecycle_state
   aws_class_attribute :launch_configuration, Aerosol::LaunchConfiguration
-  primary_key :id
+  primary_key :instance_id
 
   def live?
     describe_again
@@ -14,19 +11,27 @@ class Aerosol::Instance
   end
 
   def instance_state_name
-    description['instanceState']['name']
+    description[:state][:name]
   end
 
   def public_hostname
-    description['dnsName']
+    description[:public_dns_name]
   end
 
   def private_ip_address
-    description['privateIpAddress']
+    description[:private_ip_address]
   end
 
-  def ami
-    description['imageId']
+  def address
+    if public_hostname.blank?
+      private_ip_address
+    else
+      public_hostname
+    end
+  end
+
+  def image_id
+    description[:image_id]
   end
 
   def description
@@ -36,16 +41,14 @@ class Aerosol::Instance
   def self.request_all
     Aerosol::AWS.auto_scaling
                 .describe_auto_scaling_instances
-                .body
-                .[]('DescribeAutoScalingInstancesResult')
-                .[]('AutoScalingInstances')
+                .auto_scaling_instances
   end
 
 private
   def describe!
-    ensure_present! :id
-    result = Aerosol::AWS.compute.describe_instances('instance-id' => id).body
-    result['reservationSet'].first['instancesSet'].first rescue nil
+    ensure_present! :instance_id
+    result = Aerosol::AWS.compute.describe_instances(instance_ids: [instance_id])
+    result.reservations.first.instances.first.to_h rescue nil
   end
 
   def describe_again

data/lib/aerosol/launch_configuration.rb

@@ -3,60 +3,63 @@ class Aerosol::LaunchConfiguration
   include Dockly::Util::Logger::Mixin
 
   logger_prefix '[aerosol launch_configuration]'
-  aws_attribute :aws_identifier              => 'LaunchConfigurationName',
-                :ami                         => 'ImageId',
-                :instance_type               => 'InstanceType',
-                :security_groups             => 'SecurityGroups',
-                :user_data                   => 'UserData',
-                :iam_role                    => 'IamInstanceProfile',
-                :kernel_id                   => 'KernelId',
-                :key_name                    => 'KeyName',
-                :spot_price                  => 'SpotPrice',
-                :created_time                => 'CreatedTime',
-                :associate_public_ip_address => 'AssociatePublicIpAddress'
-
-  primary_key :aws_identifier
+  aws_attribute :launch_configuration_name, :image_id, :instance_type, :security_groups, :user_data,
+                :iam_instance_profile, :kernel_id, :key_name, :spot_price, :created_time,
+                :associate_public_ip_address
+
+  primary_key :launch_configuration_name
   default_value(:security_groups) { [] }
 
-  def aws_identifier(arg = nil)
+  def launch_configuration_name(arg = nil)
     if arg
-      raise "You cannot set the aws_identifer directly" unless from_aws
-      @aws_identifier = arg
+      raise "You cannot set the launch_configuration_name directly" unless from_aws
+      @launch_configuration_name = arg
     else
-      @aws_identifier || default_identifier
+      @launch_configuration_name || default_identifier
     end
   end
 
+  def ami(name=nil)
+    warn 'Warning: Use `image_id` instead `ami` for a launch configuration'
+    image_id(name)
+  end
+
+  def iam_role(name=nil)
+    warn 'Warning: Use `iam_instance_profile` instead `iam_role` for a launch configuration'
+    iam_instance_profile(name)
+  end
+
   def security_group(group)
     security_groups << group
   end
 
   def create!
-    ensure_present! :ami, :instance_type
+    ensure_present! :image_id, :instance_type
 
     info self.to_s
-    conn.create_launch_configuration(ami, instance_type, aws_identifier, create_options)
+    conn.create_launch_configuration({
+      image_id: image_id,
+      instance_type: instance_type,
+      launch_configuration_name: launch_configuration_name,
+    }.merge(create_options))
     sleep 10 # TODO: switch to fog models and .wait_for { ready? }
   end
 
   def destroy!
     info self.to_s
-    conn.delete_launch_configuration(aws_identifier)
+    conn.delete_launch_configuration(launch_configuration_name: launch_configuration_name)
   end
 
   def all_instances
     Aerosol::Instance.all.select { |instance|
       !instance.launch_configuration.nil? &&
-        (instance.launch_configuration.aws_identifier == self.aws_identifier)
+        (instance.launch_configuration.launch_configuration_name == launch_configuration_name)
     }.each(&:description)
   end
 
   def self.request_all_for_token(next_token)
-    options = next_token.nil? ? {} : { 'NextToken' => next_token }
-    Aerosol::AWS.auto_scaling
-                .describe_launch_configurations(options)
-                .body
-                .[]('DescribeLaunchConfigurationsResult')
+    options = next_token.nil? ? {} : { next_token: next_token }
+    Aerosol::AWS.auto_scaling.describe_launch_configurations(options)
   end
 
   def self.request_all
@@ -65,21 +68,21 @@ class Aerosol::LaunchConfiguration
 
     begin
       new_lcs = request_all_for_token(next_token)
-      lcs.concat(new_lcs['LaunchConfigurations'])
-      next_token = new_lcs['NextToken']
-    end while !next_token.nil?
+      lcs.concat(new_lcs.launch_configurations)
+      next_token = new_lcs.next_token
+    end until next_token.nil?
 
     lcs
   end
 
   def to_s
     %{Aerosol::LaunchConfiguration { \
-"aws_identifier" => "#{aws_identifier}", \
-"ami" => "#{ami}", \
+"launch_configuration_name" => "#{launch_configuration_name}", \
+"image_id" => "#{image_id}", \
 "instance_type" => "#{instance_type}", \
 "security_groups" => #{security_groups.to_s}, \
 "user_data" => "#{user_data}", \
-"iam_role" => "#{iam_role}", \
+"iam_instance_profile" => "#{iam_instance_profile}", \
 "kernel_id" => "#{kernel_id}", \
 "key_name" => "#{key_name}", \
 "spot_price" => "#{spot_price}", \
@@ -90,13 +93,13 @@ class Aerosol::LaunchConfiguration
 private
   def create_options
     { # TODO Add dsl so that 'BlockDeviceMappings' may be specified
-      'IamInstanceProfile' => iam_role,
-      'KernelId' => kernel_id,
-      'KeyName' => key_name,
-      'SecurityGroups' => security_groups,
-      'SpotPrice' => spot_price,
-      'UserData' => Aerosol::Util.strip_heredoc(user_data || ''),
-      'AssociatePublicIpAddress' => associate_public_ip_address
+      iam_instance_profile: iam_instance_profile,
+      kernel_id: kernel_id,
+      key_name: key_name,
+      security_groups: security_groups,
+      spot_price: spot_price,
+      user_data: Base64.encode64(Aerosol::Util.strip_heredoc(user_data || '')),
+      associate_public_ip_address: associate_public_ip_address
     }.reject { |k, v| v.nil? }
   end