kuby-core 0.3.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42f6ba3c11212d10aeb9d878af3f91e4712f88498ddf1f6d94a29d26dfbd27d4
-  data.tar.gz: 624f45761eed5d05d45e115697a6f43e4fa4516fed17f1158a05af01266ef0e4
+  metadata.gz: 7d3f784993d379920477923911af9c73a7ac0f661a8831a3fdc21feea83e9d89
+  data.tar.gz: 97390f124219ba7e697253c551bbef2527b15d7234793a76431ebdde73e996ed
 SHA512:
-  metadata.gz: 46fda51d238e517907361f4da89ef9615383e55d3daad4c58eb8a0d947ccae27398ca340b9d2590274ff02ef312e9f8384fa7965a5470b4b3b0d8b0eb63527bb
-  data.tar.gz: b7589f6ad84cbd44276893466a15350ba24db01dc5183db3554dc8f5cff77b6834ec964c0591de4c3ad1293713e62f6f28766775b6c88074d3f36d6749afe522
+  metadata.gz: 95fceaebbb3959fb3b872b570b9202deb4dfd4a44dc363c25b20398f9e2a199091eb5fdecbeb07caceb2be104b94c07f3294e8b8158737416e2b83efe7e65ebe
+  data.tar.gz: 248b60b0c0ab90d10c780ce69e3f63ff6aa4b222cef82c5121abf2acb4b462c6534b245556a2683649ccf57440e758d5846e93322828f127c66784701ea11127

data/CHANGELOG.md

@@ -1,3 +1,53 @@
+## 0.7.0
+* Automatically perform `docker login` if not already logged into the Docker registry.
+* Fix timestamp tag parsing issue causing deploy to fail with no available tags.
+  - Issue turned out to be ignoring the month of October in the validation regex.
+
+## 0.6.1
+* Fix issue causing database.yml to not be rewritten to point at correct database host.
+
+## 0.6.0
+* Don't load the Rails environment when running Kuby's rake tasks.
+  - Kuby's gems are still part of the bundle, but config has been moved out of the initializer and into kuby.rb in the Rails root directory.
+  - Internal classes no longer retain a reference to `Rails.application`.
+  - Kuby config now requires `environment` blocks:
+      ```ruby
+      Kuby.define('my-app') do
+        environment(:production) do
+          ...
+        end
+
+        environment(:staging) do
+          ...
+        end
+      end
+      ```
+* Fix `MissingDistroError` caused by not setting a default distro.
+* Create a .dockerignore file when running the Rails generator.
+* Add ability to insert inline Docker layers without having to create a separate class, eg:
+    ```ruby
+    insert :hello, before: :bundler_phase do |dockerfile|
+      dockerfile.run('echo "hello, world"')
+    end
+    ```
+* Add Postgres database support.
+* Don't install sqlite libs by default.
+* Modify Rails generator
+  - Require kuby and load config safely.
+  - Provide manual access to credentials via `ActiveSupport::EncryptedConfiguration`, which is necessary now that our rake tasks don't load the Rails environment.
+* Add a convenience method for requesting the amount of block storage for the database.
+* Add the ability to entirely disable database management via `manage_database false`.
+* Avoid deploying nginx-ingress if it's already deployed.
+* Add rake task for running arbitrary `kubectl` commands.
+
+## 0.5.0
+* Fix Rails generators issue causing crash at startup.
+* Add rake task to run arbitrary kubectl commands.
+
+## 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/kuby-core.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |s|
   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 'kuby-cert-manager', '~> 0.2'
   s.add_dependency 'kube-dsl', '~> 0.3'
   s.add_dependency 'kuby-kube-db', '~> 0.4'
   s.add_dependency 'kubernetes-cli', '~> 0.2'
@@ -23,5 +23,6 @@ Gem::Specification.new do |s|
   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

@@ -1,10 +1,16 @@
 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'
   autoload :Definition,   'kuby/definition'
   autoload :Docker,       'kuby/docker'
+  autoload :Environment,  'kuby/environment'
   autoload :Kubernetes,   'kuby/kubernetes'
   autoload :Middleware,   'kuby/middleware'
   autoload :Tasks,        'kuby/tasks'
@@ -14,19 +20,25 @@ module Kuby
 
   class << self
     attr_reader :definition
-    attr_accessor :logger
+    attr_writer :logger
 
-    def define(environment, app = Rails.application, &block)
-      environment = environment.to_s
-      definitions[environment] ||= Definition.new(environment, app, &block)
+    def load!
+      require ENV['KUBY_CONFIG'] || File.join('.', 'kuby.rb')
     end
 
