kran 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 79c4036c8b185127e7157d85eff69305ef0d9bc124e4fbfc9f1ff336fdaae6fe
+  data.tar.gz: 1950703c5f3f10e734a39277ec2ede994fa6703ff2c16c3b5f174f03dc9aafab
+SHA512:
+  metadata.gz: 93fc5a593bb95f3b212d5657d446b08d264de9e186302732320671f94eef43713cd6b84a59b690c800950c4b45d0b74501aa9557146077251d856557821fa0a4
+  data.tar.gz: e058664d0ede94f9fa65d6d8e59f18e9b55836b176f612cf387e597c8d030e392cc50df4118cabbe3105223c6a90fc969524cb02eff709252129db934b963f99

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yi Feng Xie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,49 @@
+# kran
+
+Deploy to Kubernetes with [krane](https://github.com/Shopify/krane), the simple way.
+One command builds the image, pushes it, renders the krane templates and deploys them. A few more
+commands cover the daily work: logs, exec, details, audit.
+
+Kran is the German word for crane.
+
+## Install
+
+```sh
+gem install kran
+```
+
+Kran drives `docker`, `krane` and `kubectl`, and `ejson` when secrets come from krane's `secrets.ejson`.
+None of them is a gem dependency. `kran version` shows which ones are found.
+
+## Use
+
+```sh
+kran init                 # writes config/kran.yml
+kran deploy --dry-run     # prints every command it would run
+kran deploy               # docker login, docker build --push, krane render | krane deploy
+kran deploy -P            # skip the build and push
+kran logs -f
+kran exec bin/rails db:migrate
+kran shell                # alias for: exec --interactive bash
+kran console              # alias for: exec --interactive bin/rails console
+```
+
+Every command reads `config/kran.yml`. `-d staging` layers `config/kran.staging.yml` on top of it.
+
+If you have used [kamal](https://kamal-deploy.org), this will feel just as simple: familiar command names,
+one config file, one command to deploy.
+
+Documentation: https://kran.bincode.tw
+Source: https://github.com/yfxie/kran
+
+## Develop
+
+```sh
+bundle install
+bundle exec rake test
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/exe/kran

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require "kran"
+
+begin
+  Kran::CLI::Main.start
+rescue Kran::Error => error
+  warn("ERROR: #{error.message}")
+  exit(1)
+end

data/lib/kran/cli/alias_command.rb

@@ -0,0 +1,23 @@
+require "shellwords"
+
+module Kran
+  module CLI
+    # Thor hands unknown command names to this class, which lets `aliases` from
+    # config/kran.yml expand into real commands without shadowing built-in ones.
+    class AliasCommand < Thor::DynamicCommand
+      def run(instance, args = [])
+        expansion = aliases(args)[name]
+        return super unless expansion
+
+        Main.start(Shellwords.split(expansion) + args)
+      end
+
+      private
+
+      def aliases(args)
+        destination = Thor::Options.new(Main.class_options).parse(args)["destination"]
+        Configuration.load(destination: destination).aliases
+      end
+    end
+  end
+end

data/lib/kran/cli/base.rb

@@ -0,0 +1,57 @@
+require "thor"
+
+module Kran
+  module CLI
+    class Base < Thor
+      class_option :destination, aliases: "-d", desc: "Layer config/kran.<destination>.yml over config/kran.yml"
+      # No default here: Thor merges a subcommand's options over the parent's,
+      # so a default of false would erase `--dry-run` given before `build push`.
+      class_option :dry_run, type: :boolean, desc: "Print the commands instead of running them"
+
+      class << self
+        def exit_on_failure?
+          true
+        end
+
+        def basename
+          "kran"
+        end
+      end
+
+      private
+
+      def config
+        @config ||= Configuration.load(destination: options[:destination])
+      end
+
+      def runner
+        Kran.runner.tap { |runner| runner.dry_run = options[:dry_run] }
+      end
+
+      def docker
+        Commands::Docker.new(config)
+      end
+
+      def krane
+        Commands::Krane.new(config)
+      end
+
+      def kubectl
+        Commands::Kubectl.new(config)
+      end
+
+      def image_tag
+        options[:version] || Git.new.version
+      end
+
+      def ensure_tools(*names)
+        Dependencies.new.ensure!(*names) unless options[:dry_run]
+      end
+
+      def push_image(tag)
+        runner.run(docker.login, stdin: config.registry.password) if config.registry.credentials?
+        runner.run(docker.build(tag))
+      end
+    end
+  end
+end

data/lib/kran/cli/build.rb

@@ -0,0 +1,19 @@
+module Kran
+  module CLI
+    class Build < Base
+      desc "push", "Build the image and push it to the registry"
+      option :version, desc: "Image tag (defaults to the git HEAD sha)"
+      def push
+        ensure_tools("docker")
+        push_image(image_tag)
+      end
+
+      desc "details", "Show the Docker daemon and builders that builds run on"
+      def details
+        ensure_tools("docker")
+        runner.run(docker.version)
+        runner.run(docker.buildx_ls)
+      end
+    end
+  end
+end

data/lib/kran/cli/main.rb

@@ -0,0 +1,92 @@
+require "fileutils"
+
+module Kran
+  module CLI
+    class Main < Base
+      TEMPLATE = File.expand_path("../templates/kran.yml", __dir__)
+
+      class << self
+        def dynamic_command_class
+          AliasCommand
+        end
+      end
+
+      desc "init", "Create config/kran.yml"
+      def init
+        if File.exist?(Configuration::FILE)
+          say "#{Configuration::FILE} already exists (remove it first to create a new one)"
+        else
+          FileUtils.mkdir_p(File.dirname(Configuration::FILE))
+          FileUtils.cp(TEMPLATE, Configuration::FILE)
+          say "Created #{Configuration::FILE}"
+        end
+      end
+
+      desc "deploy", "Build and push the image, then render and deploy with krane"
+      option :version, desc: "Image tag (defaults to the git HEAD sha)"
+      option :skip_push, aliases: "-P", type: :boolean, default: false, desc: "Skip the image build and push"
+      def deploy
+        tools = options[:skip_push] ? [] : ["docker"]
+        ensure_tools(*tools, krane.executable, "kubectl")
+        tag = image_tag
+        push_image(tag) unless options[:skip_push]
+        runner.run(krane.pipeline(tag))
+      end
+
+      desc "build SUBCOMMAND", "Build the image (push, details)"
+      subcommand "build", Build
+
+      desc "logs", "Show logs from the app pods"
+      option :follow, aliases: "-f", type: :boolean, default: false, desc: "Stream new lines as they arrive"
+      option :lines, aliases: "-n", type: :numeric, desc: "Number of recent lines per pod"
+      option :since, aliases: "-s", desc: "Only lines newer than this, for example 10m or 1h"
+      option :grep, aliases: "-g", desc: "Only lines matching this pattern"
+      def logs
+        ensure_tools("kubectl")
+        runner.run(kubectl.logs(**options.slice("follow", "lines", "since", "grep").symbolize_keys))
+      end
+
+      desc "exec COMMAND...", "Run a command in a running app pod"
+      option :interactive, aliases: "-i", type: :boolean, default: false, desc: "Attach a terminal"
+      def exec(*command)
+        if command.empty?
+          raise Error, "exec needs a command to run, for example `kran exec bin/rails db:migrate`"
+        end
+
+        ensure_tools("kubectl")
+        runner.run(kubectl.exec(command, interactive: options[:interactive]))
+      end
+
+      desc "details", "Show every resource in the namespace"
+      def details
+        ensure_tools("kubectl")
+        runner.run(kubectl.details)
+      end
+
+      desc "audit", "Show the rollout history of the app deployments"
+      def audit
+        ensure_tools("kubectl")
+        runner.run(kubectl.audit)
+      end
+
+      desc "version", "Show the versions of kran, docker, krane and kubectl"
+      def version
+        krane_commands = Commands::Krane.new(File.exist?(Configuration::FILE) ? config : Configuration.new({}))
+        say "kran     #{VERSION}"
+        say "docker   #{tool_version("docker", "docker --version")}"
+        say "krane    #{tool_version(krane_commands.executable, krane_commands.version)}"
+        say "kubectl  #{tool_version("kubectl", "kubectl version --client")}"
+      end
+
+      private
+
+      def tool_version(executable, command)
+        return "not found" unless Kran.runner.executable?(executable)
+
+        Kran.runner.capture(command).lines.first.to_s.strip
+      rescue CommandFailed => error
+        "failed: #{error.message.lines[1].to_s.strip}"
+      end
+    end
+  end
+end

data/lib/kran/cli.rb

@@ -0,0 +1,5 @@
+require "active_support/core_ext/hash/keys"
+require "kran/cli/base"
+require "kran/cli/build"
+require "kran/cli/alias_command"
+require "kran/cli/main"

data/lib/kran/commands/docker.rb

@@ -0,0 +1,43 @@
+require "kran/shell"
+
+module Kran
+  module Commands
+    class Docker
+      def initialize(config)
+        @config = config
+      end
+
+      def login
+        registry = @config.registry
+        docker("login", registry.server, "-u", registry.username, "--password-stdin")
+      end
+
+      def build(tag)
+        builder = @config.builder
+        docker("build", *platform(builder.arch), "--push", "-t", "#{@config.absolute_image}:#{tag}", builder.context)
+      end
+
+      def version
+        docker("version")
+      end
+
+      def buildx_ls
+        docker("buildx", "ls")
+      end
+
+      private
+
+      def docker(*args)
+        command = Shell.join(["docker", *args.compact])
+        remote = @config.builder.remote
+        remote ? "DOCKER_HOST=#{Shell.escape(remote)} #{command}" : command
+      end
+
+      def platform(archs)
+        return [] if archs.empty?
+
+        ["--platform", archs.map { |arch| "linux/#{arch}" }.join(",")]
+      end
+    end
+  end
+end

data/lib/kran/commands/krane.rb

@@ -0,0 +1,44 @@
+require "shellwords"
+require "kran/shell"
+
+module Kran
+  module Commands
+    class Krane
+      def initialize(config)
+        @config = config
+      end
+
+      def render(tag)
+        krane("render", "-f", @config.krane.templates, "--current-sha", tag,
+          "--bindings", "image=#{@config.absolute_image}:#{tag}")
+      end
+
+      def deploy
+        kubernetes = @config.kubernetes
+        # krane parses options with Thor, where a repeated -f replaces the earlier one
+        # instead of appending to it, so every file has to follow a single -f.
+        files = [@config.krane.secrets, "-"].compact
+        command = krane("deploy", kubernetes.namespace, kubernetes.context, "-f", *files)
+        kubernetes.kubeconfig ? "KUBECONFIG=#{Shell.escape(kubernetes.kubeconfig)} #{command}" : command
+      end
+
+      def pipeline(tag)
+        "#{render(tag)} | #{deploy}"
+      end
+
+      def version
+        krane("version")
+      end
+
+      def executable
+        Shellwords.split(@config.krane.command).find { |word| !word.include?("=") }
+      end
+
+      private
+
+      def krane(*args)
+        "#{@config.krane.command} #{Shell.join(args)}"
+      end
+    end
+  end
+end

data/lib/kran/commands/kubectl.rb

@@ -0,0 +1,54 @@
+require "kran/shell"
+
+module Kran
+  module Commands
+    class Kubectl
+      def initialize(config)
+        @config = config
+      end
+
+      def logs(lines: nil, since: nil, follow: false, grep: nil)
+        command = kubectl("logs", "-l", selector, *container, "--prefix", "--timestamps",
+          *(["--tail", lines.to_s] if lines), *(["--since", since] if since), *("-f" if follow))
+        grep ? "#{command} | grep #{Shell.escape(grep)}" : command
+      end
+
+      def exec(command, interactive: false)
+        <<~SH.chomp
+          pod=$(#{running_pod}) && test -n "$pod" || { echo #{Shell.escape("No running pod matches #{selector}")} >&2; exit 1; }
+          #{kubectl("exec", *("-it" if interactive))} "$pod" #{Shell.join([*container, "--", *command])}
+        SH
+      end
+
+      def details
+        kubectl("get", "all", "-o", "wide")
+      end
+
+      def audit
+        kubectl("rollout", "history", "deployment", "-l", selector)
+      end
+
+      private
+
+      def running_pod
+        kubectl("get", "pods", "-l", selector, "--field-selector", "status.phase=Running",
+          "-o", "jsonpath={.items[0].metadata.name}")
+      end
+
+      def selector
+        @config.app.selector
+      end
+
+      def container
+        name = @config.app.container
+        name ? ["-c", name] : []
+      end
+
+      def kubectl(*args)
+        kubernetes = @config.kubernetes
+        command = Shell.join(["kubectl", "--context", kubernetes.context, "--namespace", kubernetes.namespace, *args.compact])
+        kubernetes.kubeconfig ? "KUBECONFIG=#{Shell.escape(kubernetes.kubeconfig)} #{command}" : command
+      end
+    end
+  end
+end

data/lib/kran/configuration/app.rb

@@ -0,0 +1,13 @@
+module Kran
+  class Configuration
+    class App < Section
+      def selector
+        required("selector")
+      end
+
+      def container
+        optional("container")
+      end
+    end
+  end
+end

data/lib/kran/configuration/builder.rb

@@ -0,0 +1,17 @@
+module Kran
+  class Configuration
+    class Builder < Section
+      def arch
+        Array(optional("arch"))
+      end
+
+      def remote
+        optional("remote")
+      end
+
+      def context
+        optional("context", ".")
+      end
+    end
+  end
+end

data/lib/kran/configuration/krane.rb

@@ -0,0 +1,27 @@
+module Kran
+  class Configuration
+    class Krane < Section
+      DEFAULT_TEMPLATES = "config/deploy"
+      SECRETS_FILE = "secrets.ejson"
+
+      def templates
+        optional("templates", DEFAULT_TEMPLATES)
+      end
+
+      def secrets
+        optional("secrets") || default_secrets
+      end
+
+      def command
+        optional("command", "krane")
+      end
+
+      private
+
+      def default_secrets
+        path = File.join(templates, SECRETS_FILE)
+        path if File.exist?(path)
+      end
+    end
+  end
+end

data/lib/kran/configuration/kubernetes.rb

@@ -0,0 +1,18 @@
+module Kran
+  class Configuration
+    class Kubernetes < Section
+      def kubeconfig
+        path = optional("kubeconfig")
+        path && File.expand_path(path)
+      end
+
+      def context
+        required("context")
+      end
+
+      def namespace
+        required("namespace")
+      end
+    end
+  end
+end

data/lib/kran/configuration/registry.rb

@@ -0,0 +1,49 @@
+module Kran
+  class Configuration
+    class Registry < Section
+      def initialize(raw, ejson: nil)
+        super(raw)
+        @ejson = ejson
+      end
+
+      def server
+        value = optional("server")
+        value.to_s.empty? ? nil : value
+      end
+
+      def credentials?
+        return false if optional("username").nil? && optional("password").nil?
+        return true if optional("username") && optional("password")
+
+        raise Error, "Set registry.username and registry.password together in #{Configuration::FILE}, " \
+          "or leave both out to reuse the login docker already has"
+      end
+
+      def username
+        resolve("username")
+      end
+
+      def password
+        resolve("password")
+      end
+
+      private
+
+      def resolve(key)
+        case optional(key)
+        in Hash => reference then fetch_from_ejson(key, reference.fetch("ejson"))
+        in value then value
+        end
+      end
+
+      def fetch_from_ejson(key, path)
+        if @ejson.nil?
+          raise Error, "registry.#{key} refers to ejson but krane.secrets is not set and " \
+            "#{Krane::DEFAULT_TEMPLATES}/#{Krane::SECRETS_FILE} does not exist"
+        end
+
+        @ejson.fetch(path)
+      end
+    end
+  end
+end

data/lib/kran/configuration/section.rb

@@ -0,0 +1,23 @@
+module Kran
+  class Configuration
+    class Section
+      def initialize(raw)
+        @section = raw.fetch(name, {}) || {}
+      end
+
+      private
+
+      def name
+        self.class.name.split("::").last.downcase
+      end
+
+      def required(key)
+        @section.fetch(key) { raise Error, "Missing #{name}.#{key} in #{Configuration::FILE}" }
+      end
+
+      def optional(key, default = nil)
+        @section.fetch(key, default)
+      end
+    end
+  end
+end

data/lib/kran/configuration.rb

@@ -0,0 +1,75 @@
+require "erb"
+require "yaml"
+require "active_support/core_ext/hash/deep_merge"
+require "kran/configuration/section"
+require "kran/configuration/registry"
+require "kran/configuration/builder"
+require "kran/configuration/kubernetes"
+require "kran/configuration/krane"
+require "kran/configuration/app"
+
+module Kran
+  class Configuration
+    FILE = "config/kran.yml"
+
+    class << self
+      def load(destination: nil)
+        raw = load_file(FILE, destination, hint: " (run `kran init` to create one)")
+        raw = raw.deep_merge(load_file(destination_file(destination), destination)) if destination
+        new(raw, destination: destination)
+      end
+
+      private
+
+      def destination_file(destination)
+        FILE.sub(/\.yml\z/, ".#{destination}.yml")
+      end
+
+      def load_file(file, destination, hint: "")
+        raise Error, "Configuration file not found in #{file}#{hint}" unless File.exist?(file)
+
+        rendered = ERB.new(File.read(file), trim_mode: "-").result_with_hash(destination: destination)
+        YAML.safe_load(rendered, aliases: true) || {}
+      end
+    end
+
+    attr_reader :destination
+
+    def initialize(raw, destination: nil)
+      @raw = raw
+      @destination = destination
+    end
+
+    def image
+      @raw.fetch("image") { raise Error, "Missing image in #{FILE}" }
+    end
+
+    def absolute_image
+      [registry.server, image].compact.join("/")
+    end
+
+    def registry
+      @registry ||= Registry.new(@raw, ejson: krane.secrets && Ejson.new(krane.secrets))
+    end
+
+    def builder
+      @builder ||= Builder.new(@raw)
+    end
+
+    def kubernetes
+      @kubernetes ||= Kubernetes.new(@raw)
+    end
+
+    def krane
+      @krane ||= Krane.new(@raw)
+    end
+
+    def app
+      @app ||= App.new(@raw)
+    end
+
+    def aliases
+      @raw.fetch("aliases", {})
+    end
+  end
+end

data/lib/kran/dependencies.rb

@@ -0,0 +1,23 @@
+module Kran
+  class Dependencies
+    HINTS = {
+      "docker" => "Install it from https://docs.docker.com/get-docker/",
+      "krane" => "Install it with `gem install krane`, or add it to a Gemfile and set krane.command to " \
+        "`bundle exec krane`.",
+      "kubectl" => "Install it from https://kubernetes.io/docs/tasks/tools/",
+      "ejson" => "Install it with `gem install ejson` (krane depends on it) or `brew install ejson`.",
+    }.freeze
+    GENERIC_HINT = "Install it and try again."
+
+    def initialize(runner: Kran.runner)
+      @runner = runner
+    end
+
+    def ensure!(*names)
+      missing = names.reject { |name| @runner.executable?(name) }
+      return if missing.empty?
+
+      raise Error, missing.map { |name| "#{name} is not on PATH. #{HINTS.fetch(name, GENERIC_HINT)}" }.join("\n")
+    end
+  end
+end

data/lib/kran/ejson.rb

@@ -0,0 +1,27 @@
+require "json"
+require "kran/shell"
+
+module Kran
+  class Ejson
+    attr_reader :path
+
+    def initialize(path, runner: Kran.runner)
+      @path = path
+      @runner = runner
+    end
+
+    def fetch(dotted_path)
+      value = document.dig(*dotted_path.split("."))
+      raise Error, "#{dotted_path} not found in #{path}" if value.nil?
+
+      value
+    end
+
+    private
+
+    def document
+      Dependencies.new(runner: @runner).ensure!("ejson")
+      @document ||= JSON.parse(@runner.capture("ejson decrypt #{Shell.escape(path)}"))
+    end
+  end
+end

data/lib/kran/git.rb

@@ -0,0 +1,27 @@
+require "securerandom"
+
+module Kran
+  class Git
+    def initialize(runner: Kran.runner)
+      @runner = runner
+    end
+
+    def version
+      sha = revision
+      uncommitted? ? "#{sha}_uncommitted_#{SecureRandom.hex(8)}" : sha
+    end
+
+    private
+
+    def revision
+      @runner.capture("git rev-parse HEAD").strip
+    rescue CommandFailed => error
+      raise Error, "Git could not provide an image tag in #{Dir.pwd}: #{error.message}\n" \
+        "Pass --version to set the tag explicitly."
+    end
+
+    def uncommitted?
+      !@runner.capture("git status --porcelain").strip.empty?
+    end
+  end
+end

data/lib/kran/runner.rb

@@ -0,0 +1,55 @@
+require "open3"
+
+module Kran
+  class CommandFailed < Error; end
+
+  class Runner
+    attr_accessor :dry_run
+
+    def initialize(dry_run: false)
+      @dry_run = dry_run
+    end
+
+    def run(command, stdin: nil)
+      puts(stdin ? "printf '%s' '[REDACTED]' | #{command}" : command)
+      return if dry_run
+
+      status = unbundled { execute(command, stdin) }
+      raise CommandFailed, "Command failed (exit #{status.exitstatus}): #{command}" unless status.success?
+    end
+
+    def capture(command)
+      stdout, stderr, status = unbundled { Open3.capture3(command) }
+      unless status.success?
+        raise CommandFailed, "Command failed (exit #{status.exitstatus}): #{command}\n#{stderr.strip}"
+      end
+
+      stdout
+    rescue Errno::ENOENT => error
+      raise CommandFailed, "Command failed: #{command}\n#{error.message}"
+    end
+
+    def executable?(name)
+      ENV.fetch("PATH").split(File::PATH_SEPARATOR).any? { |dir| File.executable?(File.join(dir, name)) }
+    end
+
+    private
+
+    def execute(command, stdin)
+      if stdin
+        IO.popen(command, "w") { |io| io.write(stdin) }
+      else
+        system(command)
+      end
+      $CHILD_STATUS
+    end
+
+    # kran is usually started through `bundle exec` or a binstub, and the tools it
+    # drives (krane, ejson) are Ruby programs of their own. Without this they would
+    # inherit RUBYOPT and BUNDLE_GEMFILE and refuse to start unless they happened to
+    # be in the same bundle as kran.
+    def unbundled(&block)
+      defined?(Bundler) ? Bundler.with_unbundled_env(&block) : yield
+    end
+  end
+end

data/lib/kran/shell.rb

@@ -0,0 +1,19 @@
+module Kran
+  # Shellwords escapes "=" and ":" and uses backslashes, which makes every
+  # printed kubectl and docker command harder to read than necessary. Safe
+  # words stay bare; anything else is wrapped in single quotes.
+  module Shell
+    SAFE_WORD = %r{\A[\w@%+=:,./-]+\z}
+
+    extend self
+
+    def escape(word)
+      word = word.to_s
+      word.match?(SAFE_WORD) ? word : "'#{word.gsub("'", "'\\\\''")}'"
+    end
+
+    def join(words)
+      words.map { |word| escape(word) }.join(" ")
+    end
+  end
+end

data/lib/kran/templates/kran.yml

@@ -0,0 +1,52 @@
+# Name of the container image, without registry and tag.
+# The tag comes from `kran deploy --version`, or from git HEAD when omitted.
+image: my-user/my-app
+
+# Where the image is pushed. Leave username and password out to reuse the login docker already
+# has on this machine; set both, in CI for example, and `docker login` runs before every push.
+registry:
+  # Leave empty for Docker Hub.
+  server: ghcr.io
+  # username: my-user
+  # This file is ERB, so the password can come from the environment or any Ruby expression.
+  # password: <%= ENV["KRAN_REGISTRY_PASSWORD"] %>
+  # Or read it from krane's secrets.ejson (a dotted path from the top of the decrypted file):
+  # password:
+  #   ejson: registry.password
+
+# How the image is built.
+builder:
+  # One or more of amd64, arm64. Becomes `docker build --platform linux/<arch>[,linux/<arch>]`.
+  arch: amd64
+  # Build on another Docker host over SSH. Sets DOCKER_HOST for `docker login` and `docker build`.
+  # remote: ssh://user@builder.example.com
+  # Build context. Defaults to the current directory, so uncommitted changes are included.
+  # context: .
+
+# Cluster and namespace that every command targets.
+kubernetes:
+  # Defaults to the KUBECONFIG environment variable, then ~/.kube/config.
+  # kubeconfig: ~/.kube/my-cluster.yml
+  context: my-cluster
+  namespace: my-app
+
+# How krane is invoked.
+krane:
+  # Directory of krane templates, passed to `krane render -f`.
+  templates: config/deploy
+  # ejson file passed to `krane deploy -f`. Defaults to <templates>/secrets.ejson when it exists.
+  # secrets: config/deploy/secrets.ejson
+  # Command used to run krane. Override when krane lives in a Gemfile.
+  # command: bundle exec krane
+
+# Pods used by logs and exec.
+app:
+  # Label selector for the application pods (kubectl -l).
+  selector: app=my-app
+  # Container inside the pod (kubectl -c). Defaults to the pod's default container.
+  # container: web
+
+# Shortcuts run with `kran <alias>`. Extra arguments are appended to the command.
+aliases:
+  shell: exec --interactive bash
+  console: exec --interactive bin/rails console

data/lib/kran/version.rb

@@ -0,0 +1,3 @@
+module Kran
+  VERSION = "1.0.0"
+end

data/lib/kran.rb

@@ -0,0 +1,25 @@
+require "English"
+require "kran/version"
+
+module Kran
+  class Error < StandardError; end
+
+  class << self
+    attr_writer :runner
+
+    def runner
+      @runner ||= Runner.new
+    end
+  end
+end
+
+require "kran/shell"
+require "kran/runner"
+require "kran/ejson"
+require "kran/git"
+require "kran/configuration"
+require "kran/commands/docker"
+require "kran/commands/krane"
+require "kran/commands/kubectl"
+require "kran/dependencies"
+require "kran/cli"

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: kran
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Yi Feng Xie
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: One command to build, push, render and deploy with krane, plus helpers
+  for logs, exec, details and audit.
+email:
+- yfxie@me.com
+executables:
+- kran
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- exe/kran
+- lib/kran.rb
+- lib/kran/cli.rb
+- lib/kran/cli/alias_command.rb
+- lib/kran/cli/base.rb
+- lib/kran/cli/build.rb
+- lib/kran/cli/main.rb
+- lib/kran/commands/docker.rb
+- lib/kran/commands/krane.rb
+- lib/kran/commands/kubectl.rb
+- lib/kran/configuration.rb
+- lib/kran/configuration/app.rb
+- lib/kran/configuration/builder.rb
+- lib/kran/configuration/krane.rb
+- lib/kran/configuration/kubernetes.rb
+- lib/kran/configuration/registry.rb
+- lib/kran/configuration/section.rb
+- lib/kran/dependencies.rb
+- lib/kran/ejson.rb
+- lib/kran/git.rb
+- lib/kran/runner.rb
+- lib/kran/shell.rb
+- lib/kran/templates/kran.yml
+- lib/kran/version.rb
+homepage: https://kran.bincode.tw
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://kran.bincode.tw
+  source_code_uri: https://github.com/yfxie/kran
+  bug_tracker_uri: https://github.com/yfxie/kran/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Deploy to Kubernetes with krane, the simple way
+test_files: []