elastic_beans 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 18b8fddb84235084c0ed2656617d432b4b22e6d4
-  data.tar.gz: c49a0e1f3240697c150aab493b9373913dc25c61
+  metadata.gz: cb92ef373018a6f507082e86909372817ddd7042
+  data.tar.gz: 49eb178cbdad8e93930afa6998577588093d7994
 SHA512:
-  metadata.gz: 480c7aeed8133114eafa17306f832a0a1e21487c9b0069424567283122b166fb3051eaee5f7d7b3829f62030fc91c2904af0bd65430087603884593dda108858
-  data.tar.gz: 35cc62acbf16cdbe0b26b2a600b9f84332bb6c5ac7e151053b56072aa40c4692f37245293285a0d671287ede3791f8cdce678ef53e662f9bae43693253371e5c
+  metadata.gz: e8b5a831464781d60d79e18c66c723a361d02c597b1e5cea19ed059e62ab70ce8be4f1a80fa4154d37455b7d4e455e409b833d50ccf198e77c600ca2a7148db9
+  data.tar.gz: eb62d218f9ab435ff4d90beb9e8f209ddedcf289e981cd09302bc4390763a2a7b1c90d9d0acab694f3deeeefc64c6ad15fa98f1eab0f33fc7ea7c305f8d8baed

data/README.md

@@ -26,6 +26,9 @@ As the SDK documentation suggests, using environment variables is recommended.
     # Create a webserver environment with a pretty DNS name at myapp.TLD (managed by Route53)
     beans create -a myapp [-d myapp.TLD] [--tags=Environment:production Team:Unicorn] webserver
 
+    # Add additional webserver instances to ensure no downtime
+    beans scale -a myapp --min 2 --max 4 webserver
+
     # Create a worker environment using an SQS queue created by the CloudFormation template
     beans create -a myapp [-q QUEUE] worker
 
@@ -54,6 +57,7 @@ As the SDK documentation suggests, using environment variables is recommended.
       name: "myapp",
       cloudformation: Aws::CloudFormation::Client.new,
       elastic_beanstalk: Aws::ElasticBeanstalk::Client.new,
+      s3: Aws::S3::Client.new,
     )
     app.exec_command("rake db:migrate", sqs: Aws::SQS::Client.new)
 
@@ -105,6 +109,42 @@ Then create a periodic scheduler environment using `cron.yaml`:
 
 This environment will enqueue the commands from `cron.yaml` for the `exec` environment to run.
 
+## What elastic_beans does differently than awsebcli
+
+### End-to-end encryption
+
+Elastic Beans sets up [end-to-end encryption][e2e] by default.
+The ELB is configured with an SSL certificate on an HTTPS listener, as well as a backend key policy.
+
+[e2e]: http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/configuring-https-endtoend.html
+
+### Environment variables
+
+[Elastic Beanstalk sets a 4096-byte limit on the environment variable string][envlimit], which is passed to CloudFormation.
+The string is of the form `KEY=VALUE,KEY2=VALUE2...`.
+If your application has a lot of environment variables, there is no easy way around this.
+Elastic Beans avoids this by managing your environment variables in S3 from the start.
+Before loading your application, the configuration is fetched and loaded.
+
+[envlimit]: http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/command-options-general.html#command-options-docker-elasticbeanstalkapplicationenvironment
+
+### One-off and periodic commands
+
+Elastic Beans supports the execution of one-off and periodic commands in an isolated environment.
+This way they can be computationally expensive without affecting application performance.
+Additionally, they are not limited to the visibility timeout of an application background job queue.
+Logs are persisted to an HTTPS endpoint upon command completion.
+
+### Shared code between environments
+
+A Rails app supports multiple contexts with the same codebase.
+Elastic Beans supports webserver, worker, one-off command, and scheduled command environments.
+
+### VPC support
+
+Elastic Beans enforces the use of a VPC and supports running your application in a private network.
+Commands that need to connect to an instance can use a bastion server as an SSH gateway.
+
 ## Requirements
 
 Elastic Beans assumes that you use CloudFormation to manage your infrastructure.
@@ -179,6 +219,18 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 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).
 
