kuby-core 0.7.0 → 0.9.0

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

@@ -0,0 +1,75 @@
+require 'erb'
+require 'yaml'
+
+module Kuby
+  module Plugins
+    module RailsApp
+      class UnsupportedDatabaseError < StandardError; end
+
+      class Database
+        ADAPTER_MAP = {
+          sqlite3: Sqlite,
+          mysql2: MySQL,
+          postgresql: Postgres
+        }.freeze
+
+        def self.get(rails_app)
+          if rails_app.manage_database?
+            new(rails_app)
+          end
+        end
+
+        def self.get_adapter(adapter_name)
+          ADAPTER_MAP.fetch(adapter_name) do
+            raise UnsupportedDatabaseError, "Kuby does not support the '#{adapter}' "\
+              'database adapter'
+          end
+        end
+
+        attr_reader :rails_app
+
+        def initialize(rails_app)
+          @rails_app = rails_app
+        end
+
+        def plugin
+          @plugin ||= self.class
+            .get_adapter(adapter_name)
+            .new(rails_app.environment, db_configs)
+        end
+
+        def adapter_name
+          @adapter_name ||= db_config['adapter'].to_sym
+        end
+
+        alias_method :plugin_name, :adapter_name
+
+        private
+
+        def db_config
+          @db_config ||= db_configs[rails_app.environment.name]
+        end
+
+        def db_configs
+          @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
+  end
+end

data/lib/kuby/{kubernetes/plugins → plugins}/rails_app/generators/kuby.rb

@@ -2,17 +2,6 @@ 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',
@@ -48,15 +37,14 @@ class KubyGenerator < Rails::Generators::Base
             # 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
+            # Use Docker Desktop as the provider.
+            # See: https://www.docker.com/products/docker-desktop
             #
             # 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
+            provider :docker_desktop
           end
         end
       END

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

@@ -0,0 +1,155 @@
+require 'kube-dsl'
+require 'kuby/kube-db'
+
+module Kuby
+  module Plugins
+    module RailsApp
+      class MySQL < ::Kuby::Plugin
+        ROLE = 'web'.freeze
+
+        attr_reader :environment, :configs
+
+        def initialize(environment, configs)
+          @environment = environment
+          @configs = configs
+
+          user(config['username'])
+          password(config['password'])
+        end
+
+        def name
+          :mysql
+        end
+
+        def resources
+          @resources ||= [secret, database]
+        end
+
+        def after_configuration
+          environment.docker.package_phase.add(:mysql_dev)
+          environment.docker.package_phase.add(:mysql_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.name]['host'] = host
+          end
+        end
+
+        def user(user)
+          secret do
+            data do
+              set :user, user
+            end
+          end
+        end
+
+        def password(password)
+          secret do
+            data do
+              set :password, password
+            end
+          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
+
+          @secret ||= KubeDSL.secret do
+            metadata do
+              name "#{context.base_name}-mysql-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.my_sql do
+            api_version 'kubedb.com/v1alpha1'
+
+            metadata do
+              name "#{context.base_name}-mysql"
+              namespace context.kubernetes.namespace.metadata.name
+            end
+
+            spec do
+              database_secret do
+                secret_name context.secret.metadata.name
+              end
+
+              version '5.7-v2'
+              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
+          environment.kubernetes
+        end
+
+        private
+
+        def config
+          configs[environment.name]
+        end
+      end
+    end
+  end
+end
+
+Kuby.register_package(:mysql_client,
+  debian: 'default-mysql-client',
+  alpine: 'mariadb-client'
+)
+
+Kuby.register_package(:mysql_dev,
+  debian: 'default-libmysqlclient-dev',
+  alpine: 'mariadb-dev'
+)

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

