eks_cli 0.4.4 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba49f9e0042e7f67e85c83c1b1da3baf19b285128a042c630f70dd14dcab66d7
-  data.tar.gz: '058b044ee0b320a9989110cb408b2a35a2a5f9317eeab4b45b2f34c4386076ac'
+  metadata.gz: 13604399317ad223e406ab42975a58de062eba61d6f5f2f073c545818c89b625
+  data.tar.gz: 237117a49388e1d2dde8044a8935e5a2dd56ae9c92769930919df1d1750fa01f
 SHA512:
-  metadata.gz: 97bf31805bbd9b3c741ef8cc9778462d5300a39cdc001ab760b67a01a273dd48a6c3adeefbb36bead38fb8183706bcfac11da6a78aa8e449c7ceb719195cb28c
-  data.tar.gz: fec0ee13e7c70bbf76384cd69468d763cf0551b264927283783a1073333799009e59c301e483ebac88931f3c8ec478a99d6c80cf2a19a9a29d93356eb07198be
+  metadata.gz: 25568fb30b957afd895a46666fc1e7b6f6a83c119b5294031f7505a933d81c4fbf112a805de02ca0d66c490c483b585f7253316da942cba22b37c8d8c7c18253
+  data.tar.gz: d982788e52ef2485652940c5506a6ba654d77f33bbcd331a3149cb37858f0a7c58493a0582590768b60a85cb2e1a0d50760e49371e65c77b2223d882b622db50

data/README.md

@@ -10,16 +10,18 @@ EKS cluster bootstrap with batteries included
 * Manage IAM policies that will be attached to your nodes
 * Easily configure docker repository secrets to allow pulling private images
 * Manage Route53 DNS records to point at your Kubernetes services
-* Export nodegroups to SporInst Elastigroups
+* Export nodegroups to SpotInst Elastigroups
 * Auto resolving AMIs by region & instance types (GPU enabled AMIs)
-* Even more...
+* Supports both kubernetes 1.12 and 1.13
+* Configuration is saved on S3 for easy collaboration
 
 ## Usage
 
 ```
 $ gem install eks_cli
-$ eks create --cluster-name My-EKS-Cluster
-$ eks create-nodegroup --cluster-name My-EKS-Cluster --group-name nodes --ssh-key-name <my-ssh-key> --yes
+$ eks create --kubernetes-version 1.13 --cluster-name my-eks-cluster --s3-bucket my-eks-config-bucket
+$ eks create-nodegroup --cluster-name my-eks-cluster --group-name nodes --ssh-key-name <my-ssh-key> --s3-bucket my-eks-config-bucket --yes
+$ eks delete-cluster --cluster-name my-eks-cluster --s3-bucket my-eks-config-bucket
 ```
 
 You can type `eks` in your shell to get the full synopsis of available commands
@@ -28,38 +30,45 @@ You can type `eks` in your shell to get the full synopsis of available commands
 Commands:
   eks add-iam-user IAM_ARN                                     # adds an IAM user as an authorized member on the EKS cluster
   eks create                                                   # creates a new EKS cluster
-  eks create-cluster-security-group                            # creates a SG for cluster communication
-  eks create-cluster-vpc                                       # creates a vpc according to aws cloudformation template
   eks create-default-storage-class                             # creates default storage class on a new k8s cluster
   eks create-dns-autoscaler                                    # creates kube dns autoscaler
-  eks create-eks-cluster                                       # create EKS cluster on AWS
-  eks create-eks-role                                          # creates an IAM role for usage by EKS
   eks create-nodegroup                                         # creates all nodegroups on environment
+  eks delete-cluster                                           # deletes a cluster, including nodegroups
   eks delete-nodegroup                                         # deletes cloudformation stack for nodegroup
-  eks detach-iam-policies                                      # detaches added policies to nodegroup IAM Role
   eks enable-gpu                                               # installs nvidia plugin as a daemonset on the cluster
   eks export-nodegroup                                         # exports nodegroup auto scaling group to spotinst
   eks help [COMMAND]                                           # Describe available commands or one specific command
