kuby-core 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42f6ba3c11212d10aeb9d878af3f91e4712f88498ddf1f6d94a29d26dfbd27d4
-  data.tar.gz: 624f45761eed5d05d45e115697a6f43e4fa4516fed17f1158a05af01266ef0e4
+  metadata.gz: b8199a0db99884940e43a0711cb6ec706d0828a6e553bb327f04d3370ee4c724
+  data.tar.gz: 4a07cf9105716b0d230a3935b33205321818e414d458e99058dcd23b9abbbf99
 SHA512:
-  metadata.gz: 46fda51d238e517907361f4da89ef9615383e55d3daad4c58eb8a0d947ccae27398ca340b9d2590274ff02ef312e9f8384fa7965a5470b4b3b0d8b0eb63527bb
-  data.tar.gz: b7589f6ad84cbd44276893466a15350ba24db01dc5183db3554dc8f5cff77b6834ec964c0591de4c3ad1293713e62f6f28766775b6c88074d3f36d6749afe522
+  metadata.gz: 5e4a38749d22b3dc559296aeaa15cff01d4b51a2bcfd754ec1f780a8a62a849dc85723bb8ee7e2a92f24eaa16c19b5e27e2c238682da2805077507441b87bae6
+  data.tar.gz: 6070a9a67c1aab75c1e7d1f0b7684bb6fbd899312df57aed642c5c7012d98e886a2880dfca21fec00d38646ba8cbef426fcf56e9a96ba4d4c0dc604b2aa61aa9

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.4.0
+* Introduce simple managed package.
+* Refactor deploy task into its own class.
+
 ## 0.3.0
 * Fix Krane issue causing incorrect constant lookup and therefore deploy failures.
   - See: https://github.com/Shopify/krane/pull/720

data/README.md

@@ -8,170 +8,13 @@ At its core, Kuby is a set of tools and smart defaults that encapsulate and codi
 
 Under the hood, Kuby leverages the power of Docker and Kubernetes. It tries to make these technologies accessible to the average Rails dev without requiring a devops black belt.
 
