kuby-core 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5ecf6df1172c327a682b1db7ea6ef1b0d9df936f9ae3599f09a548ebdad20980
+  data.tar.gz: ebb10f441864a243a61ac493594461d4c5c6223f82f063ca0c58f2ba2bb97aba
+SHA512:
+  metadata.gz: 432a5cfc254e69243a4a8c6009592b67aec84a77b91db62ec64496fca0d858fec4ee167d6995eded577ad96511eafb3eaa96e2993a8913167d301fae6b9534ce
+  data.tar.gz: 36df0acb5eca66ad07dea436f34434a61a6a841c8c84503af72d3222e18325224b648ae0828091dcd09344e41a22436b26013b51a45a4d16309f02b2409b0f32

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## 0.1.0
+* Birthday!

data/Gemfile

@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'kube-dsl', path: '../kube-dsl'
+gem 'kuby-kube-db', path: '../kuby-kube-db'
+gem 'kuby-cert-manager', path: '../kuby-cert-manager'
+
+group :development, :test do
+  gem 'pry-byebug'
+  gem 'rake'
+end
+
+group :test do
+  gem 'rspec', '~> 3.0'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Cameron Dutro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,186 @@
+## Kuby
+
+Deploy your Rails app the easy way.
+
+## What is Kuby?
+
+At its core, Kuby is a set of tools and smart defaults that encapsulate and codify years of established best-practices around deploying webapps, reducing the amount of time required to take your Rails project from an app that runs on your computer to an app that runs on the Internet.
+
+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.2 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
+
+    ```sh
+    bundle exec rake kuby:push
+    ```
+1. Deploy!
+
+    ```sh
+    bundle exec rake kuby:deploy
+    ```
+1. Rejoice
+
+## Running Tests
+
+`bundle exec rspec` should do the trick... or at least it would if there were any tests. Don't worry, it's on my radar.
+
+## License
+
+Licensed under the MIT license. See LICENSE for details.
+
+## Authors
+
+* Cameron C. Dutro: http://github.com/camertron

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'rubygems/package_task'
+
+require 'kuby'
+
+Bundler::GemHelper.install_tasks
+
+task default: :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = './spec/**/*_spec.rb'
+end

data/kuby-core.gemspec

@@ -0,0 +1,27 @@
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'kuby/version'
+
+Gem::Specification.new do |s|
+  s.name     = 'kuby-core'
+  s.version  = ::Kuby::VERSION
+  s.authors  = ['Cameron Dutro']
+  s.email    = ['camertron@gmail.com']
+  s.homepage = 'http://github.com/getkuby/kuby-core'
+
+  s.description = s.summary = 'Deploy your Rails app onto Kubernetes the easy way.'
+
+  s.platform = Gem::Platform::RUBY
+
+  s.add_dependency 'colorize', '~> 0.8'
+  s.add_dependency 'docker-remote', '~> 0.1'
+  s.add_dependency 'krane', '~> 1.0'
+  s.add_dependency 'kuby-cert-manager', '~> 0.1'
+  s.add_dependency 'kube-dsl', '~> 0.1'
+  s.add_dependency 'kuby-kube-db', '~> 0.1'
+  s.add_dependency 'kubernetes-cli', '~> 0.1'
+  s.add_dependency 'railties', '~> 6.0'
+  s.add_dependency 'rouge', '~> 3.0'
+
+  s.require_path = 'lib'
+  s.files = Dir['{lib,spec}/**/*', 'Gemfile', 'LICENSE', 'CHANGELOG.md', 'README.md', 'Rakefile', 'kuby-core.gemspec']
+end

data/lib/kuby.rb