-  eks scale-nodegroup --group-name=GROUP_NAME --max=N --min=N  # scales a nodegroup
+  eks scale-nodegroup                                          # scales a nodegroup
   eks set-docker-registry-credentials USERNAME PASSWORD EMAIL  # sets docker registry credentials
   eks set-iam-policies --policies=one two three                # sets IAM policies to be attached to created nodegroups
   eks set-inter-vpc-networking TO_VPC_ID TO_SG_ID              # creates a vpc peering connection, sets route tables and allows network access on SG
   eks show-config                                              # print cluster configuration
   eks update-auth                                              # update aws auth configmap to allow all nodegroups to connect to control plane
+  eks update-cluster-cni                                       # updates cni with warm ip target
   eks update-dns HOSTNAME K8S_SERVICE_NAME                     # alters route53 CNAME records to point to k8s service ELBs
   eks version                                                  # prints eks_cli version
   eks wait-for-cluster                                         # waits until cluster responds to HTTP requests
 
 Options:
-  c, --cluster-name=CLUSTER_NAME 
+  c, [--cluster-name=CLUSTER_NAME]  # eks cluster name (env: EKS_CLI_CLUSTER_NAME)
+  s3, [--s3-bucket=S3_BUCKET]       # s3 bucket name to save configurtaion and state (env: EKS_CLI_S3_BUCKET)
 ```
-
 ## Prerequisites
 
 1. Ruby
 2. [kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/) version >= 10 on your `PATH`
 3. [aws-iam-authenticator](https://github.com/kubernetes-sigs/aws-iam-authenticator) on your `PATH`
 4. [aws-cli](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) version >= 1.16.18 on your `PATH`
+5. S3 bucket with write/read permissions to store configuration
+
+## Environment variables
+
+You are encouraged to use both `EKS_CLI_CLUSTER_NAME` and `EKS_CLI_S3_BUCKET` environment variables instead of using the corresponding flags on each command. It makes the command clearer and reduces the chance for typos.
+The following selected commands assumes you have exported both environment variables:
+```bash
+export EKS_CLI_S3_BUCKET=my-eks-config-bucket
+export EKS_CLI_CLUSTER_NAME=my-eks-cluster
+```
 
 ## Selected Commands
 
@@ -74,30 +83,30 @@ Nodes in different nodegroups may communicate freely thanks to a shared Security
 
 Scale nodegroups up and down using
 
-`$ eks scale-nodegroup --cluster-name My-EKS-Cluster --group-name nodes --min 1 --max 10`
+`$ eks scale-nodegroup --group-name nodes --min 1 --max 10`
 
 ### Authorize an IAM user to access the cluster
 
-`$ eks add-iam-user arn:aws:iam::XXXXXXXX:user/XXXXXXXX --cluster-name=My-EKS-Cluster --yes`
+`$ eks add-iam-user arn:aws:iam::XXXXXXXX:user/XXXXXXXX --yes`
 
 Edits `aws-auth` configmap and updates it on EKS to allow an IAM user access the cluster via `kubectl`
 
 ### Setting IAM policies to be attached to EKS nodes
 
-`$ eks set-iam-policies --cluster-name=My-EKS-Cluster --policies=AmazonS3FullAccess AmazonDynamoDBFullAccess`
+`$ eks set-iam-policies --policies=AmazonS3FullAccess AmazonDynamoDBFullAccess`
 
 Sets IAM policies to be attached to nodegroups once created.
 This settings does not work retro-actively - only affects future `eks create-nodegroup` commands.
 
 ### Routing Route53 hostnames to Kubernetes service
 
-`$ eks update-dns my-cool-service.my-company.com cool-service --route53-hosted-zone-id=XXXXX --elb-hosted-zone-id=XXXXXX --cluster-name=My-EKS-Cluster`
+`$ eks update-dns my-cool-service.my-company.com cool-service --route53-hosted-zone-id=XXXXX --elb-hosted-zone-id=XXXXXX`
 
 Takes the ELB endpoint from `cool-service` and puts it as an alias record of `my-cool-service.my-company.com` on Route53
 
 ### Enabling GPU
 
-`$ eks enable-gpu --cluster-name EKS-Staging`
+`$ eks enable-gpu`
 
 Installs the nvidia device plugin required to have your GPUs exposed
 
@@ -108,21 +117,21 @@ Installs the nvidia device plugin required to have your GPUs exposed
 
 ### Adding Dockerhub Secrets
 
-`$ eks set-docker-registry-credentials <dockerhub-user> <dockerhub-password> <dockerhub-email> --cluster-name My-EKS-Cluster`
+`$ eks set-docker-registry-credentials <dockerhub-user> <dockerhub-password> <dockerhub-email>`
 
 Adds your dockerhub credentials as a secret and attaches it to the default ServiceAccount's imagePullSecrets
 
 ### Creating Default Storage Class
 
-`$ eks create-default-storage-class --cluster-name My-EKS-Cluster`
+`$ eks create-default-storage-class`
 
 Creates a standard gp2 default storage class named gp2
 
 ### Installing DNS autoscaler
 
-`$ eks create-dns-autoscaler --cluster-name My-EKS-Cluster`
+`$ eks create-dns-autoscaler`
 
-Creates kube-dns autoscaler with sane defaults
+Creates coredns autoscaler with production defaults
 
 ### Connecting to an existing VPC
 

data/eks_cli.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |s|
   s.bindir        = "bin"
   s.executables   = ["eks"]
   s.require_paths = ["lib"]
+  s.add_dependency 'aws-sdk-s3', '~> 1'
   s.add_dependency 'thor', '0.20.3'
   s.add_dependency 'aws-sdk-ec2', '1.62.0'
   s.add_dependency 'aws-sdk-cloudformation', '1.13.0'

data/lib/eks_cli/cli.rb

@@ -27,7 +27,8 @@ module EksCli
 
   class Cli < Thor
 
-    class_option :cluster_name, required: true, aliases: :c
+    class_option :cluster_name, required: false, aliases: :c, desc: 'eks cluster name (env: EKS_CLI_CLUSTER_NAME)'
+    class_option :s3_bucket, required: false, aliases: :s3, desc: "s3 bucket name to save configurtaion and state (env: EKS_CLI_S3_BUCKET)"
 
     desc "create", "creates a new EKS cluster"
     option :region, type: :string, default: "us-west-2", desc: "AWS region for EKS cluster"
@@ -42,53 +43,59 @@ module EksCli
     option :create_dns_autoscaler, type: :boolean, default: true, desc: "creates dns autoscaler on the cluster"
     option :warm_ip_target, type: :numeric, desc: "set a default custom warm ip target for CNI"
     def create
-      opts = {region: options[:region],
-              kubernetes_version: options[:kubernetes_version],
-              open_ports: options[:open_ports],
-              cidr: options[:cidr],
-              warm_ip_target: options[:warm_ip_target] ? options[:warm_ip_target].to_i : nil,
-              subnet1_az: (options[:subnet1_az] || Config::AZS[options[:region]][0]),
-              subnet2_az: (options[:subnet2_az] || Config::AZS[options[:region]][1]),
-              subnet3_az: (options[:subnet3_az] || Config::AZS[options[:region]][2])}
-      config.bootstrap(opts)
-      cluster = EKS::Cluster.new(cluster_name).create
-      cluster.update_kubeconfig
-      wait_for_cluster
-      enable_gpu if options[:enable_gpu]
-      create_default_storage_class if options[:create_default_storage_class]
-      create_dns_autoscaler if options[:create_dns_autoscaler]
-      update_cluster_cni if options[:warm_ip_target]
-      Log.info "cluster creation completed"
+      with_context do
+
+        opts = {region: options[:region],
+                kubernetes_version: options[:kubernetes_version],
+                open_ports: options[:open_ports],
+                cidr: options[:cidr],
+                warm_ip_target: options[:warm_ip_target] ? options[:warm_ip_target].to_i : nil,
+                subnet1_az: (options[:subnet1_az] || Config::AZS[options[:region]][0]),
+                subnet2_az: (options[:subnet2_az] || Config::AZS[options[:region]][1]),
+                subnet3_az: (options[:subnet3_az] || Config::AZS[options[:region]][2])}
+
+        config.bootstrap(opts)
+        cluster = EKS::Cluster.new(cluster_name).create
+        cluster.update_kubeconfig
+        wait_for_cluster
+        enable_gpu if options[:enable_gpu]
+        create_default_storage_class if options[:create_default_storage_class]
+        create_dns_autoscaler if options[:create_dns_autoscaler]
+        update_cluster_cni if options[:warm_ip_target]
+        Log.info "cluster creation completed"
+      end
     end
 
     desc "show-config", "print cluster configuration"
     option :group_name, desc: "group name to show configuration for"
     def show_config
-      if options[:group_name]
-        puts JSON.pretty_generate(config.for_group(options[:group_name]))
-      else
-        puts JSON.pretty_generate(config.read_from_disk)
+      with_context do
+        if options[:group_name]
+          puts JSON.pretty_generate(config.for_group(options[:group_name]))
+        else
+          puts JSON.pretty_generate(config.read_from_disk)
+        end
       end
     end
 
     desc "update-cluster-cni", "updates cni with warm ip target"
     def update_cluster_cni
-      K8s::Client.new(cluster_name).update_cni
+      with_context { K8s::Client.new(cluster_name).update_cni }
     end
 
     desc "enable-gpu", "installs nvidia plugin as a daemonset on the cluster"
     def enable_gpu
-      K8s::Client.new(cluster_name).enable_gpu
+      with_context { K8s::Client.new(cluster_name).enable_gpu }
     end
 
     desc "set-docker-registry-credentials USERNAME PASSWORD EMAIL", "sets docker registry credentials"
     def set_docker_registry_credentials(username, password, email)
-      K8s::Client.new(cluster_name).set_docker_registry_credentials(username, password, email)
+      with_context { K8s::Client.new(cluster_name).set_docker_registry_credentials(username, password, email) }
     end
 
     desc "create-default-storage-class", "creates default storage class on a new k8s cluster"
     def create_default_storage_class
-      K8s::Client.new(cluster_name).create_default_storage_class
+      with_context { K8s::Client.new(cluster_name).create_default_storage_class }
     end
 
     desc "create-nodegroup", "creates all nodegroups on environment"
@@ -106,13 +113,15 @@ module EksCli
     option :enable_docker_bridge, type: :boolean, default: false, desc: "pass --enable-docker-bridge true on bootstrap.sh (https://github.com/kubernetes/kubernetes/issues/40182))"
     option :yes, type: :boolean, default: false, desc: "perform nodegroup creation"
     def create_nodegroup
-      opts = options.dup
-      opts[:subnets] = opts[:subnets].map(&:to_i)
-      Config[cluster_name].update_nodegroup(opts) unless opts[:all]
-      if opts[:yes]
-        cf_stacks = nodegroups.map {|ng| ng.create(wait_for_completion: false)}
-        CloudFormation::Stack.await(cf_stacks)
-        K8s::Auth.new(cluster_name).update
+      with_context do
+        opts = options.dup 
+        opts[:subnets] = opts[:subnets].map(&:to_i)
+        Config[cluster_name].update_nodegroup(opts) unless opts[:all]
+        if opts[:yes]
+          cf_stacks = nodegroups.map {|ng| ng.create(wait_for_completion: false)}
+          CloudFormation::Stack.await(cf_stacks)
+          K8s::Auth.new(cluster_name).update
+        end
       end
     end
 
@@ -125,35 +134,37 @@ module EksCli
     option :asg, type: :boolean, default: true, desc: "scale ec2 auto scaling group"
     option :update, type: :boolean, default: false, desc: "update the nodegroup attributes"
     def scale_nodegroup
-      nodegroups.each do |ng| 
-        min = (options[:min] || config.for_group(ng.name)["min"]).to_i
-        max = (options[:max] || config.for_group(ng.name)["max"]).to_i
-        ng.scale(min, max, options[:asg], options[:spotinst])
-        Config[cluster_name].update_nodegroup(options.slice("min", "max").merge({"group_name" => ng.name})) if options[:update]
+      with_context do
+        nodegroups.each do |ng| 
+          min = (options[:min] || config.for_group(ng.name)["min"]).to_i
+          max = (options[:max] || config.for_group(ng.name)["max"]).to_i
+          ng.scale(min, max, options[:asg], options[:spotinst])
+          Config[cluster_name].update_nodegroup(options.slice("min", "max").merge({"group_name" => ng.name})) if options[:update]
+        end
       end
     end
 
-    desc "delete-cluster", "deleted cluster"
+    desc "delete-cluster", "deletes a cluster, including nodegroups/elastigroups and cloudformation stacks"
     def delete_cluster
-      EKS::Cluster.new(cluster_name).delete
+      with_context { EKS::Cluster.new(cluster_name).delete }
     end
 
     desc "delete-nodegroup", "deletes cloudformation stack for nodegroup"
     option :all, type: :boolean, default: false, desc: "delete all nodegroups. can't be used with --name"
     option :group_name, type: :string, desc: "delete a specific nodegroup. can't be used with --all"
     def delete_nodegroup
-      nodegroups.each(&:delete)
+      with_context { nodegroups.each(&:delete) }
     end
 
     desc "update-auth", "update aws auth configmap to allow all nodegroups to connect to control plane"
     def update_auth
-      K8s::Auth.new(cluster_name).update
+      with_context { K8s::Auth.new(cluster_name).update }
     end
 
     desc "set-iam-policies", "sets IAM policies to be attached to created nodegroups"
     option :policies, type: :array, required: true, desc: "IAM policies ARNs"
     def set_iam_policies
-      Config[cluster_name].set_iam_policies(options[:policies])
+      with_context { Config[cluster_name].set_iam_policies(options[:policies]) }
     end
 
     desc "update-dns HOSTNAME K8S_SERVICE_NAME", "alters route53 CNAME records to point to k8s service ELBs"
@@ -161,22 +172,22 @@ module EksCli
     option :elb_hosted_zone_id, required: true, desc: "hosted zone ID for the ELB on ec2"
     option :namespace, default: "default", desc: "the k8s namespace of the service"
     def update_dns(hostname, k8s_service_name)
-      Route53::Client.new(cluster_name).update_dns(hostname, k8s_service_name, options[:namespace], options[:route53_hosted_zone_id], options[:elb_hosted_zone_id])
+      with_context { Route53::Client.new(cluster_name).update_dns(hostname, k8s_service_name, options[:namespace], options[:route53_hosted_zone_id], options[:elb_hosted_zone_id]) }
     end
 
     desc "set-inter-vpc-networking TO_VPC_ID TO_SG_ID", "creates a vpc peering connection, sets route tables and allows network access on SG"
     def set_inter_vpc_networking(to_vpc_id, to_sg_id)
-      VPC::Client.new(cluster_name).set_inter_vpc_networking(to_vpc_id, to_sg_id)
+      with_context { VPC::Client.new(cluster_name).set_inter_vpc_networking(to_vpc_id, to_sg_id) }
     end
 
     desc "create-dns-autoscaler", "creates kube dns autoscaler"
     def create_dns_autoscaler
-      K8s::Client.new(cluster_name).create_dns_autoscaler
+      with_context { K8s::Client.new(cluster_name).create_dns_autoscaler }
     end
 
     desc "wait-for-cluster", "waits until cluster responds to HTTP requests"
     def wait_for_cluster
-      K8s::Client.new(cluster_name).wait_for_cluster
+      with_context { K8s::Client.new(cluster_name).wait_for_cluster }
     end
 
     desc "export-nodegroup", "exports nodegroup auto scaling group to spotinst"
@@ -184,7 +195,7 @@ module EksCli
     option :group_name, type: :string, desc: "create a specific nodegroup. can't be used with --all"
     option :exact_instance_type, type: :boolean, default: false, desc: "enforce spotinst to use existing instance type only"
     def export_nodegroup
-      nodegroups.each {|ng| ng.export_to_spotinst(options[:exact_instance_type]) }
+      with_context { nodegroups.each {|ng| ng.export_to_spotinst(options[:exact_instance_type]) } }
     end
 
     desc "add-iam-user IAM_ARN", "adds an IAM user as an authorized member on the EKS cluster"
@@ -192,8 +203,10 @@ module EksCli
     option :groups, type: :array, default: ["system:masters"], desc: "which group should the user be added to"
     option :yes, type: :boolean, default: false, desc: "update aws-auth configmap"
     def add_iam_user(iam_arn)
-      Config[cluster_name].add_user(iam_arn, options[:username], options[:groups])
-      K8s::Auth.new(cluster_name).update if options[:yes]
+      with_context do
+        Config[cluster_name].add_user(iam_arn, options[:username], options[:groups])
+        K8s::Auth.new(cluster_name).update if options[:yes]
+      end
     end
 
     disable_required_check! :version
@@ -203,16 +216,35 @@ module EksCli
     end
 
     no_commands do
-      def cluster_name; options[:cluster_name]; end
+      def cluster_name; options_or_env(:cluster_name); end
+      def s3_bucket; options_or_env(:s3_bucket); end
+
+      def with_context 
+        Config.s3_bucket=(s3_bucket)
+        yield
+      end
 
-      def config; Config[cluster_name]; end
+      def config; Config.new(cluster_name); end
 
-      def all_nodegroups; Config[cluster_name]["groups"].keys ;end
+      def all_nodegroups; config["groups"].keys ;end
 
       def nodegroups
         ng = options[:all] ? all_nodegroups : [options[:group_name]]
         ng.map {|n| NodeGroup.new(cluster_name, n)}
       end
+
+      def options_or_env(k)
+        v = options[k] || ENV[env_param_name(k)]
+        if v == nil || v == ""
+          Log.error "missing #{k} or #{env_param_name(k)}"
+          exit 1
+        end
+        v
+      end
+
+      def env_param_name(k)
+        "EKS_CLI_#{k.to_s.upcase}"
+      end
     end
 
   end

data/lib/eks_cli/config.rb

@@ -2,6 +2,7 @@ require 'json'
 require_relative 'log'
 require 'active_support/core_ext/hash'
 require 'fileutils'
+require 'aws-sdk-s3'
 module EksCli
   class Config
 
@@ -16,6 +17,13 @@ module EksCli
         new(cluster_name)
       end
 
+      def s3_bucket=(bucket)
+        @s3_bucket = bucket
+      end
+
+      def s3_bucket
+        @s3_bucket || raise("no s3 bucket set")
+      end
     end
 
     def initialize(cluster_name)
@@ -24,7 +32,10 @@ module EksCli
 
     def delete
       Log.info "deleting configuration for #{@cluster_name} at #{dir}"
-      FileUtils.rm_rf(dir)
+      s3.delete_object(bucket: s3_bucket, key: config_path)
+      s3.delete_object(bucket: s3_bucket, key: state_path)
+      s3.delete_object(bucket: s3_bucket, key: groups_path)
+      s3.delete_object(bucket: s3_bucket, key: dir)
     end
 
     def read_from_disk
@@ -91,33 +102,37 @@ module EksCli
     end
 
     def write_to_file(attrs, path)
-      File.open(path, 'w') {|file| file.write(attrs.to_json)}
+      s3.put_object(bucket: s3_bucket, key: path, body: attrs.to_json)
     end
 
     def read(path)
-      f = File.read(path)
-      JSON.parse(f)
+      resp = s3.get_object(bucket: s3_bucket, key: path)
+      body = resp.body.read
+      JSON.parse(body)
     end
 
     def groups_path
-      with_config_dir { |dir| "#{dir}/groups.json" }
+      "#{dir}/groups.json"
     end
 
     def state_path
-      with_config_dir { |dir| "#{dir}/state.json" }
+      "#{dir}/state.json"
     end
 
     def config_path
-      with_config_dir { |dir| "#{dir}/config.json" }
+      "#{dir}/config.json"
     end
 
     def dir
-      "#{ENV['HOME']}/.eks/#{@cluster_name}"
+      "eks-cli/#{@cluster_name}"
+    end
+
+    def s3_bucket
+      self.class.s3_bucket
     end
 
-    def with_config_dir
-      FileUtils.mkdir_p(dir)
-      yield dir
+    def s3
+      @s3 ||= Aws::S3::Client.new
     end
 
   end

data/lib/eks_cli/version.rb

@@ -1,3 +1,3 @@
 module EksCli
-  VERSION = "0.4.4"
+  VERSION = "0.4.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eks_cli
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.5
 platform: ruby
 authors:
 - Erez Rabih
@@ -10,6 +10,20 @@ bindir: bin
 cert_chain: []
 date: 2018-11-18 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-s3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement