kuby-core 0.1.0 → 0.6.0

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

@@ -1,3 +1,6 @@
+require 'erb'
+require 'yaml'
+
 module Kuby
   module Kubernetes
     module Plugins
@@ -11,27 +14,29 @@ module Kuby
             'postgresql' => Postgres
           }.freeze
 
-          def self.get(definition)
-            new(definition).database
+          def self.get(rails_app)
+            if rails_app.manage_database?
+              new(rails_app).database
+            end
           end
 
           def self.get_adapter(adapter)
             ADAPTER_MAP.fetch(adapter) do
-              raise UnsupportedDatabaseError, "Kuby does not support the '#{adapter}'"\
+              raise UnsupportedDatabaseError, "Kuby does not support the '#{adapter}' "\
                 'database adapter'
             end
           end
 
-          attr_reader :definition
+          attr_reader :rails_app
 
-          def initialize(definition)
-            @definition = definition
+          def initialize(rails_app)
+            @rails_app = rails_app
           end
 
           def database
             @database ||= self.class
               .get_adapter(adapter)
-              .new(definition, environment, db_configs)
+              .new(rails_app, environment, db_configs)
           end
 
           private
@@ -45,11 +50,27 @@ module Kuby
           end
 
           def environment
-            @environment ||= definition.environment
+            @environment ||= rails_app.definition.environment.name
           end
 
           def db_configs
-            @db_configs ||= definition.app.config.database_configuration
+            @db_configs ||= YAML.load(ERB.new(File.read(db_config_path)).result)
+          end
+
+          def db_config_path
+            @db_config_path ||= begin
+              db_config_paths.first or
+                raise "Couldn't find database config at #{rails_app.root}"
+            end
+          end
+
+          def db_config_paths
+            @db_config_paths ||=
+              Dir.glob(
+                File.join(
+                  rails_app.root, 'config', 'database.{yml,erb,yml.erb,yaml,yaml.erb}'
+                )
+              )
           end
         end
       end

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