+### Philosophy
+
+Elastic Beanstalk is an evolving platform, albeit slowly.
+It has many gaps and surprises in functionality that beans addresses.
+Whenever possible, beans adds behavior using publicized and approved methods, such as `commands` in an ebextension.
+But sometimes, beans must reach under the hood and tweak things in a less-safe manner.
+
+Beans uses Ruby objects to represent Elastic Beanstalk concepts, like `Application` or `Environment`.
+Those objects should be constructed with enough information to locate an existing entity.
+However, it is expected that a Ruby object can represent an Elastic Beanstalk entity that does not exist.
+This is most common when creating them.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/onemedical/elastic_beans.

data/exe/beans

@@ -45,10 +45,10 @@ class ElasticBeans::CLI < Thor
   option :dns, aliases: %w(-d)
   option :queue, aliases: %w(-q)
   option :tags, type: :hash, default: {}
-  def create(environment_name)
+  def create(environment_type)
     @verbose = options[:verbose]
     ElasticBeans::Command::Create.new(
-      environment_name: environment_name,
+      environment_type: environment_type,
       dns: options[:dns],
       queue: options[:queue],
       tags: options[:tags],
@@ -95,6 +95,28 @@ class ElasticBeans::CLI < Thor
     error(e)
   end
 
+  desc ElasticBeans::Command::Scale::USAGE, ElasticBeans::Command::Scale::DESC
+  long_desc ElasticBeans::Command::Scale::LONG_DESC
+  option :application, aliases: %w(-a), required: true
+  option :minimum, aliases: %w(-i --min), required: true
+  option :maximum, aliases: %w(-m --max), required: true
+  option :queue, aliases: %w(-q)
+  def scale(environment_type)
+    @verbose = options[:verbose]
+    ElasticBeans::Command::Scale.new(
+      application: application(
+        name: options[:application],
+      ),
+      minimum: options[:minimum],
+      maximum: options[:maximum],
+      queue: options[:queue],
+      elastic_beanstalk: elastic_beanstalk_client,
+      ui: ui,
+    ).run(environment_type)
+  rescue StandardError => e
+    error(e)
+  end
+
   desc ElasticBeans::Command::SetEnv::USAGE, ElasticBeans::Command::SetEnv::DESC
   long_desc ElasticBeans::Command::SetEnv::LONG_DESC
   option :application, aliases: %w(-a), required: true
@@ -126,12 +148,14 @@ class ElasticBeans::CLI < Thor
   def application(
     name:,
     cloudformation: cloudformation_client,
-    elastic_beanstalk: elastic_beanstalk_client
+    elastic_beanstalk: elastic_beanstalk_client,
+    s3: s3_client
   )
     @application ||= ElasticBeans::Application.new(
       name: name,
       cloudformation: cloudformation,
       elastic_beanstalk: elastic_beanstalk,
+      s3: s3,
     )
   end
 

data/lib/elastic_beans.rb

@@ -4,6 +4,7 @@ end
 require "elastic_beans/application"
 require "elastic_beans/application_version"
 require "elastic_beans/configuration_template"
+require "elastic_beans/env_vars"
 require "elastic_beans/environment"
 require "elastic_beans/network"
 require "elastic_beans/version"

data/lib/elastic_beans/application.rb

@@ -7,9 +7,10 @@ module ElasticBeans
   class Application
     attr_reader :name
 
-    def initialize(name:, cloudformation:, elastic_beanstalk:)
+    def initialize(name:, cloudformation:, elastic_beanstalk:, s3:)
       @name = name
       @elastic_beanstalk = elastic_beanstalk
+      @s3 = s3
       @stack = ElasticBeans::Aws::CloudformationStack.new(name, cloudformation: cloudformation)
     end
 
@@ -45,6 +46,14 @@ module ElasticBeans
       retry
     end
 
+    def env_vars
+      unless exists?
+        raise MissingApplicationError
+      end
+
+      EnvVars.new(application: self, s3: s3)
+    end
+
     def environments
       response = elastic_beanstalk.describe_environments(application_name: name)
       live_environments = response.environments.select { |environment| environment.status !~ /Terminat/ }
@@ -60,6 +69,15 @@ module ElasticBeans
       retry
     end
 
+    def bucket_name
+      return @bucket_name if @bucket_name
+      bucket = s3.list_buckets.buckets.find { |bucket| bucket.name.start_with?("elasticbeanstalk-") }
+      unless bucket
+        raise MissingBucketError
+      end
+      @bucket_name = bucket.name
+    end
+
     def enqueue_command(command, sqs:)
       if environments.none? { |environment| environment.is_a?(Environment::Exec) }
         raise MissingExecEnvironmentError
@@ -100,7 +118,7 @@ module ElasticBeans
 
     private
 
-    attr_reader :elastic_beanstalk, :stack
+    attr_reader :elastic_beanstalk, :s3, :stack
 
     def exec_message(command)
       {
@@ -108,12 +126,26 @@ module ElasticBeans
       }.to_json
     end
 
+    def exists?
+      elastic_beanstalk.describe_applications(application_names: [name]).applications.any?
+    rescue ::Aws::ElasticBeanstalk::Errors::Throttling
+      sleep 5
+      retry
+    end
+
     class MissingApplicationError < ElasticBeans::Error
       def message
         "Application `#{@application_name}' does not exist. Please create the Elastic Beanstalk application using a CloudFormation stack."
       end
     end
 
+    class MissingBucketError < ElasticBeans::Error
+      def message
+        "Cannot find the Elastic Beanstalk S3 bucket." \
+          " Create an S3 bucket with a name starting with \"elasticbeanstalk-\"."
+      end
+    end
+
     class MissingExecEnvironmentError < ElasticBeans::Error
       def message
         <<-MESSAGE

data/lib/elastic_beans/application_version.rb

@@ -37,11 +37,10 @@ module ElasticBeans
       def create_application_version(path:, version_label:, application:, elastic_beanstalk:, s3:)
         archive_filename = File.basename(path)
         archive = File.new(path)
-        eb_bucket_name = find_eb_bucket_name(s3)
-        s3.put_object(body: archive, bucket: eb_bucket_name, key: archive_filename)
+        s3.put_object(body: archive, bucket: application.bucket_name, key: archive_filename)
         elastic_beanstalk.create_application_version(
           application_name: application.name,
-          source_bundle: {s3_bucket: eb_bucket_name, s3_key: archive_filename},
+          source_bundle: {s3_bucket: application.bucket_name, s3_key: archive_filename},
           version_label: version_label,
           process: true,
         )
@@ -77,19 +76,12 @@ module ElasticBeans
         end
 
         Zip::File.open(path) do |zip_file|
+          inject_env_vars_into_zip(zip_file)
           inject_exec_into_zip(zip_file)
           inject_scheduler_into_zip(zip_file)
         end
       end
 
-      def find_eb_bucket_name(s3)
-        bucket = s3.list_buckets.buckets.find { |bucket| bucket.name.start_with?("elasticbeanstalk-") }
-        unless bucket
-          raise MissingBucketError
-        end
-        bucket.name
-      end
-
       def fetch_version_label(working_directory)
         if Dir.glob(File.join(working_directory, ".git")).empty?
           raise InvalidVersionWorkingDirectoryError.new(wd: working_directory)
@@ -100,6 +92,17 @@ module ElasticBeans
         end
       end
 
+      def inject_env_vars_into_zip(zip_file)
+        begin
+          zip_file.mkdir(".ebextensions")
+        rescue Errno::EEXIST
+        end
+        zip_file.add(
+          ".ebextensions/elastic_beans_env_vars.config",
+          File.expand_path('../env_vars/ebextension.yml', __FILE__),
+        )
+      end
+
       def inject_exec_into_zip(zip_file)
         begin
           zip_file.mkdir(".elastic_beans")
@@ -191,12 +194,5 @@ module ElasticBeans
         "Cannot create a version from '#{@wd}`, please change to a Rails project root directory."
       end
     end
-
-    class MissingBucketError < ElasticBeans::Error
-      def message
-        "Cannot find the Elastic Beanstalk S3 bucket." \
-          " Create an S3 bucket with a name starting with \"elasticbeanstalk-\"."
-      end
-    end
   end
 end

data/lib/elastic_beans/command.rb

@@ -2,6 +2,7 @@ require "elastic_beans/command/configure"
 require "elastic_beans/command/create"
 require "elastic_beans/command/deploy"
 require "elastic_beans/command/exec"
+require "elastic_beans/command/scale"
 require "elastic_beans/command/set_env"
 require "elastic_beans/command/talk"
 require "elastic_beans/command/version"

data/lib/elastic_beans/command/configure.rb

@@ -1,3 +1,4 @@
+require "ruby-progressbar"
 require "elastic_beans/error/environments_not_ready"
 
 module ElasticBeans

data/lib/elastic_beans/command/create.rb

@@ -7,7 +7,7 @@ require "elastic_beans/environment/webserver"
 module ElasticBeans
   module Command
     class Create
-      USAGE = "create -a APPLICATION [-t TYPE] [-q QUEUE] [-d PRETTY_DNS] ENVIRONMENT"
+      USAGE = "create -a APPLICATION [-q QUEUE] [-d PRETTY_DNS] ENVIRONMENT_TYPE"
       DESC = "Create a new environment in Elastic Beanstalk and attach it to relevant resources"
       LONG_DESC = <<-LONG_DESC
 Create a new environment in Elastic Beanstalk and attach it to relevant resources
@@ -18,7 +18,7 @@ Requires AWS credentials to be set in the environment, i.e. AWS_ACCESS_KEY_ID an
       LONG_DESC
 
       def initialize(
-        environment_name:,
+        environment_type:,
         dns: nil,
         queue: nil,
         tags:,
@@ -28,12 +28,10 @@ Requires AWS credentials to be set in the environment, i.e. AWS_ACCESS_KEY_ID an
         route53:,
         s3:
       )
-        @environment_name = environment_name
-        @environment_type = environment_name
+        @environment_type = environment_type
         @dns = dns
         if @environment_type == "worker"
           @queue = queue || "default"
-          @environment_name = "#{@environment_name}-#{@queue}"
         end
         @tags = tags
         @application = application
@@ -53,7 +51,6 @@ Requires AWS credentials to be set in the environment, i.e. AWS_ACCESS_KEY_ID an
         )
         environment = ElasticBeans::Environment.new_by_type(
           environment_type,
-          suffix: environment_name,
           queue: queue,
           application: application,
           elastic_beanstalk: elastic_beanstalk,

data/lib/elastic_beans/command/deploy.rb

@@ -1,3 +1,4 @@
+require "ruby-progressbar"
 require "elastic_beans/error/environments_not_ready"
 
 module ElasticBeans

data/lib/elastic_beans/command/scale.rb

@@ -0,0 +1,77 @@
+require "ruby-progressbar"
+require "elastic_beans/error/environments_not_ready"
+
+module ElasticBeans
+  module Command
+    class Scale
+      USAGE = "scale -a APPLICATION -i MINIMUM -m MAXIMUM ENVIRONMENT"
+      DESC = "Change the autoscaling minimum and maximum for the given environment"
+      LONG_DESC = <<-LONG_DESC
+Change the autoscaling minimum and maximum for the given environment.
+
+Requires the application name.
+Requires AWS credentials to be set in the environment, i.e. AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY.
+      LONG_DESC
+
+      def initialize(application:, minimum:, maximum:, queue:, elastic_beanstalk:, ui:)
+        @application = application
+        @minimum = minimum
+        @maximum = maximum
+        @queue = queue || "default"
+        @elastic_beanstalk = elastic_beanstalk
+        @ui = ui
+      end
+
+      def run(environment_type)
+        environment = ElasticBeans::Environment.new_by_type(
+          environment_type,
+          queue: queue,
+          application: application,
+          elastic_beanstalk: elastic_beanstalk,
+        )
+        if environment.status != "Ready"
+          raise EnvironmentsNotReady.new(environments: [environment])
+        end
+
+        progressbar = ProgressBar.create(title: "Configuring", total: nil, output: ui.stdout)
+
+        thread = Thread.new do
+          config = ElasticBeans::ConfigurationTemplate.new_by_type(
+            environment_type,
+            queue: queue,
+            application: application,
+            elastic_beanstalk: elastic_beanstalk,
+          )
+          progressbar.log("Updating `#{config.name}' configuration template in #{application.name}...")
+          config.upsert(min_size: minimum, max_size: maximum)
+        end
+        loop do
+          sleep 0.5
+          progressbar.increment
+          if !thread.alive?
+            break
+          end
+        end
+        thread.join
+
+        thread = Thread.new do
+          progressbar.log("Updating `#{environment.name}'...")
+          environment.scale(min_size: minimum, max_size: maximum)
+        end
+        loop do
+          sleep 0.5
+          progressbar.increment
+          if !thread.alive?
+            progressbar.total = progressbar.progress
+            break
+          end
+        end
+        thread.join
+      end
+
+      private
+
+      attr_reader :application, :minimum, :maximum, :queue, :elastic_beanstalk, :ui
+    end
+  end
+end

data/lib/elastic_beans/command/set_env.rb

@@ -31,19 +31,16 @@ Requires AWS credentials to be set in the environment, i.e. AWS_ACCESS_KEY_ID an
 
         progressbar = ProgressBar.create(title: "Updating", total: nil, output: ui.stdout)
 
-        progressbar.log("Updating configuration templates in #{application.name}...")
-        threads += application.configuration_templates.map { |config|
-          thread = Thread.new do
-            config.update_environment(env_vars)
-          end
-          progressbar.increment
-          thread
-        }
+        progressbar.log("Updating configuration in #{application.name}...")
+        threads << Thread.new do
+          application.env_vars.update(env_vars)
+        end
+        progressbar.increment
 
         threads += environments.map { |environment|
           progressbar.log("Updating `#{environment.name}'...")
           thread = Thread.new do
-            environment.update_environment(env_vars)
+            environment.restart
           end
           progressbar.increment
           thread

data/lib/elastic_beans/configuration_template.rb

@@ -63,24 +63,6 @@ module ElasticBeans
       raise MissingConfigurationError
     end
 
-    def update_environment(env_vars)
-      new_env_settings = env_vars.map { |k, v|
-        {namespace: "aws:elasticbeanstalk:application:environment", option_name: k, value: v}
-      }
-      elastic_beanstalk.update_configuration_template(
-        application_name: application.name,
-        template_name: name,
-        option_settings: new_env_settings,
-      )
-    rescue ::Aws::ElasticBeanstalk::Errors::ConfigurationValidationException => e
-      raise InvalidConfigurationError.new(cause: e)
-    rescue ::Aws::ElasticBeanstalk::Errors::InvalidParameterValue => e
-      raise MissingConfigurationError.new(cause: e)
-    rescue ::Aws::ElasticBeanstalk::Errors::Throttling
-      sleep 5
-      retry
-    end
-
     def upsert(**args)
       @option_settings = build_option_settings(**args)
       if configuration_settings_description

data/lib/elastic_beans/configuration_template/base.rb

@@ -33,13 +33,15 @@ module ElasticBeans
       protected
 
       def build_option_settings(
-        network:,
+        network: nil,
         database_url: nil,
         secret_key_base: nil,
         image_id: nil,
         instance_type: nil,
         keypair: nil,
-        iam:,
+        min_size: nil,
+        max_size: nil,
+        iam: nil,
         **_
       )
         instance_profile_setting = template_option_setting(namespace: "aws:autoscaling:launchconfiguration", option_name: "IamInstanceProfile", override: instance_profile(iam))
@@ -54,23 +56,26 @@ module ElasticBeans
           raise MissingConfigurationError
         end
 
-        security_groups = [network.ssh_security_group] + network.application_security_groups
+        config_path = "#{application.bucket_name}/#{application.env_vars.s3_key}"
         settings = [
           template_option_setting(namespace: "aws:elasticbeanstalk:command", option_name: "BatchSize", default: "1"),
           template_option_setting(namespace: "aws:elasticbeanstalk:command", option_name: "BatchSizeType", default: "Fixed"),
           template_option_setting(namespace: "aws:elasticbeanstalk:command", option_name: "DeploymentPolicy", default: "Rolling"),
           template_option_setting(namespace: "aws:elasticbeanstalk:application:environment", option_name: "DISABLE_SQS_CONSUMER", default: "true"),
+          template_option_setting(namespace: "aws:elasticbeanstalk:application:environment", option_name: "ELASTIC_BEANS_ENV_VARS", default: config_path),
           template_option_setting(namespace: "aws:elasticbeanstalk:environment", option_name: "ServiceRole", default: "aws-elasticbeanstalk-service-role"),
           template_option_setting(namespace: "aws:elasticbeanstalk:healthreporting:system", option_name: "SystemType", default: "enhanced"),
           template_option_setting(namespace: "aws:ec2:vpc", option_name: "AssociatePublicIpAddress", default: "false"),
+          template_option_setting(namespace: "aws:autoscaling:asg", option_name: "MinSize", default: "1", override: min_size),
+          template_option_setting(namespace: "aws:autoscaling:asg", option_name: "MaxSize", default: "4", override: max_size),
           template_option_setting(namespace: "aws:autoscaling:launchconfiguration", option_name: "InstanceType", default: "c4.large", override: instance_type),
           template_option_setting(namespace: "aws:autoscaling:launchconfiguration", option_name: "SSHSourceRestriction", default: "tcp, 22, 22, 0.0.0.0/32"),
           template_option_setting(namespace: "aws:autoscaling:updatepolicy:rollingupdate", option_name: "RollingUpdateType", default: "Health"),
           template_option_setting(namespace: "aws:autoscaling:updatepolicy:rollingupdate", option_name: "RollingUpdateEnabled", default: "true"),
-          template_option_setting(namespace: "aws:autoscaling:launchconfiguration", option_name: "SecurityGroups", override: security_groups.join(",")),
-          template_option_setting(namespace: "aws:ec2:vpc", option_name: "ELBSubnets", override: network.elb_subnets.join(",")),
-          template_option_setting(namespace: "aws:ec2:vpc", option_name: "Subnets", override: network.application_subnets.join(",")),
-          template_option_setting(namespace: "aws:ec2:vpc", option_name: "VPCId", override: network.vpc),
+          template_option_setting(namespace: "aws:autoscaling:launchconfiguration", option_name: "SecurityGroups", override: security_groups(network)),
+          template_option_setting(namespace: "aws:ec2:vpc", option_name: "ELBSubnets", override: elb_subnets(network)),
+          template_option_setting(namespace: "aws:ec2:vpc", option_name: "Subnets", override: subnets(network)),
+          template_option_setting(namespace: "aws:ec2:vpc", option_name: "VPCId", override: vpc_id(network)),
           instance_profile_setting,
           keypair_setting,
           database_url_setting,
@@ -84,8 +89,15 @@ module ElasticBeans
 
       private
 
+      def elb_subnets(network)
+        if network
+          network.elb_subnets.join(",")
+        end
+      end
+
       def instance_profile(iam)
         return @instance_profile if @instance_profile
+        return nil unless iam
         marker = nil
         loop do
           response = iam.list_instance_profiles(marker: marker)
@@ -102,6 +114,18 @@ module ElasticBeans
         nil
       end
 
+      def security_groups(network)
+        ([network.ssh_security_group] + network.application_security_groups).join(",") if network
+      end
+
+      def subnets(network)
+        network.application_subnets.join(",") if network
+      end
+
+      def vpc_id(network)
+        network.vpc if network
+      end
+
       class MissingInstanceProfileError < ElasticBeans::Error
         def message
           "Could not find Elastic Beanstalk instance profile." \

data/lib/elastic_beans/configuration_template/webserver.rb

@@ -9,7 +9,7 @@ module ElasticBeans
 
       protected
 
-      def build_option_settings(network:, public_key:, ssl_certificate_id:, **_)
+      def build_option_settings(network: nil, public_key: nil, ssl_certificate_id: nil, **_)
         public_key_policy_names_setting = template_option_setting(namespace: "aws:elb:policies:backendencryption", option_name: "PublicKeyPolicyNames", default: "backendkey")
         public_key_setting = template_option_setting(namespace: "aws:elb:policies:#{public_key_policy_names_setting[:value]}", option_name: "PublicKey", override: public_key)
         ssl_certificate_setting = template_option_setting(namespace: "aws:elb:listener:443", option_name: "SSLCertificateId", override: ssl_certificate_id)
@@ -24,8 +24,8 @@ module ElasticBeans
           template_option_setting(namespace: "aws:elb:listener:443", option_name: "InstancePort", default: "443"),
           template_option_setting(namespace: "aws:elb:listener:443", option_name: "InstanceProtocol", default: "HTTPS"),
           template_option_setting(namespace: "aws:elb:listener:443", option_name: "ListenerProtocol", default: "HTTPS"),
-          template_option_setting(namespace: "aws:elb:loadbalancer", option_name: "ManagedSecurityGroup", override: network.elb_security_groups[0]),
-          template_option_setting(namespace: "aws:elb:loadbalancer", option_name: "SecurityGroups", override: network.elb_security_groups.join(",")),
+          template_option_setting(namespace: "aws:elb:loadbalancer", option_name: "ManagedSecurityGroup", override: managed_security_group(network)),
+          template_option_setting(namespace: "aws:elb:loadbalancer", option_name: "SecurityGroups", override: elb_security_groups(network)),
           template_option_setting(namespace: "aws:elb:policies", option_name: "ConnectionDrainingEnabled", default: "true"),
           template_option_setting(namespace: "aws:elb:policies:backendencryption", option_name: "InstancePorts", default: "443"),
           public_key_policy_names_setting,
@@ -34,6 +34,14 @@ module ElasticBeans
         ]
       end
 
+      def elb_security_groups(network)
+        network.elb_security_groups.join(",") if network
+      end
+
+      def managed_security_group(network)
+        network.elb_security_groups[0] if network
+      end
+
       class NoEncryptionSettingsError < ElasticBeans::Error
         def message
           require "elastic_beans/command/configure"

data/lib/elastic_beans/env_vars.rb

@@ -0,0 +1,52 @@
+require "json"
+require "aws-sdk"
+require "elastic_beans/error"
+
+module ElasticBeans
+  class EnvVars
+    def initialize(application:, s3:)
+      @application = application
+      @s3 = s3
+    end
+
+    def s3_key
+      @s3_key ||= "#{application.name}/env_vars.json"
+    end
+
+    def update(env_hash)
+      body = env_script(existing_env_hash.merge(env_hash))
+      s3.put_object(bucket: application.bucket_name, key: s3_key, body: body)
+    end
+
+    private
+
+    attr_reader :application, :s3
+
+    def env_script(env_hash)
+      JSON.dump(env_hash)
+    end
+
+    def existing_env_hash
+      s3.head_object(bucket: application.bucket_name, key: s3_key)
+      response = s3.get_object(bucket: application.bucket_name, key: s3_key)
+      existing_script = response.body.read
+      JSON.parse(existing_script)
+    rescue ::Aws::S3::Errors::NotFound
+      {}
+    rescue ::Aws::S3::Errors::Forbidden
+      raise CannotAccessConfigError.new(bucket_name: application.bucket_name, key: s3_key)
+    end
+
+    class CannotAccessConfigError < ElasticBeans::Error
+      def initialize(bucket_name:, key:)
+        @bucket_name = bucket_name
+        @key = key
+      end
+
+      def message
+        "Cannot access configuration stored in S3 with bucket `#{@bucket_name}' and key `#{@key}'." \
+          " Please ask an administrator of your AWS account administrator to give you access."
+      end
+    end
+  end
+end

data/lib/elastic_beans/env_vars/ebextension.yml

@@ -0,0 +1,61 @@
+files:
+  "/opt/elasticbeanstalk/support/get_envvars.rb":
+    mode: "000644"
+    owner: root
+    group: root
+    content: |
+      require "json"
+
+      def get_env_vars
+        require "aws-sdk"
+        eb_env = JSON.parse(`/opt/elasticbeanstalk/bin/get-config environment`)
+
+        region = eb_env['AWS_REGION'] || eb_env['AWS_DEFAULT_REGION'] || "us-east-1"
+        s3_bucket, s3_key = eb_env['ELASTIC_BEANS_ENV_VARS'].split('/', 2)
+        $stderr.puts "Fetching environment variables from s3://#{s3_bucket}/#{s3_key}..."
+        response = Aws::S3::Client.new(region: region).get_object(bucket: s3_bucket, key: s3_key)
+        beans_env_body = response.body.read
+
+        eb_env.merge(JSON.parse(beans_env_body))
+      rescue LoadError, StandardError => e
+        $stderr.puts "#{e.class.name}: #{e.message}"
+        JSON.parse(`/opt/elasticbeanstalk/bin/get-config environment`)
+      end
+  "/opt/elasticbeanstalk/support/export_envvars":
+    mode: "000755"
+    owner: root
+    group: root
+    content: |
+      #!/bin/env bash
+
+      # execute using Elastic Beanstalk's built-in Ruby with aws-sdk pre-installed
+      export PATH="/opt/elasticbeanstalk/lib/ruby/bin:$PATH"
+      export GEM_PATH="/opt/elasticbeanstalk/lib/ruby/lib/ruby/2.2.0"
+      exec ruby /opt/elasticbeanstalk/support/export_envvars.rb
+  "/opt/elasticbeanstalk/support/export_envvars.rb":
+    mode: "000755"
+    owner: root
+    group: root
+    content: |
+      #!/bin/env ruby
+
+      require '/opt/elasticbeanstalk/support/get_envvars'
+
+      if __FILE__ == $0
+          env_file = '/opt/elasticbeanstalk/support/envvars'
+          env_vars = get_env_vars
+
+          str = ''
+          env_vars.each do |key, value|
+              new_key = key.gsub(/\s/, '_')
+              str << "export #{new_key}=\"#{value}\"\n"
+          end
+
+          File.open(env_file, 'w') { |f| f.write(str) }
+      end
+commands:
+  config_hooks:
+    command: |
+      cp -v /opt/elasticbeanstalk/support/export_envvars /opt/elasticbeanstalk/hooks/restartappserver/pre/09_update_environment.sh
+  update_environment:
+    command: "/opt/elasticbeanstalk/support/export_envvars"

data/lib/elastic_beans/environment.rb

@@ -16,8 +16,8 @@ module ElasticBeans
 
     attr_reader :name
 
-    def self.new_by_type(type, suffix: nil, application:, **args)
-      name = "#{application.name}-#{suffix}"
+    def self.new_by_type(type, application:, **args)
+      name = "#{application.name}-#{type}"
       case type
       when "exec"
         ElasticBeans::Environment::Exec.new(name, application: application, **args)
@@ -26,6 +26,7 @@ module ElasticBeans
       when "webserver"
         ElasticBeans::Environment::Webserver.new(name, application: application, **args)
       when "worker"
+        name = "#{name}-#{args[:queue]}"
         ElasticBeans::Environment::Worker.new(name, application: application, **args)
       else
         raise UnknownEnvironmentType.new(environment_type: type)
@@ -117,11 +118,22 @@ module ElasticBeans
       raise UnhealthyEnvironmentError.new(environment_name: name, cause: e)
     end
 
-    def update_configuration
+    def restart
+      elastic_beanstalk.restart_app_server(environment_name: name)
+      wait_environment(wait_status: "Updating", wait_health_status: "Info")
+    rescue ::Aws::ElasticBeanstalk::Errors::Throttling
+      sleep 5
+      retry
+    end
+
+    def scale(min_size:, max_size:)
+      option_settings = [
+        {namespace: "aws:autoscaling:asg", option_name: "MinSize", value: min_size},
+        {namespace: "aws:autoscaling:asg", option_name: "MaxSize", value: max_size},
+      ]
       elastic_beanstalk.update_environment(
         environment_name: name,
-        template_name: template_name,
-        tier: {name: tier_name, type: tier_type},
+        option_settings: option_settings,
       )
       wait_environment(wait_status: "Updating", wait_health_status: "Info")
     rescue ::Aws::ElasticBeanstalk::Errors::InvalidParameterValue
@@ -131,15 +143,12 @@ module ElasticBeans
       retry
     end
 
-    def update_environment(env_vars)
-      new_env_settings = env_vars.map { |k, v|
-        {namespace: "aws:elasticbeanstalk:application:environment", option_name: k, value: v}
-      }
+    def update_configuration
       elastic_beanstalk.update_environment(
         environment_name: name,
-        option_settings: new_env_settings,
+        template_name: template_name,
+        tier: {name: tier_name, type: tier_type},
       )
-
       wait_environment(wait_status: "Updating", wait_health_status: "Info")
     rescue ::Aws::ElasticBeanstalk::Errors::InvalidParameterValue
       raise MissingEnvironmentError.new(environment_name: name)

data/lib/elastic_beans/exec/ebextension.yml

@@ -1,6 +1,6 @@
 container_commands:
   00_copy_files:
-    command: "mkdir -p /opt/elastic_beans && cp -vR /var/app/ondeck/.elastic_beans/exec /opt/elastic_beans/"
+    command: "mkdir -vp /opt/elastic_beans && cp -vR /var/app/ondeck/.elastic_beans/exec /opt/elastic_beans/"
   01_permissions:
     command: "chmod 755 /opt/elastic_beans/exec/run_command.sh"
   09_upstart:

data/lib/elastic_beans/version.rb

@@ -1,3 +1,3 @@
 module ElasticBeans
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elastic_beans
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Adam Stegman
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-11 00:00:00.000000000 Z
+date: 2016-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -165,6 +165,7 @@ files:
 - lib/elastic_beans/command/create.rb
 - lib/elastic_beans/command/deploy.rb
 - lib/elastic_beans/command/exec.rb
+- lib/elastic_beans/command/scale.rb
 - lib/elastic_beans/command/set_env.rb
 - lib/elastic_beans/command/talk.rb
 - lib/elastic_beans/command/version.rb
@@ -175,6 +176,8 @@ files:
 - lib/elastic_beans/configuration_template/webserver.rb
 - lib/elastic_beans/configuration_template/worker.rb
 - lib/elastic_beans/dns_entry.rb
+- lib/elastic_beans/env_vars.rb
+- lib/elastic_beans/env_vars/ebextension.yml
 - lib/elastic_beans/environment.rb
 - lib/elastic_beans/environment/exec.rb
 - lib/elastic_beans/environment/scheduler.rb