-## Raison d'etre
-
-One of Rails' most notorious mantras is "convention over configuration," i.e. sane defaults that limit the cognitive overhead of application development. Rails has survived for as long as it has precisely because it makes so many decisions for you, especially compared to other web application frameworks. It's easy to learn and easy to build with. The development experience is fantastic... right up until the point you want to deploy your app to production. It's at that point that the hand-holding stops. Like the Roadrunner, Rails stops right before the cliff and lets you, Wile E. Coyote, sail over the edge.
-
-![Wile E. Coytote](coyote.jpg)
-
-Perhaps [Stefan Wintermeyer](https://twitter.com/wintermeyer) said it best during his appearance on the Ruby Rogues podcast, [episode 403](https://devchat.tv/ruby-rogues/rr-403-rails-needs-active-deployment-with-stefan-wintermeyer/):
-
-> "In my experience, deployment is one of the major problems of normal Rails users. It is a big pain to set up a deployment system for a Rails application, and I don't see anything out there that makes it easier. [...] I believe that we lose quite a lot of companies and new developers on this step. Because everything else [is] so much easier with Rails. But that last step - and it's a super important step - is still super complicated."
-
-## Docker and Kubernetes
-
-Why bet the farm on Docker and Kubernetes?
-
-### Docker
-
-When Docker came on the scene in 2013 it was seen as a game-changer. Applications that used to be deployed onto hand-provisioned servers can now be bundled up into neat little packages and transferred between computers in their entirety. Since the whole application - dependencies, operating system components, assets, code, etc - can be passed around as a single artifact, Docker images curtail the need for manually provisioned servers and eliminate a whole class of "works on my machine" problems.
-
-### Kubernetes
-
-Kubernetes has taken the ops world by storm. It's resilient to failure, portable across a variety of cloud providers, and backed by industry-leading organizations like the CNCF. Kubernetes configuration is portable enough to be used, without modification, on just about any Kubernetes cluster, making migrations not only feasible, but easy. Many cloud providers like Google GCP, Amazon AWS, Microsoft Azure, DigitalOcean, and Linode support Kubernetes. Most of these providers will manage the Kubernetes cluster for you, and in some cases will even provide it free of charge (you pay only for the compute resources).
-
 ## Getting Started
 
-NOTE: Kuby is designed to work with Rails 5.1 and up.
-
-### Choosing a Provider
-
-The first step in deploying your app is to choose a hosting provider. At the time of this writing, Kuby supports DigitalOcean and Linode, but support for more providers is coming soon. Use your provider's dashboard to spin up a Kubernetes cluster. In most cases, this shouldn't involve more than a few button clicks.
-
-### The Container Registry
-
-Kuby uses Docker to package up your application into a Docker _image_. Images are then pushed (i.e. uploaded) to something called a "container registry." Container registries host Docker images so they can be pulled (i.e. downloaded) later.
-
-Although there are a number of container registries available (some free and some paid), consider using the Gitlab registry. Gitlab's registry is free and unlimited. You don't have to host your code on Gitlab to take advantage of the registry, but they're great for that too.
-
-### Integrating Kuby
-
-Kuby configuration is done via a [DSL](https://en.wikipedia.org/wiki/Domain-specific_language). There are two main sections, one for Docker and one for Kubernetes. Put the config into a Rails initializer, eg. config/initializers/kuby.rb.
-
-Here's what a complete config looks like:
-
-```ruby
-Kuby.define(:production) do
-  docker do
-    credentials do
-      username ENV['DOCKER_USERNAME']
-      password ENV['DOCKER_PASSWORD']
-      email ENV['DOCKER_EMAIL']
-    end
-
-    image_url 'registry.gitlab.com/username/repo'
-  end
-
-  kubernetes do
-    provider :digitalocean do
-      access_token ENV['DIGITALOCEAN_ACCESS_TOKEN']
-      cluster_id 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
-    end
-
-    add_plugin :rails_app do
-      hostname 'mywebsite.com'
-    end
-  end
-end
-```
-
-Let's go over this config in detail.
-
-### Deploy Environments
-
-The first line defines the _deploy environment_:
-
-```ruby
-Kuby.define(:production)
-```
-
-Deploy environments usually closely mirror your Rails environments. For example, you might create a new Rails environment called "staging" or "preprod" that's used to test production changes before they go live. You'll want to create a "staging" Kuby deploy environment as well.
-
-If you're a small shop or hobbyist though, chances are the "production" deploy environment is all you need.
-
-### Configuring Docker
-
-Kuby can automatically "dockerize" your application. You just need to tell it where to push images and provide some credentials:
-
-```ruby
-docker do
-  credentials do
-    username ENV['DOCKER_USERNAME']
-    password ENV['DOCKER_PASSWORD']
-    email ENV['DOCKER_EMAIL']
-  end
-
-  image_url 'registry.gitlab.com/username/repo'
-end
-```
-
-The username, password, and email fields are used to authenticate with the Docker registry that hosts your images. For Gitlab, you'll need to create a [personal access token](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html) instead of your password. The `image_url` field is the full URL to your image, including the registry's domain.
-
-In the example above, the username, password, and email are all provided as environment variables. **NEVER** hard-code sensitive information like this in your Kuby config or check it into source control (i.e. git). Consider using a tool like [dotenv](https://github.com/bkeepers/dotenv) to automatically load the variables from a file when your app starts (NOTE: don't check the .env file into git either!)
-
-### Configuring Kubernetes
-
-Now that your app can be packaged up into a Docker image, it's time to use Kubernetes to run it. There are two top-level concerns in the Kubernetes section of your Kuby config: providers and plugins.
-
-#### Providers
-
-Each Kubernetes definition must have a provider configured. Providers correspond to the hosting provider you chose earlier. For example, you'll need to add the `:digitalocean` provider to deploy to a managed DigitalOcean Kubernetes cluster.
-
-```ruby
-kubernetes do
-  provider :digitalocean do
-    access_token ENV['DIGITALOCEAN_ACCESS_TOKEN']
-    cluster_id 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
-  end
-end
-```
-
-Kuby providers are distributed as individual rubygems. Add the one you need to your Gemfile, for example:
-
-```ruby
-gem 'kuby-digitalocean', '~> 0.1'
-```
-
-Providers can have different config options, so make sure you consult the gem's README for the provider you've chosen.
-
-#### Plugins
-
-Nearly all Kuby's functionality is provided via plugins. For example, simply add the `:rails_app` plugin to get your Rails app ready to deploy:
-
-```ruby
-add_plugin :rails_app
-```
-
-To indicate your app exists behind a particular domain name, specify the `hostname` option:
-
-```ruby
-add_plugin :rails_app do
-  hostname 'mywebsite.com'
-end
-```
-
-Configuring DNS to point to your Kubernetes cluster is outside the scope of this README, but all the hosting providers should have tutorials. For example, [here's the one](https://www.digitalocean.com/community/tutorials/how-to-point-to-digitalocean-nameservers-from-common-domain-registrars) from DigitalOcean.
-
-## Deploying
-
-Now that Kuby is configured and your Kubernetes cluster is ready, it's time to deploy!
-
-1. Build the Docker image
-
-    ```sh
-    bundle exec rake kuby:build
-    ```
-1. Push the Docker image to the container registry
+See the [Quick Start Guide](https://github.com/getkuby/kuby-core/wiki/Quick-Start-Guide)
 
-    ```sh
-    bundle exec rake kuby:push
-    ```
-1. Deploy!
+## More Info
 
-    ```sh
-    bundle exec rake kuby:deploy
-    ```
-1. Rejoice
+See the [wiki](https://github.com/getkuby/kuby-core/wiki).
 
 ## Running Tests
 

data/lib/kuby.rb

@@ -1,5 +1,10 @@
 require 'kuby/railtie'
 
+begin
+  require 'kuby/kubernetes/plugins/rails_app/generators/kuby'
+rescue NameError
+end
+
 module Kuby
   autoload :BasicLogger,  'kuby/basic_logger'
   autoload :CLIBase,      'kuby/cli_base'
@@ -56,11 +61,15 @@ module Kuby
       @plugins ||= {}
     end
 
-    def register_package(package_name, package_def)
+    def register_package(package_name, package_def = nil)
       packages[package_name] = case package_def
+        when NilClass
+          Kuby::Docker::Packages::SimpleManagedPackage.new(
+            package_name
+          )
         when String
-          Kuby::Docker::Packages::ManagedPackage.new(
-            package_name, debian: package_def, alpine: package_def
+          Kuby::Docker::Packages::SimpleManagedPackage.new(
+            package_def
           )
         when Hash
           Kuby::Docker::Packages::ManagedPackage.new(

data/lib/kuby/docker/packages.rb

@@ -1,10 +1,11 @@
 module Kuby
   module Docker
     module Packages
-      autoload :ManagedPackage, 'kuby/docker/packages/managed_package'
-      autoload :Nodejs,         'kuby/docker/packages/nodejs'
-      autoload :Package,        'kuby/docker/packages/package'
-      autoload :Yarn,           'kuby/docker/packages/yarn'
+      autoload :ManagedPackage,       'kuby/docker/packages/managed_package'
+      autoload :Nodejs,               'kuby/docker/packages/nodejs'
+      autoload :Package,              'kuby/docker/packages/package'
+      autoload :SimpleManagedPackage, 'kuby/docker/packages/simple_managed_package'
+      autoload :Yarn,                 'kuby/docker/packages/yarn'
     end
   end
 end

data/lib/kuby/docker/packages/simple_managed_package.rb

@@ -0,0 +1,25 @@
+module Kuby
+  module Docker
+    module Packages
+      class SimpleManagedPackage
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def package_name_for(distro)
+          name
+        end
+
+        def with_version(*)
+          self
+        end
+
+        def managed?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/kuby/kubernetes.rb

@@ -4,6 +4,7 @@ module Kuby
   module Kubernetes
     autoload :MinikubeProvider, 'kuby/kubernetes/minikube_provider'
     autoload :Deployer,         'kuby/kubernetes/deployer'
+    autoload :DeployTask,       'kuby/kubernetes/deploy_task'
     autoload :DockerConfig,     'kuby/kubernetes/docker_config'
     autoload :Manifest,         'kuby/kubernetes/manifest'
     autoload :Monitors,         'kuby/kubernetes/monitors'

data/lib/kuby/kubernetes/deploy_task.rb

@@ -0,0 +1,33 @@
+require 'krane'
+require 'ext/krane/kubernetes_resource'
+require 'kubectl-rb'
+
+module Kuby
+  module Kubernetes
+    class DeployTask
+      attr_reader :deploy_task
+
+      def initialize(**kwargs)
+        @deploy_task ||= ::Krane::DeployTask.new(**kwargs)
+      end
+
+      def run!(**kwargs)
+        new_path = "#{File.dirname(KubectlRb.executable)}:#{ENV['PATH']}"
+
+        with_env('PATH' => new_path) do
+          deploy_task.run!(**kwargs)
+        end
+      end
+
+      private
+
+      def with_env(new_env)
+        old_env = ENV.to_h
+        ENV.replace(old_env.merge(new_env))
+        yield
+      ensure
+        ENV.replace(old_env)
+      end
+    end
+  end
+end

data/lib/kuby/kubernetes/deployer.rb

@@ -1,6 +1,4 @@
 require 'fileutils'
-require 'krane'
-require 'ext/krane/kubernetes_resource'
 require 'securerandom'
 require 'yaml'
 
@@ -63,7 +61,7 @@ module Kuby
           File.write(resource_path, resource.to_resource.to_yaml)
         end
 
-        task = ::Krane::DeployTask.new(
+        task = ::Kuby::Kubernetes::DeployTask.new(
           namespace: namespace.metadata.name,
           context: cli.current_context,
           filenames: [tmpdir]

data/lib/kuby/kubernetes/plugins/rails_app/generators/kuby.rb

@@ -0,0 +1,43 @@
+require 'rails/generators/base'
+
+class KubyGenerator < Rails::Generators::Base
+  def create_initializer_file
+    initializer(
+      'kuby.rb',
+      <<~END
+        # Define a production Kuby deploy environment
+        Kuby.define(:production) do
+          docker do
+            # Configure your Docker registry credentials here. Add them to your
+            # Rails credentials file by running `bundle exec rake credentials:edit`.
+            credentials do
+              username Rails.application.credentials[:KUBY_DOCKER_USERNAME]
+              password Rails.application.credentials[:KUBY_DOCKER_PASSWORD]
+              email Rails.application.credentials[:KUBY_DOCKER_EMAIL]
+            end
+
+            # Configure the URL to your Docker image here, eg:
+            # image_url 'foo.bar.com/me/myproject'
+            #
+            # If you're using Gitlab's Docker registry, try something like this:
+            # image_url 'registry.gitlab.com/<username>/<repo>'
+          end
+
+          kubernetes do
+            # Add a plugin that facilitates deploying a Rails app.
+            add_plugin :rails_app
+
+            # Use minikube as the default provider.
+            # See: https://github.com/kubernetes/minikube
+            #
+            # Note: you will likely want to use a different provider when deploying
+            # your application into a production environment. To configure a different
+            # provider, add the corresponding gem to your gemfile and update the
+            # following line according to the provider gem's README.
+            provider :minikube
+          end
+        end
+      END
+    )
+  end
+end

data/lib/kuby/version.rb

@@ -1,3 +1,3 @@
 module Kuby
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kuby-core
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Cameron Dutro
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-18 00:00:00.000000000 Z
+date: 2020-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -173,6 +173,7 @@ files:
 - lib/kuby/docker/packages/managed_package.rb
 - lib/kuby/docker/packages/nodejs.rb
 - lib/kuby/docker/packages/package.rb
+- lib/kuby/docker/packages/simple_managed_package.rb
 - lib/kuby/docker/packages/yarn.rb
 - lib/kuby/docker/phase.rb
 - lib/kuby/docker/remote_tags.rb
@@ -183,6 +184,7 @@ files:
 - lib/kuby/docker/webserver_phase.rb
 - lib/kuby/docker/yarn_phase.rb
 - lib/kuby/kubernetes.rb
+- lib/kuby/kubernetes/deploy_task.rb
 - lib/kuby/kubernetes/deployer.rb
 - lib/kuby/kubernetes/docker_config.rb
 - lib/kuby/kubernetes/errors.rb
@@ -193,6 +195,7 @@ files:
 - lib/kuby/kubernetes/plugins/nginx_ingress.rb
 - lib/kuby/kubernetes/plugins/rails_app.rb
 - lib/kuby/kubernetes/plugins/rails_app/database.rb
+- lib/kuby/kubernetes/plugins/rails_app/generators/kuby.rb
 - lib/kuby/kubernetes/plugins/rails_app/mysql.rb
 - lib/kuby/kubernetes/plugins/rails_app/plugin.rb
 - lib/kuby/kubernetes/plugins/rails_app/postgres.rb