kuby-core 0.7.2 → 0.8.0

data/lib/kuby/kubernetes/plugins.rb

@@ -1,8 +0,0 @@
-module Kuby
-  module Kubernetes
-    module Plugins
-      autoload :NginxIngress, 'kuby/kubernetes/plugins/nginx_ingress'
-      autoload :RailsApp,     'kuby/kubernetes/plugins/rails_app'
-    end
-  end
-end

data/lib/kuby/kubernetes/plugins/nginx_ingress.rb

@@ -1,73 +0,0 @@
-require 'kube-dsl'
-
-module Kuby
-  module Kubernetes
-    module Plugins
-      class NginxIngress < Plugin
-        class Config
-          extend ::KubeDSL::ValueFields
-
-          value_fields :provider
-        end
-
-        VERSION = '0.27.1'.freeze
-        DEFAULT_PROVIDER = 'cloud-generic'.freeze
-        NAMESPACE = 'ingress-nginx'.freeze
-        SERVICE_NAME = 'ingress-nginx'.freeze
-
-        SETUP_RESOURCES = [
-          "https://raw.githubusercontent.com/kubernetes/ingress-nginx/nginx-#{VERSION}/deploy/static/mandatory.yaml",
-          "https://raw.githubusercontent.com/kubernetes/ingress-nginx/nginx-#{VERSION}/deploy/static/provider/%{provider}.yaml"
-        ].freeze
-
-        def configure(&block)
-          @config.instance_eval(&block) if block
-        end
-
-        def setup
-          Kuby.logger.info('Deploying nginx ingress resources')
-
-          if already_deployed?
-            Kuby.logger.info('Nginx ingress already deployed, skipping')
-            return
-          end
-
-          SETUP_RESOURCES.each do |uri|
-            uri = uri % { provider: @config.provider || DEFAULT_PROVIDER }
-            kubernetes_cli.apply_uri(uri)
-          end
-
-          Kuby.logger.info('Nginx ingress resources deployed!')
-        rescue => e
-          Kuby.logger.fatal(e.message)
-          raise
-        end
-
-        def namespace
-          NAMESPACE
-        end
-
-        def service_name
-          SERVICE_NAME
-        end
-
-        private
-
-        def already_deployed?
-          kubernetes_cli.get_object('Service', 'ingress-nginx', 'ingress-nginx')
-          true
-        rescue KubernetesCLI::GetResourceError
-          return false
-        end
-
-        def after_initialize
-          @config = Config.new
-        end
-
-        def kubernetes_cli
-          definition.kubernetes.provider.kubernetes_cli
-        end
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-module Kuby
-  module Kubernetes
-    module Plugins
-      module RailsApp
-        autoload :Database,        'kuby/kubernetes/plugins/rails_app/database'
-        autoload :MySQL,           'kuby/kubernetes/plugins/rails_app/mysql'
-        autoload :Plugin,          'kuby/kubernetes/plugins/rails_app/plugin'
-        autoload :Postgres,        'kuby/kubernetes/plugins/rails_app/postgres'
-        autoload :RewriteDbConfig, 'kuby/kubernetes/plugins/rails_app/rewrite_db_config'
-        autoload :Sqlite,          'kuby/kubernetes/plugins/rails_app/sqlite'
-      end
-    end
-  end
-end
-
-load File.expand_path(File.join('rails_app', 'tasks.rake'), __dir__)

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

@@ -1,79 +0,0 @@
-require 'erb'
-require 'yaml'
-
-module Kuby
-  module Kubernetes
-    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).database
-            end
-          end
-
-          def self.get_adapter(adapter)
-            ADAPTER_MAP.fetch(adapter) 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 database
-            @database ||= self.class
-              .get_adapter(adapter)
-              .new(rails_app, environment, db_configs)
-          end
-
-          private
-
-          def adapter
-            db_config['adapter']
-          end
-
-          def db_config
-            @db_config ||= db_configs[environment]
-          end
-
-          def environment
-            @environment ||= rails_app.definition.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
-end

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

@@ -1,154 +0,0 @@
-require 'kube-dsl'
-require 'kuby/kube-db'
-
-module Kuby
-  module Kubernetes
-    module Plugins
-      module RailsApp
-        class MySQL < 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(:mysql_dev)
-            definition.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]['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
-            definition.kubernetes
-          end
-
-          private
-
-          def config
-            configs[environment]
-          end
-        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/kubernetes/plugins/rails_app/plugin.rb

@@ -1,379 +0,0 @@
-require 'kube-dsl'
-require 'kuby/cert-manager'
-
-module Kuby
-  module Kubernetes
-    module Plugins
-      module RailsApp
-        class Plugin < Kuby::Kubernetes::Plugin
-          extend ::KubeDSL::ValueFields
-
-          WEB_ROLE = 'web'.freeze
-          MASTER_KEY_VAR = 'RAILS_MASTER_KEY'.freeze
-          ENV_SECRETS = [MASTER_KEY_VAR].freeze
-          ENV_EXCLUDE = ['RAILS_ENV'].freeze
-
-          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)
-            instance_eval(&block) if block
-          end
-
-          def after_configuration
-            if @database = Database.get(self)
-              definition.kubernetes.plugins[database] = @database
-              definition.kubernetes.add_plugin(:kube_db)
-
-              definition.docker do
-                insert :rewrite_db_config, RewriteDbConfig.new, after: :copy_phase
-              end
-            end
-
-            # do we always want this?
-            definition.kubernetes.add_plugin(:nginx_ingress)
-
-            if @tls_enabled
-              context = self
-
-              definition.kubernetes.add_plugin(:cert_manager) do
-                email context.definition.docker.credentials.email
-              end
-            end
-          end
-
-          def before_deploy(manifest)
-            # Make sure plugin has been configured. If not, do nothing.
-            if cert_manager = definition.kubernetes.plugin(:cert_manager)
-              if ing = manifest.find(:ingress, ingress.metadata.name)
-                cert_manager.annotate_ingress(ing)
-              end
-            end
-
-            image_with_tag = "#{docker.metadata.image_url}:#{kubernetes.tag}"
-
-            deployment do
-              spec do
-                template do
-                  spec do
-                    container(:web) do
-                      image image_with_tag
-                    end
-
-                    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
-
-          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 8080
-                  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
-              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
-
-                      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
-
-                    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.definition.kubernetes.registry_secret.metadata.name
-                    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
-                      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 resources
-            @resources ||= [
-              service,
-              service_account,
-              config_map,
-              app_secrets,
-              deployment,
-              ingress,
-              *database&.resources
-            ]
-          end
-
-          def selector_app
-            definition.kubernetes.selector_app
-          end
-
-          def role
-            WEB_ROLE
-          end
-
-          def docker
-            definition.docker
-          end
-
-          def kubernetes
-            definition.kubernetes
-          end
-
-          def namespace
-            definition.kubernetes.namespace
-          end
-        end
-      end
-    end
-  end
-end