-    def definitions
-      @definitions ||= {}
+    def define(name, &block)
+      raise 'Kuby is already configured' if @definition
+
+      @definition = Definition.new(name.to_s)
+      @definition.instance_eval(&block)
+
+      @definition.environments.each do |_, env|
+        env.kubernetes.after_configuration
+      end
     end
 
-    def definition(environment = env)
-      definitions.fetch(environment.to_s) do
+    def environment(name = env)
+      definition.environment(name.to_s) do
         raise UndefinedEnvironmentError, "couldn't find a Kuby environment named "\
           "'#{environment}'"
       end
@@ -56,11 +68,19 @@ module Kuby
       @plugins ||= {}
     end
 
-    def register_package(package_name, package_def)
+    def logger
+      @logger ||= BasicLogger.new(STDERR)
+    end
+
+    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(
@@ -77,7 +97,7 @@ module Kuby
 
     def env
       ENV.fetch('KUBY_ENV') do
-        (definitions.keys.first || Rails.env).to_s
+        (definition.environments.keys.first || Rails.env).to_s
       end
     end
   end
@@ -105,8 +125,3 @@ 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/definition.rb

@@ -1,29 +1,35 @@
 module Kuby
   class Definition
-    attr_reader :environment, :app
+    attr_reader :app_name
 
-    def initialize(environment, app, &block)
-      @environment = environment
-      @app = app
+    def initialize(app_name, &block)
+      @app_name = app_name
+    end
+
+    def environment(name = Kuby.env, &block)
+      name = name.to_s
+
+      if name
+        environments[name] ||= Environment.new(name, self)
+      end
+
+      if block_given?
+        environments[name].instance_eval(&block)
+      end
 
-      instance_eval(&block) if block
-      kubernetes.after_configuration
+      environments[name]
     end
 
     def docker(&block)
-      @docker ||= Docker::Spec.new(self)
-      @docker.instance_eval(&block) if block
-      @docker
+      environment.docker(&block)
     end
 
     def kubernetes(&block)
-      @kubernetes ||= Kubernetes::Spec.new(self)
-      @kubernetes.instance_eval(&block) if block
-      @kubernetes
+      environment.kubernetes(&block)
     end
 
-    def app_name
-      @app_name ||= app.class.module_parent.name
+    def environments
+      @environments ||= {}
     end
   end
 end

data/lib/kuby/docker.rb

@@ -10,12 +10,13 @@ module Kuby
     autoload :Credentials,    'kuby/docker/credentials'
     autoload :Debian,         'kuby/docker/debian'
     autoload :Dockerfile,     'kuby/docker/dockerfile'
+    autoload :InlineLayer,    'kuby/docker/inline_layer'
+    autoload :Layer,          'kuby/docker/layer'
     autoload :LayerStack,     'kuby/docker/layer_stack'
     autoload :LocalTags,      'kuby/docker/local_tags'
     autoload :Metadata,       'kuby/docker/metadata'
     autoload :Packages,       'kuby/docker/packages'
     autoload :PackagePhase,   'kuby/docker/package_phase'
-    autoload :Phase,          'kuby/docker/phase'
     autoload :RemoteTags,     'kuby/docker/remote_tags'
     autoload :SetupPhase,     'kuby/docker/setup_phase'
     autoload :Spec,           'kuby/docker/spec'

data/lib/kuby/docker/alpine.rb

@@ -8,7 +8,6 @@ module Kuby
         [:nodejs, '12.14.1'],
         [:yarn, '1.21.1'],
         [:c_toolchain],
-        [:sqlite_dev],
         [:tzdata]
       ].freeze
 

data/lib/kuby/docker/assets_phase.rb

@@ -1,6 +1,6 @@
 module Kuby
   module Docker
-    class AssetsPhase < Phase
+    class AssetsPhase < Layer
       def apply_to(dockerfile)
         dockerfile.run(
           'bundle', 'exec', 'rake', 'assets:precompile'

data/lib/kuby/docker/bundler_phase.rb

@@ -1,6 +1,8 @@
+require 'pathname'
+
 module Kuby
   module Docker
-    class BundlerPhase < Phase
+    class BundlerPhase < Layer
       DEFAULT_WITHOUT = ['development', 'test', 'deploy'].freeze
 
       attr_accessor :version, :gemfile, :without
@@ -48,7 +50,7 @@ module Kuby
           .definition
           .gemfiles
           .first
-          .relative_path_from(app.root)
+          .relative_path_from(Pathname(Dir.getwd))
           .to_s
       end
     end