@@ -0,0 +1,83 @@
+require 'rails/generators'
+require 'rails/generators/base'
+
+class KubyGenerator < Rails::Generators::Base
+  def create_initializer_file
+    initializer(
+      'kuby.rb',
+      <<~END
+        require 'kuby'
+
+        Kuby.load!
+      END
+    )
+  end
+
+  def create_config_file
+    create_file(
+      'kuby.rb',
+      <<~END
+        require 'active_support/encrypted_configuration'
+
+        # Define a production Kuby deploy environment
+        Kuby.define(:production) do
+          app_creds = ActiveSupport::EncryptedConfiguration.new(
+            config_path: File.join('config', 'credentials.yml.enc'),
+            key_path: File.join('config', 'master.key'),
+            env_key: 'RAILS_MASTER_KEY',
+            raise_if_missing_key: true
+          )
+
+          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 app_creds[:KUBY_DOCKER_USERNAME]
+              password app_creds[:KUBY_DOCKER_PASSWORD]
+              email app_creds[: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 provider, which is the default installed by
+            # Docker Desktop.
+            # 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
+
+  def create_dockerignore
+    create_file(
+      '.dockerignore',
+      <<~END
+        .bundle/
+        vendor/bundle
+        node_modules/
+        .node_modules/
+        **/.git*
+        tmp/
+        log/
+        engines/**/log/
+        engines/**/tmp/
+        public/assets
+      END
+    )
+  end
+end

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

@@ -6,6 +6,8 @@ module Kuby
     module Plugins
       module RailsApp
         class MySQL < Kuby::Kubernetes::Plugin
+          ROLE = 'web'.freeze
+
           attr_reader :definition, :environment, :configs
 
           def initialize(definition, environment, configs)
@@ -54,6 +56,20 @@ module Kuby
             end
           end
 
+          def storage(amount)
+            database do
+              spec do
+                storage do
+                  resources do
+                    requests do
+                      set :storage, amount
+                    end
+                  end
+                end
+              end
+            end
+          end
+
           def secret(&block)
             context = self
 
@@ -109,17 +125,13 @@ module Kuby
           end
 
           def base_name
-            @base_name ||= "#{kubernetes.selector_app}-#{environment}"
+            @base_name ||= "#{kubernetes.selector_app}-#{ROLE}"
           end
 
           def kubernetes
             definition.kubernetes
           end
 
-          def app
-            definition.app
-          end
-
           private
 
           def config

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

@@ -13,11 +13,17 @@ module Kuby
           ENV_SECRETS = [MASTER_KEY_VAR].freeze
           ENV_EXCLUDE = ['RAILS_ENV'].freeze
 
-          value_fields :hostname, :tls_enabled, :database
+          value_field :root, default: '.'
+          value_fields :hostname, :tls_enabled
+          value_fields :manage_database, :database, :replicas
+
+          alias_method :manage_database?, :manage_database
 
           def initialize(definition)
             @definition = definition
             @tls_enabled = true
+            @replicas = 1
+            @manage_database = true
           end
 
           def configure(&block)
@@ -25,11 +31,7 @@ module Kuby
           end
 
           def after_configuration
-            # currently Database.get doesn't return nil, but this if statement
-            # is here as a placeholder to indicate we'd like to be able to
-            # handle Rails apps that don't use a database, i.e. don't have
-            # activerecord configured
-            if @database = Database.get(definition)
+            if @database = Database.get(self)
               definition.kubernetes.plugins[database] = @database
               definition.kubernetes.add_plugin(:kube_db)
 
@@ -42,7 +44,11 @@ module Kuby
             definition.kubernetes.add_plugin(:nginx_ingress)
 
             if @tls_enabled
-              definition.kubernetes.add_plugin(:cert_manager)
+              context = self
+
+              definition.kubernetes.add_plugin(:cert_manager) do
+                email context.definition.docker.credentials.email
+              end
             end
           end
 
@@ -53,14 +59,9 @@ module Kuby
                 cert_manager.annotate_ingress(ing)
               end
             end
-          end
 
-          def database(&block)
-            @database.instance_eval(&block) if block
-            @database
-          end
+            image_with_tag = "#{docker.metadata.image_url}:#{kubernetes.tag}"
 
-          def set_image(image_with_tag)
             deployment do
               spec do
                 template do
@@ -82,6 +83,11 @@ module Kuby
             end
           end
 
+          def database(&block)
+            @database.instance_eval(&block) if block
+            @database
+          end
+
           def service(&block)
             spec = self
 
@@ -177,9 +183,9 @@ module Kuby
                 if master_key = ENV[MASTER_KEY_VAR]
                   add MASTER_KEY_VAR.to_sym, master_key
                 else
-                  master_key_path = spec.app.root.join('config', 'master.key')
+                  master_key_path = File.join(spec.root, 'config', 'master.key')
 
-                  if master_key_path.exist?
+                  if File.exist?(master_key_path)
                     add MASTER_KEY_VAR.to_sym, File.read(master_key_path).strip
                   end
                 end
@@ -190,33 +196,12 @@ module Kuby
             @app_secrets
           end
 
-          def registry_secret(&block)
-            spec = self
-
-            @registry_secret ||= RegistrySecret.new do
-              metadata do
-                name "#{spec.selector_app}-registry-secret"
-                namespace spec.namespace.metadata.name
-              end
-
-              docker_config do
-                registry_host spec.docker.metadata.image_host
-                username spec.docker.credentials.username
-                password spec.docker.credentials.password
-                email spec.docker.credentials.email
-              end
-            end
-
-            @registry_secret.instance_eval(&block) if block
-            @registry_secret
-          end
-
           def deployment(&block)
             kube_spec = self
 
             @deployment ||= KubeDSL.deployment do
               metadata do
-                name "#{kube_spec.selector_app}-deployment"
+                name "#{kube_spec.selector_app}-#{kube_spec.role}"
                 namespace kube_spec.namespace.metadata.name
 
                 labels do
@@ -226,6 +211,8 @@ module Kuby
               end
 
               spec do
+                replicas kube_spec.replicas
+
                 selector do
                   match_labels do
                     add :app, kube_spec.selector_app
@@ -299,7 +286,7 @@ module Kuby
                     end
 
                     image_pull_secret do
-                      name kube_spec.registry_secret.metadata.name
+                      name kube_spec.definition.kubernetes.registry_secret.metadata.name
                     end
 
                     restart_policy 'Always'
@@ -360,10 +347,9 @@ module Kuby
               service_account,
               config_map,
               app_secrets,
-              registry_secret,
               deployment,
               ingress,
-              *database.resources
+              *database&.resources
             ]
           end
 
@@ -379,8 +365,8 @@ module Kuby
             definition.docker
           end
 
-          def app
-            definition.app
+          def kubernetes
+            definition.kubernetes
           end
 
           def namespace

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

@@ -1,10 +1,142 @@
+require 'kube-dsl'
+require 'kuby/kube-db'
+
 module Kuby
   module Kubernetes
     module Plugins
       module RailsApp
         class Postgres < Kuby::Kubernetes::Plugin
+          ROLE = 'web'.freeze
+
+          attr_reader :definition, :environment, :configs
+
+          def initialize(definition, environment, configs)
+            @definition = definition
+            @environment = environment
+            @configs = configs
+
+            user(config['username'])
+            password(config['password'])
+          end
+
+          def resources
+            @resources ||= [secret, database]
+          end
+
+          def after_configuration
+            definition.docker.package_phase.add(:postgres_dev)
+            definition.docker.package_phase.add(:postgres_client)
+          end
+
+          def host
+            # host is the same as the name thanks to k8s DNS
+            @host ||= database.metadata.name
+          end
+
+          def rewritten_configs
+            # deep dup
+            @rewritten_configs ||= Marshal.load(Marshal.dump(configs)).tap do |new_configs|
+              new_configs[environment]['host'] = host
+            end
+          end
+
+          def user(user)
+            secret do
+              data do
+                set :POSTGRES_USER, user
+              end
+            end
+          end
+
+          def password(password)
+            secret do
+              data do
+                set :POSTGRES_PASSWORD, password
+              end
+            end
+          end
+
+          def secret(&block)
+            context = self
+
+            @secret ||= KubeDSL.secret do
+              metadata do
+                name "#{context.base_name}-postgres-secret"
+                namespace context.kubernetes.namespace.metadata.name
+              end
+
+              type 'Opaque'
+            end
+
+            @secret.instance_eval(&block) if block
+            @secret
+          end
+
+          def database(&block)
+            context = self
+
+            @database ||= Kuby::KubeDB.postgres do
+              api_version 'kubedb.com/v1alpha1'
+
+              metadata do
+                name "#{context.base_name}-postgres"
+                namespace context.kubernetes.namespace.metadata.name
+              end
+
+              spec do
+                database_secret do
+                  secret_name context.secret.metadata.name
+                end
+
+                version '11.2'
+                standby_mode 'Hot'
+                streaming_mode 'asynchronous'
+                storage_type 'Durable'
+
+                storage do
+                  storage_class_name context.kubernetes.provider.storage_class_name
+                  access_modes ['ReadWriteOnce']
+
+                  resources do
+                    requests do
+                      add :storage, '10Gi'
+                    end
+                  end
+                end
+
+                termination_policy 'DoNotTerminate'
+              end
+            end
+
+            @database.instance_eval(&block) if block
+            @database
+          end
+
+          def base_name
+            @base_name ||= "#{kubernetes.selector_app}-#{ROLE}"
+          end
+
+          def kubernetes
+            definition.kubernetes
+          end
+
+          private
+
+          def config
+            configs[environment]
+          end
         end
       end
     end
   end
 end
+
+Kuby.register_package(:postgres_dev,
+  debian: 'postgresql-client',
+  alpine: 'postgresql-dev'
+)
+
+Kuby.register_package(:postgres_client,
+  debian: 'postgresql-client',
+  alpine: 'postgresql-client'
+)