@@ -0,0 +1,588 @@
+require 'kube-dsl'
+require 'kuby/cert-manager'
+
+module Kuby
+  module Plugins
+    module RailsApp
+      class Plugin < ::Kuby::Plugin
+        extend ::KubeDSL::ValueFields
+
+        WEB_ROLE = 'web'.freeze
+        DEFAULT_HOSTNAME = 'localhost'.freeze
+        MASTER_KEY_VAR = 'RAILS_MASTER_KEY'.freeze
+        ENV_SECRETS = [MASTER_KEY_VAR].freeze
+        ENV_EXCLUDE = ['RAILS_ENV'].freeze
+        DEFAULT_ASSET_URL = '/assets'.freeze
+        DEFAULT_PACKS_URL = '/packs'.freeze
+        DEFAULT_ASSET_PATH = './public'.freeze
+
+        value_field :root, default: '.'
+        value_fields :hostname, :tls_enabled
+        value_fields :manage_database, :database, :replicas
+        value_fields :asset_url, :packs_url, :asset_path
+
+        alias_method :manage_database?, :manage_database
+
+        def initialize(environment)
+          @environment = environment
+          @tls_enabled = true
+          @replicas = 1
+          @manage_database = true
+          @hostname = DEFAULT_HOSTNAME
+          @asset_url = DEFAULT_ASSET_URL
+          @packs_url = DEFAULT_PACKS_URL
+          @asset_path = DEFAULT_ASSET_PATH
+        end
+
+        def configure(&block)
+          instance_eval(&block) if block
+        end
+
+        def after_configuration
+          context = self
+
+          if @database = Database.get(self)
+            environment.kubernetes.plugins[database.plugin_name] = @database.plugin
+            environment.kubernetes.add_plugin(:kube_db)
+
+            unless environment.development?
+              environment.docker do
+                insert :rewrite_db_config, RewriteDbConfig.new, after: :copy_phase
+              end
+            end
+          end
+
+          unless environment.development?
+            environment.kubernetes.add_plugin(:nginx_ingress)
+            environment.kubernetes.add_plugin(:rails_assets) do
+              asset_url context.asset_url
+              packs_url context.packs_url
+              asset_path context.asset_path
+            end
+
+            if @tls_enabled
+              context = self
+
+              environment.kubernetes.add_plugin(:cert_manager) do
+                email context.environment.docker.credentials.email
+              end
+            end
+          end
+        end
+
+        def before_deploy(manifest)
+          # Make sure plugin has been configured. If not, do nothing.
+          if cert_manager = environment.kubernetes.plugin(:cert_manager)
+            cert_manager.annotate_ingress(ingress)
+          end
+
+          image_with_tag = "#{docker.metadata.image_url}:#{kubernetes.tag}"
+
+          if assets = environment.kubernetes.plugin(:rails_assets)
+            assets.configure_ingress(ingress, hostname)
+            assets.configure_deployment(deployment, image_with_tag)
+          end
+
+          spec = self
+
+          deployment do
+            spec do
+              template do
+                spec do
+                  container(:web) do
+                    image image_with_tag
+                  end
+
+                  unless spec.environment.development?
+                    init_container(:create_db) do
+                      image image_with_tag
+                    end
+
+                    init_container(:migrate_db) do
+                      image image_with_tag
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        def database(&block)
+          @database.instance_eval(&block) if block
+          @database
+        end
+
+        def service(&block)
+          spec = self
+
+          @service ||= KubeDSL.service do
+            metadata do
+              name "#{spec.selector_app}-svc"
+              namespace spec.namespace.metadata.name
+
+              labels do
+                add :app, spec.selector_app
+                add :role, spec.role
+              end
+            end
+
+            spec do
+              type 'NodePort'
+
+              selector do
+                add :app, spec.selector_app
+                add :role, spec.role
+              end
+
+              port do
+                name 'http'
+                port spec.docker.webserver_phase.port
+                protocol 'TCP'
+                target_port 'http'
+              end
+            end
+          end
+
+          @service.instance_eval(&block) if block
+          @service
+        end
+
+        def service_account(&block)
+          spec = self
+
+          @service_account ||= KubeDSL.service_account do
+            metadata do
+              name "#{spec.selector_app}-sa"
+              namespace spec.namespace.metadata.name
+
+              labels do
+                add :app, spec.selector_app
+                add :role, spec.role
+              end
+            end
+          end
+
+          @service_account.instance_eval(&block) if block
+          @service_account
+        end
+
+        def config_map(&block)
+          spec = self
+
+          @config_map ||= KubeDSL.config_map do
+            metadata do
+              name "#{spec.selector_app}-config"
+              namespace spec.namespace.metadata.name
+            end
+
+            data do
+              ENV.each_pair do |key, val|
+                include_key = key.start_with?('RAILS_') &&
+                  !ENV_SECRETS.include?(key) &&
+                  !ENV_EXCLUDE.include?(key)
+
+                if include_key
+                  add key.to_sym, val
+                end
+              end
+            end
+          end
+
+          @config_map.instance_eval(&block) if block
+          @config_map
+        end
+
+        def app_secrets(&block)
+          spec = self
+
+          @app_secrets ||= KubeDSL.secret do
+            metadata do
+              name "#{spec.selector_app}-secrets"
+              namespace spec.namespace.metadata.name
+            end
+
+            type 'Opaque'
+
+            data do
+              if master_key = ENV[MASTER_KEY_VAR]
+                add MASTER_KEY_VAR.to_sym, master_key
+              else
+                master_key_path = File.join(spec.root, 'config', 'master.key')
+
+                if File.exist?(master_key_path)
+                  add MASTER_KEY_VAR.to_sym, File.read(master_key_path).strip
+                end
+              end
+            end
+          end
+
+          @app_secrets.instance_eval(&block) if block
+          @app_secrets
+        end
+
+        def deployment(&block)
+          kube_spec = self
+
+          @deployment ||= KubeDSL.deployment do
+            metadata do
+              name "#{kube_spec.selector_app}-#{kube_spec.role}"
+              namespace kube_spec.namespace.metadata.name
+
+              labels do
+                add :app, kube_spec.selector_app
+                add :role, kube_spec.role
+              end
+
+              annotations do
+                add(
+                  'getkuby.io/dockerfile-checksum',
+                  kube_spec.environment.docker.to_dockerfile.checksum
+                )
+              end
+            end
+
+            spec do
+              replicas kube_spec.replicas
+
+              selector do
+                match_labels do
+                  add :app, kube_spec.selector_app
+                  add :role, kube_spec.role
+                end
+              end
+
+              strategy do
+                type 'RollingUpdate'
+
+                rolling_update do
+                  max_surge '25%'
+                  max_unavailable 0
+                end
+              end
+
+              template do
+                metadata do
+                  labels do
+                    add :app, kube_spec.selector_app
+                    add :role, kube_spec.role
+                  end
+                end
+
+                spec do
+                  container(:web) do
+                    name "#{kube_spec.selector_app}-#{kube_spec.role}"
+                    image_pull_policy 'IfNotPresent'
+
+                    port do
+                      container_port kube_spec.docker.webserver_phase.port
+                      name 'http'
+                      protocol 'TCP'
+                    end
+
+                    env_from do
+                      config_map_ref do
+                        name kube_spec.config_map.metadata.name
+                      end
+                    end
+
+                    env_from do
+                      secret_ref do
+                        name kube_spec.app_secrets.metadata.name
+                      end
+                    end
+
+                    unless kube_spec.environment.development?
+                      readiness_probe do
+                        success_threshold 1
+                        failure_threshold 2
+                        initial_delay_seconds 15
+                        period_seconds 3
+                        timeout_seconds 1
+
+                        http_get do
+                          path '/healthz'
+                          port kube_spec.docker.webserver_phase.port
+                          scheme 'HTTP'
+                        end
+                      end
+                    end
+
+                    if kube_spec.environment.development?
+                      env do
+                        name 'BUNDLE_PATH'
+                        value '/bundle'
+                      end
+
+                      env do
+                        name 'GEM_HOME'
+                        value '/bundle'
+                      end
+
+                      env do
+                        name 'BOOTSNAP_CACHE_DIR'
+                        value '/usr/src/bootsnap'
+                      end
+
+                      volume_mount do
+                        name "#{kube_spec.selector_app}-code"
+                        mount_path '/usr/src/app'
+                      end
+
+                      volume_mount do
+                        name "#{kube_spec.selector_app}-bundle"
+                        mount_path '/bundle'
+                      end
+
+                      volume_mount do
+                        name "#{kube_spec.selector_app}-bootsnap"
+                        mount_path '/usr/src/bootsnap'
+                      end
+                    end
+                  end
+
+                  if kube_spec.environment.development?
+                    volume do
+                      name "#{kube_spec.selector_app}-code"
+
+                      persistent_volume_claim do
+                        claim_name kube_spec.code_volume_claim.metadata.name
+                      end
+                    end
+
+                    volume do
+                      name "#{kube_spec.selector_app}-bundle"
+
+                      persistent_volume_claim do
+                        claim_name kube_spec.bundle_volume_claim.metadata.name
+                      end
+                    end
+
+                    volume do
+                      name "#{kube_spec.selector_app}-bootsnap"
+
+                      persistent_volume_claim do
+                        claim_name kube_spec.bootsnap_volume_claim.metadata.name
+                      end
+                    end
+                  else
+                    init_container(:create_db) do
+                      name "#{kube_spec.selector_app}-create-db"
+                      command %w(bundle exec rake kuby:rails_app:db:create_unless_exists)
+                    end
+
+                    init_container(:migrate_db) do
+                      name "#{kube_spec.selector_app}-migrate-db"
+                      command %w(bundle exec rake db:migrate)
+                    end
+
+                    image_pull_secret do
+                      name kube_spec.environment.kubernetes.registry_secret.metadata.name
+                    end
+                  end
+
+                  restart_policy 'Always'
+                  service_account_name kube_spec.service_account.metadata.name
+                end
+              end
+            end
+          end
+
+          @deployment.instance_eval(&block) if block
+          @deployment
+        end
+
+        def ingress(&block)
+          spec = self
+          tls_enabled = @tls_enabled
+
+          @ingress ||= KubeDSL::DSL::Extensions::V1beta1::Ingress.new do
+            metadata do
+              name "#{spec.selector_app}-ingress"
+              namespace spec.namespace.metadata.name
+
+              annotations do
+                add :'kubernetes.io/ingress.class', 'nginx'
+              end
+            end
+
+            spec do
+              rule do
+                host spec.hostname
+
+                http do
+                  path do
+                    path '/'
+
+                    backend do
+                      service_name spec.service.metadata.name
+                      service_port spec.service.spec.ports.first.port
+                    end
+                  end
+                end
+              end
+
+              if tls_enabled
+                tls do
+                  secret_name "#{spec.selector_app}-tls"
+                  hosts [spec.hostname]
+                end
+              end
+            end
+          end
+
+          @ingress.instance_eval(&block) if block
+          @ingress
+        end
+
+        def code_volume(&block)
+          spec = self
+
+          if environment.development?
+            @code_volume ||= KubeDSL.persistent_volume do
+              metadata do
+                name "#{spec.selector_app}-code"
+              end
+
+              spec do
+                access_modes ['ReadWriteMany']
+
+                capacity do
+                  add :storage, '1Mi'
+                end
+
+                host_path do
+                  path File.expand_path(spec.root)
+                end
+
+                storage_class_name 'hostpath'
+              end
+            end
+
+            @code_volume.instance_eval(&block) if block
+            @code_volume
+          end
+        end
+
+        def code_volume_claim(&block)
+          spec = self
+
+          if environment.development?
+            @code_volume_claim ||= KubeDSL.persistent_volume_claim do
+              metadata do
+                name "#{spec.selector_app}-code"
+                namespace spec.namespace.metadata.name
+              end
+
+              spec do
+                access_modes ['ReadWriteMany']
+
+                resources do
+                  requests do
+                    add :storage, '1Mi'
+                  end
+                end
+
+                storage_class_name 'hostpath'
+                volume_name spec.code_volume.metadata.name
+              end
+            end
+
+            @code_volume_claim.instance_eval(&block) if block
+            @code_volume_claim
+          end
+        end
+
+        def bundle_volume_claim(&block)
+          spec = self
+
+          if environment.development?
+            @bundle_volume_claim ||= KubeDSL.persistent_volume_claim do
+              metadata do
+                name "#{spec.selector_app}-bundle"
+                namespace spec.namespace.metadata.name
+              end
+
+              spec do
+                access_modes ['ReadWriteMany']
+                storage_class_name 'hostpath'
+
+                resources do
+                  requests do
+                    add :storage, '2Gi'
+                  end
+                end
+              end
+            end
+
+            @bundle_volume_claim.instance_eval(&block) if block
+            @bundle_volume_claim
+          end
+        end
+
+        def bootsnap_volume_claim(&block)
+          spec = self
+
+          if environment.development?
+            @bootsnap_volume_claim ||= KubeDSL.persistent_volume_claim do
+              metadata do
+                name "#{spec.selector_app}-bootsnap"
+                namespace spec.namespace.metadata.name
+              end
+
+              spec do
+                access_modes ['ReadWriteMany']
+                storage_class_name 'hostpath'
+
+                resources do
+                  requests do
+                    add :storage, '2Gi'
+                  end
+                end
+              end
+            end
+
+            @bootsnap_volume_claim.instance_eval(&block) if block
+            @bootsnap_volume_claim
+          end
+        end
+
+        def resources
+          @resources ||= [
+            service,
+            service_account,
+            config_map,
+            app_secrets,
+            deployment,
+            ingress,
+            code_volume,
+            code_volume_claim,
+            bundle_volume_claim,
+            bootsnap_volume_claim,
+            *database&.plugin&.resources
+          ]
+        end
+
+        def selector_app
+          environment.kubernetes.selector_app
+        end
+
+        def role
+          WEB_ROLE
+        end
+
+        def docker
+          environment.docker
+        end
+
+        def kubernetes
+          environment.kubernetes
+        end
+
+        def namespace
+          environment.kubernetes.namespace
+        end
+      end
+    end
+  end
+end