@@ -0,0 +1,112 @@
+require 'kuby/railtie'
+
+module Kuby
+  autoload :BasicLogger,  'kuby/basic_logger'
+  autoload :CLIBase,      'kuby/cli_base'
+  autoload :Definition,   'kuby/definition'
+  autoload :Docker,       'kuby/docker'
+  autoload :Kubernetes,   'kuby/kubernetes'
+  autoload :Middleware,   'kuby/middleware'
+  autoload :Tasks,        'kuby/tasks'
+  autoload :TrailingHash, 'kuby/trailing_hash'
+
+  class UndefinedEnvironmentError < StandardError; end
+
+  class << self
+    attr_reader :definition
+    attr_accessor :logger
+
+    def define(environment, app = Rails.application, &block)
+      environment = environment.to_s
+      definitions[environment] ||= Definition.new(environment, app, &block)
+    end
+
+    def definitions
+      @definitions ||= {}
+    end
+
+    def definition(environment = env)
+      definitions.fetch(environment.to_s) do
+        raise UndefinedEnvironmentError, "couldn't find a Kuby environment named "\
+          "'#{environment}'"
+      end
+    end
+
+    def register_provider(provider_name, provider_klass)
+      providers[provider_name] = provider_klass
+    end
+
+    def providers
+      @providers ||= {}
+    end
+
+    def register_plugin(plugin_name, plugin_klass)
+      plugins[plugin_name] = plugin_klass
+    end
+
+    def register_distro(distro_name, distro_klass)
+      distros[distro_name] = distro_klass
+    end
+
+    def distros
+      @distros ||= {}
+    end
+
+    def plugins
+      @plugins ||= {}
+    end
+
+    def register_package(package_name, package_def)
+      packages[package_name] = case package_def
+        when String
+          Kuby::Docker::Packages::ManagedPackage.new(
+            package_name, debian: package_def, alpine: package_def
+          )
+        when Hash
+          Kuby::Docker::Packages::ManagedPackage.new(
+            package_name, package_def
+          )
+        else
+          package_def.new(package_name)
+      end
+    end
+
+    def packages
+      @packages ||= {}
+    end
+
+    def env
+      ENV.fetch('KUBY_ENV') do
+        (definitions.keys.first || Rails.env).to_s
+      end
+    end
+  end
+end
+
+# providers
+Kuby.register_provider(:minikube, Kuby::Kubernetes::MinikubeProvider)
+
+# plugins
+Kuby.register_plugin(:rails_app, Kuby::Kubernetes::Plugins::RailsApp::Plugin)
+Kuby.register_plugin(:nginx_ingress, Kuby::Kubernetes::Plugins::NginxIngress)
+
+# distros
+Kuby.register_distro(:debian, Kuby::Docker::Debian)
+Kuby.register_distro(:alpine, Kuby::Docker::Alpine)
+
+# packages
+Kuby.register_package(:nodejs, Kuby::Docker::Packages::Nodejs)
+Kuby.register_package(:yarn, Kuby::Docker::Packages::Yarn)
+
+Kuby.register_package(:ca_certificates, 'ca-certificates')
+Kuby.register_package(:tzdata, 'tzdata')
+
+Kuby.register_package(:c_toolchain,
+  debian: 'build-essential',
+  alpine: 'build-base'
+)
+
+Kuby.register_package(:sqlite_dev,
+  debian: 'libsqlite3-dev',
+  alpine: 'sqlite-dev'
+)

data/lib/kuby/basic_logger.rb

@@ -0,0 +1,22 @@
+require 'logger'
+require 'colorized_string'
+
+module Kuby
+  class BasicLogger < Logger
+    def initialize(*args)
+      super
+
+      self.formatter = proc do |_severity, _datetime, _progname, msg|
+        "#{msg}\n"
+      end
+    end
+
+    def info(msg, *args)
+      super(ColorizedString[msg].yellow, *args)
+    end
+
+    def fatal(msg, *args)
+      super(ColorizedString[msg].red, *args)
+    end
+  end
+end

data/lib/kuby/cli_base.rb

@@ -0,0 +1,75 @@
+require 'open3'
+require 'thread'
+
+module Kuby
+  class CLIBase
+    def last_status
+      Thread.current[status_key]
+    end
+
+    def before_execute(&block)
+      @before_execute ||= []
+      @before_execute << block
+    end
+
+    def after_execute(&block)
+      @after_execute ||= []
+      @after_execute << block
+    end
+
+    private
+
+    def open3_w(env, cmd, opts = {}, &block)
+      run_before_callbacks(cmd)
+      cmd_s = cmd.join(' ')
+
+      Open3.pipeline_w([env, cmd_s], opts) do |stdin, wait_threads|
+        yield(stdin, wait_threads).tap do
+          stdin.close
+          self.last_status = wait_threads.last.value
+          run_after_callbacks(cmd)
+        end
+      end
+    end
+
+    def execc(cmd)
+      run_before_callbacks(cmd)
+      cmd_s = cmd.join(' ')
+      exec(cmd_s)
+    end
+
+    def systemm(cmd)
+      run_before_callbacks(cmd)
+      cmd_s = cmd.join(' ')
+      system(cmd_s).tap do
+        self.last_status = $?
+        run_after_callbacks(cmd)
+      end
+    end
+
+    def backticks(cmd)
+      run_before_callbacks(cmd)
+      cmd_s = cmd.join(' ')
+      `#{cmd_s}`.tap do
+        self.last_status = $?
+        run_after_callbacks(cmd)
+      end
+    end
+
+    def run_before_callbacks(cmd)
+      (@before_execute || []).each { |cb| cb.call(cmd) }
+    end
+
+    def run_after_callbacks(cmd)
+      (@after_execute || []).each { |cb| cb.call(cmd, last_status) }
+    end
+
+    def last_status=(status)
+      Thread.current[status_key] = status
+    end
+
+    def status_key
+      raise NotImplementedError, "#{__method__} must be defined in derived classes"
+    end
+  end
+end