kube_cluster 0.2.1 → 0.3.0

data/examples/database/manifest.rb

@@ -1,238 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Database (PostgreSQL) Example
-#
-# Demonstrates the Ruby equivalents of Bitnami common chart patterns:
-#   - Secret lifecycle management (_secrets.tpl)
-#   - StorageClass resolution (_storage.tpl)
-#   - StatefulSet with persistent volumes
-#   - Headless service for stable DNS
-#   - NetworkPolicy for database isolation
-#   - Standard labels and naming (_labels.tpl, _names.tpl)
-#   - Resource presets (_resources.tpl)
-#
-# Usage:
-#   ruby examples/database/manifest.rb
-#   ruby examples/database/manifest.rb > database.yaml
-
-require "kube/schema"
-require "securerandom"
-
-# ── Naming ────────────────────────────────────────────────────────────────────
-
-APP_NAME      = "postgresql"
-RELEASE_NAME  = "my-release"
-NAMESPACE     = "database"
-FULLNAME      = "#{RELEASE_NAME}-#{APP_NAME}"[0, 63].chomp("-")
-
-# ── Labels ────────────────────────────────────────────────────────────────────
-
-STANDARD_LABELS = {
-  "app.kubernetes.io/name": APP_NAME,
-  "app.kubernetes.io/instance": RELEASE_NAME,
-  "app.kubernetes.io/version": "16.4.0",
-  "app.kubernetes.io/component": "primary",
-  "app.kubernetes.io/managed-by": "kube_cluster",
-}
-
-MATCH_LABELS = STANDARD_LABELS.slice(
-  :"app.kubernetes.io/name",
-  :"app.kubernetes.io/instance",
-  :"app.kubernetes.io/component",
-)
-
-# ── Secrets (from _secrets.tpl) ───────────────────────────────────────────────
-# Bitnami's secrets.passwords.manage generates random passwords, reuses existing
-# ones on upgrade, and base64 encodes them. In Ruby we do this directly.
-
-POSTGRES_PASSWORD = SecureRandom.alphanumeric(24)
-REPLICATION_PASSWORD = SecureRandom.alphanumeric(24)
-
-def base64(str)
-  [str].pack("m0")
-end
-
-# ── Storage (from _storage.tpl) ───────────────────────────────────────────────
-# Bitnami resolves storage class from global > persistence > default.
-# The "-" convention means explicitly use the default storage class (empty string).
-
-STORAGE_CLASS = "standard" # set to "-" for default, or nil to omit
-STORAGE_SIZE  = "10Gi"
-
-# ── Resource presets ──────────────────────────────────────────────────────────
-
-RESOURCES = {
-  requests: { cpu: "500m",  memory: "512Mi"  },
-  limits:   { cpu: "750m",  memory: "768Mi"  },
-}
-
-# ── Build manifests ───────────────────────────────────────────────────────────
-
-manifest = Kube::Schema::Manifest.new
-
-# -- Namespace --
-
-manifest << Kube::Schema["Namespace"].new {
-  metadata.name   = NAMESPACE
-  metadata.labels = STANDARD_LABELS.reject { |k, _| k == :"app.kubernetes.io/component" }
-}
-
-# -- Secret --
-# Pattern from _secrets.tpl: base64-encoded credentials, separate keys for
-# each password, supports existing secret reuse on upgrade.
-
-manifest << Kube::Schema["Secret"].new {
-  metadata.name      = FULLNAME
-  metadata.namespace  = NAMESPACE
-  metadata.labels     = STANDARD_LABELS
-  self.type = "Opaque"
-  self.data = {
-    "postgres-password":    base64(POSTGRES_PASSWORD),
-    "replication-password": base64(REPLICATION_PASSWORD),
-  }
-}
-
-# -- Headless Service (for StatefulSet stable DNS) --
-
-manifest << Kube::Schema["Service"].new {
-  metadata.name      = "#{FULLNAME}-headless"
-  metadata.namespace  = NAMESPACE
-  metadata.labels     = STANDARD_LABELS
-
-  spec.clusterIP = "None"
-  spec.selector  = MATCH_LABELS
-  spec.ports = [
-    { name: "tcp-postgresql", port: 5432, targetPort: "tcp-postgresql" },
-  ]
-}
-
-# -- Primary Service (for client connections) --
-
-manifest << Kube::Schema["Service"].new {
-  metadata.name      = FULLNAME
-  metadata.namespace  = NAMESPACE
-  metadata.labels     = STANDARD_LABELS
-
-  spec.selector = MATCH_LABELS
-  spec.ports = [
-    { name: "tcp-postgresql", port: 5432, targetPort: "tcp-postgresql" },
-  ]
-}
-
-# -- StatefulSet --
-# Uses storage class resolution pattern, secret references, resource presets,
-# pod anti-affinity for spreading replicas.
-
-manifest << Kube::Schema["StatefulSet"].new {
-  metadata.name      = FULLNAME
-  metadata.namespace  = NAMESPACE
-  metadata.labels     = STANDARD_LABELS
-
-  spec.serviceName = "#{FULLNAME}-headless"
-  spec.replicas    = 1
-  spec.selector.matchLabels = MATCH_LABELS
-
-  spec.template.metadata.labels = STANDARD_LABELS
-  spec.template.spec.containers = [
-    {
-      name:  APP_NAME,
-      image: "docker.io/postgres:16.4-alpine",
-      ports: [
-        { name: "tcp-postgresql", containerPort: 5432 },
-      ],
-      resources: RESOURCES,
-      env: [
-        { name: "POSTGRES_PASSWORD", valueFrom: { secretKeyRef: { name: FULLNAME, key: "postgres-password" } } },
-        { name: "PGDATA", value: "/var/lib/postgresql/data/pgdata" },
-      ],
-      volumeMounts: [
-        { name: "data", mountPath: "/var/lib/postgresql/data" },
-      ],
-      livenessProbe: {
-        exec: { command: ["pg_isready", "-U", "postgres"] },
-        initialDelaySeconds: 30,
-        periodSeconds: 10,
-        timeoutSeconds: 5,
-        failureThreshold: 6,
-      },
-      readinessProbe: {
-        exec: { command: ["pg_isready", "-U", "postgres"] },
-        initialDelaySeconds: 5,
-        periodSeconds: 10,
-        timeoutSeconds: 5,
-        failureThreshold: 6,
-      },
-    },
-  ]
-
-  # Pod anti-affinity: hard anti-affinity to guarantee one pod per node
-  # (from _affinities.tpl: common.affinities.pods.hard)
-  spec.template.spec.affinity = {
-    podAntiAffinity: {
-      requiredDuringSchedulingIgnoredDuringExecution: [
-        {
-          labelSelector: { matchLabels: MATCH_LABELS },
-          topologyKey: "kubernetes.io/hostname",
-        },
-      ],
-    },
-  }
-
-  # Storage class resolution (from _storage.tpl)
-  storage_class = STORAGE_CLASS == "-" ? "" : STORAGE_CLASS
-
-  spec.volumeClaimTemplates = [
-    {
-      metadata: { name: "data" },
-      spec: {
-        accessModes: ["ReadWriteOnce"],
-        storageClassName: storage_class,
-        resources: { requests: { storage: STORAGE_SIZE } },
-      },
-    },
-  ]
-}
-
-# -- NetworkPolicy --
-# Isolate the database: only allow ingress from pods with the app label,
-# deny everything else. This is a common production hardening pattern.
-
-manifest << Kube::Schema["NetworkPolicy"].new {
-  metadata.name      = FULLNAME
-  metadata.namespace  = NAMESPACE
-  metadata.labels     = STANDARD_LABELS
-
-  spec.podSelector = { matchLabels: MATCH_LABELS }
-  spec.policyTypes = ["Ingress", "Egress"]
-  spec.ingress = [
-    {
-      from: [
-        {
-          podSelector: {
-            matchLabels: { "app.kubernetes.io/name": "web-app" },
-          },
-        },
-      ],
-      ports: [
-        { protocol: "TCP", port: "5432" },
-      ],
-    },
-  ]
-  # Allow DNS egress + nothing else
-  spec.egress = [
-    {
-      to: [
-        { namespaceSelector: {} },
-      ],
-      ports: [
-        { protocol: "UDP", port: "53" },
-        { protocol: "TCP", port: "53" },
-      ],
-    },
-  ]
-}
-
-# ── Render ────────────────────────────────────────────────────────────────────
-
-puts manifest.to_yaml

