kubert 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 11a4977bc3bcc125b5c7d631fde64ad7d4bcd857
-  data.tar.gz: 257585ae70feb31f2896193dab4ac09041100a95
+  metadata.gz: b10631ed96955a9a447aeaf376dbd7e4ca077908
+  data.tar.gz: 4fbf424aa122d476bb4043bc37ceb1066cffddf4
 SHA512:
-  metadata.gz: 0401b4d08e0b7cfb568368a8779c810e20fe466163a394a485afed04327b5855eed089769e997ae5573facce97531ac9bd4dec474b69f6d5c083a9d8e376a9db
-  data.tar.gz: 7f9705992329e778645ea4b0df82db81389b321bf7d3b81a018c81b786b44ea398ae904f84431fbab8f6e7bbfbe19d518013237462f3daab88e40fa6289e42cc
+  metadata.gz: 38e72a5c366ff85f1e6b0b5e3964b537984b6d6503e579edc2d0e48fcf7e152302d550a588168944cb656688bba328b4a48e344b7b39f52dd1939576f33c49f0
+  data.tar.gz: c6c36898f08d865f6f9fb441c01ec0400fd934d2b3f54b027ca4a2fd62d1a88f83b11bde2024860f8f3ce34da6de1f343ff8823e8c57d6fcc0fe611a51121c44

data/README.md

@@ -1,8 +1,8 @@
 # Kubert - Your helpful kubernetes ruby terminal friend!
 
-## The gem relies on a second gem, [ky](https://github.com/stellaservice/ky) which may be used independently
+## The gem relies on a second gem, [ky](https://github.com/stellaservice/ky), though the two may also be used independently, other than a shared config file.
 
-# Install gem via `gem install kubert` as usual.  This will also install the ky gem, which handles configuration.
+Install gem via `gem install kubert` as usual.  This will also install the ky gem, which handles configuration and manages environments and DRYing yaml for deployments.  (If anyone wanted to provide similar interoperability with [helm](http://helm.sh) that would be awesome, we might prefer using that as the more standard solution but we use ky for now for various interoperabiltiy related reasons.)
 
 Kubert assumes your kubernetes config file lives in `~/.kube/config` and reads that to talk to the cluster.
 
@@ -11,21 +11,31 @@ Compile and Rollback actions are only available if using ky for generating your
 ky manages the scope of a deployment as a group of related, seperate kubernetes deployments.  Typing `ky example` at the console will import example ky configuration, including kubert configuration.  You may ignore/delete most of this if not using ky itself, and focus primarily on the kubert section of the yml for a few pieces of kubert configuration...  the important ones are these:
 
 ```
+environments: [dev, stg, prd]
+secret_path: "deploy/my-project.secret.yml"
+config_path: "deploy/my-project.configmap.yml"
 project_name: "my-project"
 kubert:
   contexts:
-    staging: staging.example.com   # as many values here as you have distinct clusters in kubeconfig
+    staging: staging.example.com                  # as many values here as you have distinct clusters in kubeconfig
     prod: production.example.com
-  excluded_deployments: [sanitize, migration] # optional/possibly uncommon use case, see below
+  excluded_deployments: [sanitize,migration]      # optional/possibly uncommon use case, see below
   default_environment: stg
-  default_namespace: default       # defaults to same as default_environment, specify if different
-  task_pod: console
-  console_command: rails c         # optional, but no console command unless present
-  command_prefix: bundle exec      # optional
-  kube_config_path: ~/.kube/config # No need to specify unless you store file elsewhere
+  default_namespace: default                      # defaults to same as default_environment, specify if different
+  task_pod: console                               # deployment id (from Procfile) for tasks/console, selected at random if blank
+  console_command: rails c                        # optional, but no console command unless present
+  command_prefix: bundle exec                     # optional
+  kube_config_path: ~/.kube/config                # No need to specify unless you store file elsewhere
+  s3_secret_path: s3://my-bucket/environments/    # If defined, must manually install aws-sdk gem and have credentials for bucket as defaults (for now)
+  s3_config_path: s3://my-bucket/environments     # Ditto, with or w/o trailing slash, less likely as could be checked in but supporting for symmetry
 ```
 
-The project name is used by ky and assumes a metadata namespace for your app deployments in the format of `{{project_name}}-{{deployment_name}}`, so as long as your deployments obey this pattern it should be usable for you without ky.
+project_name is used by ky and assumes a metadata namespace for your app deployments in the format of `{{project_name}}-{{deployment_name}}`, so as long as your deployments obey this pattern it should be usable for you without ky.
+
+environments defines valid environments with overrideable configuration located in the same directory as ky config with names like `stg.yml`
+
+secret_path and config_path will likely NOT be defined in your global ky configuration as above but in environment specific files... ky assumes one such file per environment listed in the environments config, and merges any keys defined in those files (under a configuration key) as overrides of the global ky config, but perhaps in this example dev and stg share configmap and secret so only prd needs to override these
+
 contexts is used to create convenience functions for switching between different clusters defined in the same kubeconfig file, i.e. `kubert staging` with above config will switch/ensure your config is using staging.example.com
 
 excluded_deployments says not to deploy the following deployments defined in your Procfile during a normal deployment, and not to rollback during a rollback.
@@ -38,17 +48,30 @@ console_command and console_prefix are for opening a REPL and for prefixing all
 
 kube_config_path is probably not needed unless your kubernetes config is located elsewhere
 
+s3_secret_path and s3_config_path tell kubert not to use the locally configured ky build path, but to read and write either/both values to a an s3 bucket
+The value provided must begin with s3:// and provide bucket name and path to a folder in bucket containing one folder per environment, i.e. for
+example above s3://my-bucket/environments/stg/my-project.secret.yml and s3://my-bucket/environments/stg/my-project.configmap.yml
+
+Kubert will also download from these locations when deploying to kubernetes, and then delete when done to avoid confusion/leaking data, if specified.
+
 ###Example usage
 ```
-$ kubert console                  # open a console on a task_pod
-$ kubert execute rake db:migrate  # run a migration
-$ kubert list web                 # list all running web pods
-$ kubert sandbox                  # only if rails c/rails console is console_command above, opens console wrapped in DB transaction
-$ kubert context                  # print current kubectl context/cluster
-$ kubert deploy -e prd            # perform a production deployment
-$ kubert rollback -e prd          # rollback a production deployment
-$ kubert deploy                   # perform a deployment to the default environment
-$ kubert logs web                 # tail the logs from all web pods and interleave together
+$ kubert console                        # open a console on a task_pod
+$ kubert execute rake db:migrate        # run a migration
+$ kubert list web                       # list all running web pods
+$ kubert sandbox                        # only if rails c/rails console is console_command above, opens console wrapped in DB transaction
+$ kubert context                        # print current kubectl context/cluster
+$ kubert deploy -e prd                  # perform a production deployment
+$ kubert rollback -e prd                # rollback a production deployment
+$ kubert deploy                         # perform a deployment to the default environment
+$ kubert logs web                       # tail the logs from all web pods and interleave together
+$ kubert env all                        # print all secret/configmap values, with secrets sanitized showing last 4 characters
+$ kubert env all --cleartext-secrets    # print all secret/configmap values, with secrets fully visible
+$ kubert env get secret-or-config-key   # print one env value defined in configmap or secrets for default environment
+$ kubert env set key value              # update one env key/value defined in configmap or secrets for default environment
+$ kubert env set key value -s           # create new env key/value defined in secrets for default environment
+$ kubert env set key value -c           # create new env key/value defined in configmap for default environment
+$ kubert env unset key                  # remove an env key/value defined in configmap or secrets for default environment
 ```
 
-A valid url may also be used in place of a file path for input.
+A valid url may also be used in place of a file path for input.

data/lib/kubert.rb

@@ -4,63 +4,14 @@ require 'open3'
 require 'fiber'
 require_relative "kubert/pods"
 require_relative "kubert/deployment"
+require_relative "kubert/environment"
+require_relative "kubert/configuration"
+require_relative "kubert/file_access"
+require_relative "kubert/env_cli"
 
 module Kubert
-  extend self
-  DEFAULT_KUBE_CONFIG_PATH = '~/.kube/config'
-  def kube_config
-    @kube_config ||= Kubeclient::Config.read(File.expand_path(kube_config_path))
-  end
-
-  def kube_config_path
-    configuration[:kube_config_path] || DEFAULT_KUBE_CONFIG_PATH
-  end
-
-  def contexts
-    configuration[:contexts] || []
-  end
-
-  def task_pod
-    configuration[:task_pod] || random_pod_type
-  end
-
-  def default_environment
-    configuration[:default_environment]
-  end
-
-  def default_namespace
-    configuration[:default_namespace] || configuration[:default_environment]
-  end
-
-  def context
-    kube_config.contexts.select {|c| kube_config.context.api_endpoint.match(c) }
-  end
-
-  def console_command
-    Array(configuration[:console_command] && configuration[:console_command].split(" "))
-  end
-
-  def command_prefix
-    configuration[:command_prefix]
-  end
-
-  def excluded_deployments
-    configuration[:excluded_deployments] || []
-  end
-
-  def ky_configuration
-    @ky_configuration ||= KY::Configuration.new
-  end
-
-  def ky_active?
-    ky_configuration[:image] && ky_configuration[:deployment] && ky_configuration[:procfile_path]
-  end
-
-  def configuration
-    @config ||= (ky_configuration[:kubert] || {}).merge(project_name: ky_configuration[:project_name])
-  end
-
-  def client
+  extend Configuration
+  def self.client
     @client ||= begin
       Kubeclient::Client.new(
         kube_config.context.api_endpoint,
@@ -72,22 +23,4 @@ module Kubert
       )
     end
   end
-
-  private
-
-  def random_pod_type
-    Kubert.client.get_pods(namespace: current_namespace)
-    .sample
-    .metadata
-    .name
-    .split("-")
-    .first
-  end
-
-  def current_namespace
-    ky_configuration[:namespace]        ||
-    default_namespace                   ||
-    (raise "MUST DEFINE A NAMESPACE FOR POD OPERATIONS, ky namespace, default_namespace or default_environment")
-  end
-
 end

data/lib/kubert/cli.rb

@@ -38,8 +38,8 @@ module Kubert
       Pods.execute(command)
     end
 
-    desc "logs pod_type (status, default Running)", "Interleave and tail logs from all running pods of the specified type"
-    def logs(pod_type, status= :running)
+    desc "logs (pod_type, default 'web') (status, default 'Running')", "Interleave and tail logs from all running pods of the specified type"
+    def logs(pod_type='web', status= :running)
       Pods.logs(pod_type, status)
     end
 
@@ -49,20 +49,27 @@ module Kubert
       method_option :namespace, type: :string, aliases: "-n"
       method_option :environment, type: :string, aliases: "-e"
       method_option :image_tag, type: :string, aliases: "-t"
-      method_option :configmap_path, type: :string, aliases: "-c"
-      method_option :secrets_path, type: :string, aliases: "-s"
+      method_option :configmap_path, type: :string, aliases: "-k"
+      method_option :secrets_path, type: :string, aliases: "-p"
       method_option :output_dir, type: :string, aliases: "-o"
+      method_option :skip_confirmation, type: :boolean, aliases: "-s"
       def deploy
         Deployment.perform(options)
       end
 
+      desc "env", "Sub commands to manage secrets and configmap values"
+      def env(*args)
+        Kubert::EnvCli.start(args)
+      end
+
       desc "rollback", "Rollback a deployment, reverse of a kubert deploy command with same flags"
       method_option :namespace, type: :string, aliases: "-n"
       method_option :environment, type: :string, aliases: "-e"
       method_option :image_tag, type: :string, aliases: "-t"
-      method_option :configmap_path, type: :string, aliases: "-c"
-      method_option :secrets_path, type: :string, aliases: "-s"
+      method_option :configmap_path, type: :string, aliases: "-k"
+      method_option :secrets_path, type: :string, aliases: "-p"
       method_option :output_dir, type: :string, aliases: "-o"
+      method_option :skip_confirmation, type: :boolean, aliases: "-s"
       def rollback
         Deployment.rollback(options)
       end

data/lib/kubert/configuration.rb

@@ -0,0 +1,81 @@
+module Kubert
+  module Configuration
+    DEFAULT_KUBE_CONFIG_PATH = '~/.kube/config'
+    def kube_config
+      @kube_config ||= Kubeclient::Config.read(File.expand_path(kube_config_path))
+    end
+
+    # Config methods which correspond to config or default value/value_method
+    {
+      default_environment: nil,
+      command_prefix: nil,
+      s3_secret_path: nil,
+      s3_config_path: nil,
+      kube_config_path: DEFAULT_KUBE_CONFIG_PATH,
+      contexts: [],
+      excluded_deployments: [],
+      task_pod: :random_pod_type,
+      default_namespace: :default_environment
+    }.each do |config, default_value|
+      define_method(config) do
+        return configuration[config] if configuration[config]
+        default_value.is_a?(Symbol) ? public_send(default_value) : default_value
+      end
+    end
+
+    def context
+      kube_config.contexts.select {|c| kube_config.context.api_endpoint.match(c) }
+    end
+
+    def console_command
+      Array(configuration[:console_command] && configuration[:console_command].split(" "))
+    end
+
+    def ky_configuration(options={})
+      @ky_configuration ||= KY::Configuration.new({environment: Kubert.default_environment, namespace: Kubert.default_namespace}.merge(options))
+    end
+
+    def ky_active?
+      ky_configuration[:image] && ky_configuration[:deployment] && ky_configuration[:procfile_path]
+    end
+
+    def configuration
+      @configuration ||= begin
+        temp_ky_configuration = KY::Configuration.new
+        (temp_ky_configuration[:kubert] || {}).merge(project_name: temp_ky_configuration[:project_name])
+      end
+    end
+
+    def config_file_name
+      "#{configuration[:project_name]}#{KY::Manipulation::CONFIG_SUFFIX}"
+    end
+
+    def secret_file_name
+      "#{configuration[:project_name]}#{KY::Manipulation::SECRET_SUFFIX}"
+    end
+
+    def current_namespace
+      ky_configuration[:namespace]        ||
+      default_namespace                   ||
+      (raise "MUST DEFINE A NAMESPACE FOR POD OPERATIONS, ky namespace, default_namespace or default_environment")
+    end
+
+    def current_environment
+      ky_configuration[:environment]        ||
+      default_environment                   ||
+      (raise "MUST DEFINE AN ENVIRONMENT FOR SECRETS, ky environment, environment flag in command or default_environment")
+    end
+
+    private
+
+    def random_pod_type
+      Kubert.client.get_pods(namespace: current_namespace)
+      .sample
+      .metadata
+      .name
+      .split("-")
+      .first
+    end
+
+  end
+end

data/lib/kubert/deployment.rb

@@ -8,11 +8,11 @@ module Kubert
       new(options).rollback
     end
 
-    attr_reader :project_name, :deployments, :options, :operation_statuses
+    attr_reader :project_name, :options, :operation_statuses
     def initialize(options, project_name= Kubert.configuration[:project_name])
       @project_name = project_name
-      @deployments = []
       @options = options
+      Kubert.ky_configuration(options) # memoize options for FileAccess usage
     end
 
     def rollback
@@ -26,15 +26,25 @@ module Kubert
 
     def perform
       confirm :deploy do
-        perform_with_status { `kubectl apply -f #{output_dir}/#{Kubert.configuration[:project_name]}#{KY::Manipulation::CONFIG_SUFFIX}` }
-        perform_with_status {`kubectl apply -f #{output_dir}/#{Kubert.configuration[:project_name]}#{KY::Manipulation::SECRET_SUFFIX}` }
-        compilation.deploy_generation.to_h.each do |deployment_file, _template_hash|
-          perform_with_status { `kubectl apply -f #{deployment_file}` unless excluded?(deployment_file) }
+        handle_env_deploy(:config) do
+          handle_env_deploy(:secret) do
+            compilation.deploy_generation.to_h.each do |deployment_file, _template_hash|
+              perform_with_status { `kubectl apply -f #{File.expand_path(deployment_file)} --record` unless excluded?(deployment_file) }
+            end
+            report_status(:deploy)
+          end
         end
-        report_status(:deploy)
       end
     end
 
+    def handle_env_deploy(env)
+      data = FileAccess.new(:config)
+      data.write_local unless data.local?
+      perform_with_status { `kubectl apply -f #{File.expand_path(output_dir)}/#{Kubert.public_send("#{env}_file_name")} --record` }
+      yield
+      data.clean_local unless data.local?
+    end
+
     def compilation
       @compilation ||= KY::API.compile(options[:configmap_path], options[:secrets_path], options[:output_dir], options_with_defaults)
     end
@@ -42,11 +52,13 @@ module Kubert
     private
 
     def confirm(action)
-      unless ENV['SKIP_CONFIRMATION']
+      unless options[:skip_confirmation]
         puts "Press any key to confirm, ctl-c to abort: #{action.to_s.upcase} on #{Kubert.context}"
         $stdin.gets
       end
       yield
+    rescue Interrupt
+      puts "Aborting #{action}"
     end
 
     def report_status(action)

data/lib/kubert/env_cli.rb

@@ -0,0 +1,41 @@
+require 'thor'
+module Kubert
+  class EnvCli < Thor
+    desc "env all", "Get all keys and values from configmap and secrets"
+    method_option :environment, type: :string, aliases: "-e"
+    method_option :configmap_path, type: :string, aliases: "-k"
+    method_option :secrets_path, type: :string, aliases: "-p"
+    method_option :cleartext_secrets, type: :string, aliases: "-c"
+    def all
+      Environment.get(nil, options)
+    end
+
+    desc "env get", "Get named env value from configmap or secrets"
+    method_option :environment, type: :string, aliases: "-e"
+    method_option :configmap_path, type: :string, aliases: "-k"
+    method_option :secrets_path, type: :string, aliases: "-p"
+    def get(key)
+      Environment.get(key, options)
+    end
+
+    desc "env unset", "Clear named env value from configmap or secrets, error if not present"
+    method_option :environment, type: :string, aliases: "-e"
+    method_option :configmap_path, type: :string, aliases: "-k"
+    method_option :secrets_path, type: :string, aliases: "-p"
+    method_option :cleartext_secrets, type: :string, aliases: "-c"
+    def unset(key)
+      Environment.unset(key, options)
+    end
+
+    method_option :environment, type: :string, aliases: "-e"
+    method_option :configmap_path, type: :string, aliases: "-k"
+    method_option :secrets_path, type: :string, aliases: "-p"
+    method_option :new_secret, type: :string, aliases: "-s"
+    method_option :new_config, type: :string, aliases: "-c"
+    desc "env set", "change existing env value in configmap or secrets, or new one with flag option"
+    def set(key, value)
+      Environment.set(key, value, options)
+    end
+
+  end
+end

data/lib/kubert/environment.rb

@@ -0,0 +1,122 @@
+module Kubert
+  class Environment
+    PEEK_LENGTH = 4
+    def self.get(key, options)
+      new(key, nil, options).get
+    end
+
+    def self.set(key, value, options)
+      new(key, value, options).set
+    end
+
+    def self.unset(key, options)
+      new(key, nil, options).set
+    end
+
+    def initialize(key, value, raw_options)
+      @key      = key
+      @value    = value
+      @options  = raw_options.with_indifferent_access
+      abort("ERROR: Cannot specify env set as both new_secret and new_config") if options[:new_config] && options[:new_secret]
+      Kubert.ky_configuration(options) # memoizes and avoids passing to FileAccess
+      @config_data = FileAccess.new(:config, yaml_key)
+      @secret_data = FileAccess.new(:secret, yaml_key)
+      return if print_all?
+      @create_mode      = (options[:new_config] || options[:new_secret])&.to_sym
+    end
+
+    def set
+      if create_mode
+        abort("ERROR: #{key} exists but #{create_mode} flag set! Call without flag to update existing value") unless total_found == 0
+        create
+      else
+        report_unchanged if existing_value == value
+        update
+      end
+    end
+
+    def get
+      return get_all if print_all?
+      case total_found
+      when 0
+        puts "#{yaml_key} not found in configmap or secrets"
+      when 1
+        puts existing_value
+      else
+        puts "ERROR! multiple entries found for key: config - #{config_data.found}, secret - #{secret_data.found}"
+      end
+    end
+
+    private
+    attr_reader :key, :value, :options, :create_mode, :config_data, :secret_data
+
+    def print_all?
+      key.nil? && value.nil?
+    end
+
+    def get_all
+      puts "CONFIGMAP:"
+      output_hash(config_data.data[:data])
+      puts "SECRETS:"
+      output_hash(options[:cleartext_secrets] ? secret_data.data[:data] : obscured_secrets)
+    end
+
+    def output_hash(hsh)
+      hsh.each {|k, v| puts "#{k}: #{v}" }
+    end
+
+    def create
+      case create_mode
+      when :new_secret
+        secret_data.set(value).write
+      when :new_config
+        config_data.set(value).write
+      else
+        abort("ERROR: unknown create env type error")
+      end
+    end
+
+    def update
+      if secret_data.found.any?
+        secret_data.set(value).write
+      elsif config_data.found.any?
+        config_data.set(value).write
+      else
+        abort("ERROR: your key is new, must specify secret or configmap with flag")
+      end
+    end
+
+    def obscured_secrets
+      values = secret_data.data[:data].values
+      secret_data.data[:data].keys.zip(
+        values.map do |secret|
+          obscure_length = [(secret.size - PEEK_LENGTH), 0].max
+          sneak_peek = secret.slice(obscure_length, secret.size)
+          "#{'*' * obscure_length}#{sneak_peek}"
+        end
+      )
+    end
+
+    def insert_ordered_hash(hsh)
+      hsh[:data][yaml_key] = value
+      hsh[:data] = hsh[:data].sort.to_h
+    end
+
+    def existing_value
+      config_data.found.merge(secret_data.found).values.first
+    end
+
+    def total_found
+      secret_data.found.size + config_data.found.size
+    end
+
+    def report_unchanged
+      puts "WARN: #{key} value unchanged, already set to #{value}"
+    end
+
+    def yaml_key
+      key&.downcase&.dasherize
+    end
+
+  end
+end

data/lib/kubert/file_access.rb

@@ -0,0 +1,75 @@
+module Kubert
+  class FileAccess
+    attr_reader :data
+    def initialize(type, key = nil)
+      @type = type
+      @key = key
+      @s3_path = Kubert.public_send("s3_#{type}_path")
+      @file_name = Kubert.public_send("#{type}_file_name")
+      @data = read
+    end
+
+    def found
+      data[:data].select {|k, _v| k == key }
+    end
+
+    def read
+      YAML.load(file_read).with_indifferent_access
+    end
+
+    def set(value)
+      if value.nil?
+        data[:data].delete(key)
+      else
+        data[:data][key] = value
+      end
+      self
+    end
+
+    def get
+      data[:data][key]
+    end
+
+    def local?
+      !s3_path
+    end
+
+    def write
+      return write_local if local?
+      s3_object.put(body: data.to_plain_yaml, content_encoding: 'application/octet-stream', content_type: "text/vnd.yaml", metadata: {author: `whoami`})
+    end
+
+    def write_local
+      File.write(local_path, data.to_plain_yaml)
+    end
+
+    def clean_local
+      File.delete(local_path)
+    end
+
+    private
+
+    attr_reader :s3_path, :file_name, :type, :key
+
+    def file_read
+      return s3_object.get.body.read unless local?
+      File.read(local_path)
+    end
+
+    def local_path
+      Kubert.ky_configuration["#{type}_path"] # options set & memoized elsewhere if needed
+    end
+
+    def s3_object
+      @s3_object ||= begin
+        require 'aws-sdk'
+        s3 = Aws::S3::Resource.new
+        match_data = s3_path.match(/\As3:\/\/(?<bucket>[^\/]+)\/(?<folder_path>\S+[^\/])\/?\z/)
+        bucket = s3.bucket(match_data[:bucket])
+        bucket.objects(prefix: "#{match_data[:folder_path]}/#{Kubert.current_namespace}/#{file_name}").first
+      rescue LoadError
+        puts "ERROR: s3_#{type}_path defined, but aws-sdk gem not available... it is not a hard dependency of kubert, but kubert requires it for s3 read/write if s3_#{type}_path defined"
+      end
+    end
+  end
+end

data/lib/kubert/version.rb

@@ -1,3 +1,3 @@
 module Kubert
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kubert
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Brian Glusman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-29 00:00:00.000000000 Z
+date: 2017-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -119,8 +119,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- ".rspec"
-- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -131,7 +129,11 @@ files:
 - kubert.gemspec
 - lib/kubert.rb
 - lib/kubert/cli.rb
+- lib/kubert/configuration.rb
 - lib/kubert/deployment.rb
+- lib/kubert/env_cli.rb
+- lib/kubert/environment.rb
+- lib/kubert/file_access.rb
 - lib/kubert/pods.rb
 - lib/kubert/version.rb
 homepage: 

data/.rspec

@@ -1,2 +0,0 @@
---format documentation
---color

data/.travis.yml

@@ -1,5 +0,0 @@
-sudo: false
-language: ruby
-rvm:
-  - 2.3.1
-before_install: gem install bundler -v 1.13.6