data/examples/web-app/manifest.rb

@@ -1,215 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "kube/schema"
-
-MATCH_LABELS = STANDARD_LABELS.slice(
-  :"app.kubernetes.io/name",
-  :"app.kubernetes.io/instance",
-)
-
-REGISTRY   = "docker.io"
-REPOSITORY = "nginx"
-TAG        = "1.27.3-alpine"
-IMAGE      = "#{REGISTRY}/#{REPOSITORY}:#{TAG}"
-
-RESOURCE_PRESETS = {
-  "nano":    { requests: { cpu: "100m",  memory: "128Mi"  }, limits: { cpu: "150m",  memory: "192Mi"  } },
-  "micro":   { requests: { cpu: "250m",  memory: "256Mi"  }, limits: { cpu: "375m",  memory: "384Mi"  } },
-  "small":   { requests: { cpu: "500m",  memory: "512Mi"  }, limits: { cpu: "750m",  memory: "768Mi"  } },
-  "medium":  { requests: { cpu: "500m",  memory: "1024Mi" }, limits: { cpu: "750m",  memory: "1536Mi" } },
-  "large":   { requests: { cpu: "1.0",   memory: "2048Mi" }, limits: { cpu: "1.5",   memory: "3072Mi" } },
-  "xlarge":  { requests: { cpu: "1.0",   memory: "3072Mi" }, limits: { cpu: "3.0",   memory: "6144Mi" } },
-  "2xlarge": { requests: { cpu: "1.0",   memory: "3072Mi" }, limits: { cpu: "6.0",   memory: "12288Mi" } },
-}
-
-module AutoConfig
-end
-
-class MyApp < Kube::Schema::Manifest
-  include Helpers
-  include AutoConfig
-
-  def initialize(namespace: DEFAULT_NAMESPACE, labels: STANDARD_LABELS)
-    @app_name  = "web-app"
-    @fullname  = "#{RELEASE_NAME}-#{APP_NAME}"[0, 63].chomp("-")
-    @namespace = namespace 
-
-    @labels = {
-      "app.kubernetes.io/name": @app_name
-      "app.kubernetes.io/managed-by": "kube_cluster",
-    }
-  end
-
-  stack do
-    use Middleware::Namespace
-    use Middleware::Labels
-  end
-
-  class Namespace < Kube::Schema["Namespace"]
-    def initialize(namespace:)
-      build {
-        metadata.name = namespace
-      }
-    end
-  end
-
-  class ConfigMap < Kube::Schema["ConfigMap"]
-    def initialize(namespace:)
-      build {
-        metadata.name = "#{namespace}-config"
-        spec.data = {
-          RAILS_ENV:     "production",
-          LOG_LEVEL:     "info",
-          WORKERS:       "4",
-          PORT:          "3000",
-        }
-      }
-    end
-  end
-
-  class Deployment < Kube::Schema["Deployment"]
-    def initialize(namespace:)
-      build {
-        metadata.name = namespace
-
-        spec.replicas = 3
-        spec.selector.matchLabels = MATCH_LABELS
-
-        spec.template.metadata.labels = STANDARD_LABELS
-        spec.template.metadata.annotations = {
-          # Checksum pattern from _utils.tpl -- triggers rolling restart on config change
-          "checksum/config": "{{ sha256sum of configmap data }}",
-        }
-
-        spec.template.spec.containers = [
-          {
-            name:  APP_NAME,
-            image: IMAGE,
-            ports: [{ name: "http", containerPort: 3000, protocol: "TCP" }],
-            resources: RESOURCES,
-            env: [
-              { name: "PORT", value: "3000" },
-            ],
-            envFrom: [
-              { configMapRef: { name: "#{FULLNAME}-config" } },
-            ],
-            livenessProbe: {
-              httpGet: { path: "/healthz", port: "http" },
-              initialDelaySeconds: 15,
-              periodSeconds: 10,
-            },
-            readinessProbe: {
-              httpGet: { path: "/readyz", port: "http" },
-              initialDelaySeconds: 5,
-              periodSeconds: 5,
-            },
-          },
-        ]
-
-        # Pod anti-affinity (from _affinities.tpl)
-        # Soft anti-affinity: prefer spreading pods across nodes but don't enforce it
-        spec.template.spec.affinity = {
-          podAntiAffinity: {
-            preferredDuringSchedulingIgnoredDuringExecution: [
-              {
-                weight: 1,
-                podAffinityTerm: {
-                  labelSelector: {
-                    matchLabels: MATCH_LABELS,
-                  },
-                  topologyKey: "kubernetes.io/hostname",
-                },
-              },
-            ],
-          },
-        }
-      }
-    end
-  end
-
-  class Service < Kube::Schema["Service"]
-    def initialize(namespace:)
-      build {
-        metadata.name = namespace
-
-        spec.selector = MATCH_LABELS
-        spec.ports = [
-          { name: "http", port: 80, targetPort: "http", protocol: "TCP" },
-        ]
-      }
-    end
-  end
-
-  class Ingress < Kube::Schema["Ingress"]
-    def initialize(namespace:)
-      build {
-        metadata.name = namespace
-        metadata.annotations = {
-          "cert-manager.io/cluster-issuer": "letsencrypt-prod",
-          "nginx.ingress.kubernetes.io/ssl-redirect": "true",
-        }
-
-        spec.ingressClassName = "nginx"
-        spec.tls = [
-          {
-            hosts: ["app.example.com"],
-            secretName: "#{namespace}-tls",
-          },
-        ]
-        spec.rules = [
-          {
-            host: "app.example.com",
-            http: {
-              paths: [
-                {
-                  path: "/",
-                  pathType: "Prefix",
-                  backend: {
-                    service: {
-                      name: FULLNAME,
-                      port: { name: "http" },
-                    },
-                  },
-                },
-              ],
-            },
-          },
-        ]
-      }
-    end
-  end
-
-  class HorizontalPodAutoscaler < Kube::Schema["HorizontalPodAutoscaler"]
-    def initialize(namespace:)
-      build {
-        metadata.name = namespace
-
-        spec.scaleTargetRef.apiVersion = "apps/v1"
-        spec.scaleTargetRef.kind = "Deployment"
-        spec.scaleTargetRef.name = namespace
-
-        spec.minReplicas = 3
-        spec.maxReplicas = 10
-        spec.metrics = [
-          {
-            type: "Resource",
-            resource: {
-              name: "cpu",
-              target: { type: "Utilization", averageUtilization: 75 },
-            },
-          },
-          {
-            type: "Resource",
-            resource: {
-              name: "memory",
-              target: { type: "Utilization", averageUtilization: 80 },
-            },
-          },
-        ]
-      }
-    end
-  end
-end
-
-puts MyApp.new.to_yaml

data/lib/kube/cluster/manifest/middleware/annotations.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Kube
-  module Cluster
-    class Manifest < Kube::Schema::Manifest
-      class Middleware
-        # Merges annotations into +metadata.annotations+ on every resource.
-        # Existing annotations are preserved; the supplied annotations act
-        # as defaults that can be overridden per-resource.
-        #
-        #   stack do
-        #     use Middleware::Annotations,
-        #       "prometheus.io/scrape": "true",
-        #       "prometheus.io/port":   "9090"
-        #   end
-        #
-        class Annotations < Middleware
-          def initialize(**annotations)
-            @annotations = annotations.transform_keys(&:to_sym).transform_values(&:to_s)
-          end
-
-          def call(resource)
-            h = resource.to_h
-            h[:metadata] ||= {}
-            h[:metadata][:annotations] = @annotations.merge(h[:metadata][:annotations] || {})
-            rebuild(resource, h)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/kube/cluster/manifest/middleware/hpa_for_deployment.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-module Kube
-  module Cluster
-    class Manifest < Kube::Schema::Manifest
-      class Middleware
-        # Generates a HorizontalPodAutoscaler for every pod-bearing
-        # resource that carries the +app.kubernetes.io/autoscale+ label.
-        #
-        # The label value encodes the min and max replicas as "min-max":
-        #
-        #   metadata.labels = { "app.kubernetes.io/autoscale": "1-5" }
-        #
-        # Options:
-        #   cpu:    — target CPU utilization percentage (default: 75)
-        #   memory: — target memory utilization percentage (default: 80)
-        #
-        #   stack do
-        #     use Middleware::HPAForDeployment
-        #     use Middleware::HPAForDeployment, cpu: 60, memory: 70
-        #   end
-        #
-        class HPAForDeployment < Middleware
-          LABEL = :"app.kubernetes.io/autoscale"
-
-          def initialize(cpu: 75, memory: 80)
-            @cpu = cpu
-            @memory = memory
-          end
-
-          def call(resource)
-            return resource unless pod_bearing?(resource)
-
-            value = label(resource, LABEL)
-            return resource unless value
-
-            min, max = parse_range(value)
-
-            h = resource.to_h
-            name      = h.dig(:metadata, :name)
-            namespace = h.dig(:metadata, :namespace)
-            labels    = h.dig(:metadata, :labels) || {}
-            api_version = h[:apiVersion] || "apps/v1"
-            resource_kind = kind(resource)
-
-            # Capture ivars as locals — the block runs via instance_exec
-            # on a BlackHoleStruct, so @ivars would resolve on the BHS.
-            cpu_target    = @cpu
-            memory_target = @memory
-
-            hpa = Kube::Schema["HorizontalPodAutoscaler"].new {
-              metadata.name      = name
-              metadata.namespace = namespace if namespace
-              metadata.labels    = labels.reject { |k, _| k == LABEL }
-
-              spec.scaleTargetRef = {
-                apiVersion: api_version,
-                kind:       resource_kind,
-                name:       name,
-              }
-              spec.minReplicas = min
-              spec.maxReplicas = max
-              spec.metrics = [
-                {
-                  type: "Resource",
-                  resource: {
-                    name: "cpu",
-                    target: { type: "Utilization", averageUtilization: cpu_target },
-                  },
-                },
-                {
-                  type: "Resource",
-                  resource: {
-                    name: "memory",
-                    target: { type: "Utilization", averageUtilization: memory_target },
-                  },
-                },
-              ]
-            }
-
-            [resource, hpa]
-          end
-
-          private
-
-            def parse_range(value)
-              parts = value.to_s.split("-", 2)
-
-              unless parts.length == 2
-                raise ArgumentError,
-                  "Invalid autoscale label: #{value.inspect}. Expected format: \"min-max\" (e.g. \"1-5\")"
-              end
-
-              min = Integer(parts[0])
-              max = Integer(parts[1])
-
-              unless min > 0 && max >= min
-                raise ArgumentError,
-                  "Invalid autoscale range: min=#{min}, max=#{max}. " \
-                  "min must be > 0 and max must be >= min."
-              end
-
-              [min, max]
-            end
-        end
-      end
-    end
-  end
-end

data/lib/kube/cluster/manifest/middleware/labels.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Kube
-  module Cluster
-    class Manifest < Kube::Schema::Manifest
-      class Middleware
-        # Merges labels into +metadata.labels+ on every resource.
-        # Existing labels are preserved; the supplied labels act as defaults
-        # that can be overridden per-resource.
-        #
-        #   stack do
-        #     use Middleware::Labels, app: "web-app", managed_by: "kube_cluster"
-        #   end
-        #
-        # The keyword arguments are converted to standard label keys:
-        #
-        #   app:        -> "app.kubernetes.io/name"
-        #   instance:   -> "app.kubernetes.io/instance"
-        #   version:    -> "app.kubernetes.io/version"
-        #   component:  -> "app.kubernetes.io/component"
-        #   part_of:    -> "app.kubernetes.io/part-of"
-        #   managed_by: -> "app.kubernetes.io/managed-by"
-        #
-        # Any unrecognized keys are passed through as-is (string or symbol).
-        #
-        class Labels < Middleware
-          STANDARD_KEYS = {
-            app:        :"app.kubernetes.io/name",
-            instance:   :"app.kubernetes.io/instance",
-            version:    :"app.kubernetes.io/version",
-            component:  :"app.kubernetes.io/component",
-            part_of:    :"app.kubernetes.io/part-of",
-            managed_by: :"app.kubernetes.io/managed-by",
-          }.freeze
-
-          def initialize(**labels)
-            @labels = normalize(labels)
-          end
-
-          def call(resource)
-            h = resource.to_h
-            h[:metadata] ||= {}
-            h[:metadata][:labels] = @labels.merge(h[:metadata][:labels] || {})
-            rebuild(resource, h)
-          end
-
-          private
-
-            def normalize(labels)
-              labels.each_with_object({}) do |(key, value), result|
-                normalized_key = STANDARD_KEYS.fetch(key, key)
-                result[normalized_key] = value.to_s
-              end
-            end
-        end
-      end
-    end
-  end
-end

data/lib/kube/cluster/manifest/middleware/namespace.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Kube
-  module Cluster
-    class Manifest < Kube::Schema::Manifest
-      class Middleware
-        # Sets +metadata.namespace+ on all namespace-scoped resources.
-        # Cluster-scoped kinds (Namespace, ClusterRole, etc.) are skipped.
-        #
-        #   stack do
-        #     use Middleware::Namespace, "production"
-        #   end
-        #
-        class Namespace < Middleware
-          def initialize(namespace)
-            @namespace = namespace
-          end
-
-          def call(resource)
-            return resource if cluster_scoped?(resource)
-
-            h = resource.to_h
-            h[:metadata] ||= {}
-            h[:metadata][:namespace] = @namespace
-            rebuild(resource, h)
-          end
-        end
-      end
-    end
-  end
-end