vagrant-k8s 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 07217ff90e6ba7b0c4f90a89b21385d0d8527863ae936fe052d3e6f39e1b7800
+  data.tar.gz: d2f5f10123b86cf8bf40a5523bcbfa41b0c2b35953c11cb7705113a396a750e0
+SHA512:
+  metadata.gz: a57e7c941f796d9be993199ef70a384b0cfb049833317578794f2565774ba6c4be20142cb6d15d56c424cb1547fdc2a164a433983acc6b96b40bf3920c728a66
+  data.tar.gz: 23b76a729143ce4355192ee75eff409fa7e868c0617a2b75fe0501d59a8bbf9b1cfd231287bfb8c4260f36f29945a69ab07b08ce8195b417e5d5f7768809f6d8

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## [0.2.0](https://github.com/julienpoirou/vagrant-k8s/compare/v0.1.4...v0.2.0) (2026-07-05)
+
+
+### Fonctionnalités ✨
+
+* Initial vagrant-k8s plugin implementation ([66cb354](https://github.com/julienpoirou/vagrant-k8s/commit/66cb3545b61e6300fa1549c8690411c348252d19))
+
+## 0.1.0
+
+- Initial release with shared Kubernetes configuration, `vagrant k8s`, and Helm/Kustomize provisioners.

data/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Julien Poirou
+
+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.fr.md

@@ -0,0 +1,61 @@
+# vagrant-k8s
+
+Plugin Vagrant pour piloter un cluster Kubernetes depuis la machine hôte, avec des provisionneurs Helm et Kustomize.
+
+## Installation
+
+```sh
+vagrant plugin install vagrant-k8s
+```
+
+## Configuration du cluster
+
+```ruby
+Vagrant.configure("2") do |config|
+  config.k8s.kubeconfig = "config/kubeconfig.yaml" # relatif au Vagrantfile
+  config.k8s.context    = "kind-dev"
+  config.k8s.namespace  = "demo"
+  config.k8s.kubectl    = "kubectl"               # facultatif
+end
+```
+
+Laissez `kubeconfig` à `nil` pour utiliser la configuration habituelle de Kubectl (dont `KUBECONFIG`).
+
+## Provisionneur Helm
+
+```ruby
+config.vm.provision "nginx", type: "helm" do |helm|
+  helm.release = "nginx"
+  helm.chart = "ingress-nginx"
+  helm.repo = "https://kubernetes.github.io/ingress-nginx"
+  helm.version = "4.11.3"
+  helm.namespace = "ingress-nginx"
+  helm.create_namespace = true
+  helm.values = ["k8s/ingress-values.yaml"]
+  helm.set = { "controller.replicaCount" => 2 }
+  helm.wait = true
+  helm.atomic = true
+  helm.timeout = "5m"
+end
+```
+
+Le provisionneur exécute `helm upgrade --install` sur le contexte configuré dans `config.k8s`.
+
+## Provisionneur Kustomize
+
+```ruby
+config.vm.provision "application", type: "kustomize" do |kustomize|
+  kustomize.path = "k8s/overlays/dev"
+  kustomize.namespace = "demo" # remplace config.k8s.namespace
+  kustomize.server_side = true
+  kustomize.prune = true
+  kustomize.prune_selector = "app.kubernetes.io/managed-by=vagrant"
+  kustomize.wait = true
+end
+```
+
+Il exécute `kubectl apply -k`. Avec `wait`, il attend les pods prêts pendant cinq minutes.
+
+## Prérequis
+
+`kubectl` est requis sur l'hôte. Helm est requis uniquement pour le provisionneur Helm. Les chemins de manifests et de fichiers values sont relatifs au répertoire du Vagrantfile.

data/README.md

@@ -0,0 +1,63 @@
+# vagrant-k8s
+
+Vagrant plugin to drive a Kubernetes cluster from the host machine, with Helm and Kustomize provisioners.
+
+See [the French documentation](README.fr.md) for the same content in French.
+
+## Installation
+
+```sh
+vagrant plugin install vagrant-k8s
+```
+
+## Cluster configuration
+
+```ruby
+Vagrant.configure("2") do |config|
+  config.k8s.kubeconfig = "config/kubeconfig.yaml" # relative to the Vagrantfile
+  config.k8s.context    = "kind-dev"
+  config.k8s.namespace  = "demo"
+  config.k8s.kubectl    = "kubectl"               # optional
+end
+```
+
+Leave `kubeconfig` at `nil` to use the usual Kubectl configuration (including `KUBECONFIG`).
+
+## Helm provisioner
+
+```ruby
+config.vm.provision "nginx", type: "helm" do |helm|
+  helm.release = "nginx"
+  helm.chart = "ingress-nginx"
+  helm.repo = "https://kubernetes.github.io/ingress-nginx"
+  helm.version = "4.11.3"
+  helm.namespace = "ingress-nginx"
+  helm.create_namespace = true
+  helm.values = ["k8s/ingress-values.yaml"]
+  helm.set = { "controller.replicaCount" => 2 }
+  helm.wait = true
+  helm.atomic = true
+  helm.timeout = "5m"
+end
+```
+
+The provisioner runs `helm upgrade --install` against the context configured in `config.k8s`.
+
+## Kustomize provisioner
+
+```ruby
+config.vm.provision "application", type: "kustomize" do |kustomize|
+  kustomize.path = "k8s/overlays/dev"
+  kustomize.namespace = "demo" # overrides config.k8s.namespace
+  kustomize.server_side = true
+  kustomize.prune = true
+  kustomize.prune_selector = "app.kubernetes.io/managed-by=vagrant"
+  kustomize.wait = true
+end
+```
+
+It runs `kubectl apply -k`. With `wait`, it waits for pods to become ready for five minutes.
+
+## Requirements
+
+`kubectl` is required on the host. Helm is required only for the Helm provisioner. Manifest and values file paths are relative to the Vagrantfile directory.

data/lib/vagrant-k8s/VERSION

@@ -0,0 +1 @@
+0.2.0

data/lib/vagrant-k8s/command_runner.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module VagrantK8s
+  module CommandRunner
+    # Raised when a command exits non-zero. Subclasses VagrantError so callers
+    # can still rescue it as one, but carries its own message: VagrantError drops
+    # a positional message string and would otherwise display "No error message".
+    class CommandError < Vagrant::Errors::VagrantError
+      def initialize(message)
+        @command_error_message = message
+        super()
+      end
+
+      def to_s
+        @command_error_message
+      end
+
+      def message
+        @command_error_message
+      end
+    end
+
+    module_function
+
+    # tolerate: optional Regexp. When the command fails but its stderr matches it,
+    # the failure is treated as a benign no-op (e.g. `kubectl wait` finding no
+    # matching resources) — logged as detail instead of raising.
+    # tolerate_message: friendly text to log in that case instead of echoing the
+    # raw (and alarming) stderr.
+    def run(ui, command, chdir: nil, tolerate: nil, tolerate_message: nil)
+      ui.detail("Executing: #{command.join(' ')}")
+      stdout, stderr, status = Open3.capture3(*command, chdir: chdir)
+      ui.detail(stdout.rstrip) unless stdout.empty?
+
+      if !status.success? && tolerate && stderr.match?(tolerate)
+        note = tolerate_message || stderr.rstrip
+        ui.detail(note) unless note.to_s.empty?
+        return stdout
+      end
+
+      ui.error(stderr.rstrip) unless stderr.empty?
+      raise CommandError, "Command failed (exit #{status.exitstatus}): #{command.first}" unless status.success?
+
+      stdout
+    rescue Errno::ENOENT
+      raise CommandError, "Executable not found: #{command.first}"
+    end
+  end
+end

data/lib/vagrant-k8s/config.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module VagrantK8s
+  class Config < Vagrant.plugin('2', :config)
+    attr_accessor :kubeconfig, :context, :namespace, :kubectl
+
+    def initialize
+      @kubeconfig = UNSET_VALUE
+      @context = UNSET_VALUE
+      @namespace = UNSET_VALUE
+      @kubectl = UNSET_VALUE
+    end
+
+    def finalize!
+      @kubeconfig = nil if @kubeconfig == UNSET_VALUE
+      @context = nil if @context == UNSET_VALUE
+      @namespace = nil if @namespace == UNSET_VALUE
+      @kubectl = 'kubectl' if @kubectl == UNSET_VALUE
+    end
+
+    def validate(_machine)
+      errors = []
+      errors << 'k8s.kubeconfig must be a path string or nil' unless @kubeconfig.nil? || @kubeconfig.is_a?(String)
+      errors << 'k8s.context must be a string or nil' unless @context.nil? || @context.is_a?(String)
+      errors << 'k8s.namespace must be a string or nil' unless @namespace.nil? || @namespace.is_a?(String)
+      errors << 'k8s.kubectl must be a command string' unless @kubectl.is_a?(String) && !@kubectl.empty?
+      { 'vagrant-k8s' => errors }
+    end
+  end
+end

data/lib/vagrant-k8s/helm_provisioner.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'open3'
+require_relative 'provisioner'
+
+module VagrantK8s
+  class HelmConfig < Vagrant.plugin('2', :config)
+    attr_accessor :release, :chart, :repo, :version, :namespace, :values, :set, :wait, :atomic, :create_namespace,
+                  :timeout, :helm
+
+    def initialize
+      @release = @chart = UNSET_VALUE
+      @repo = @version = @namespace = UNSET_VALUE
+      @values = @set = UNSET_VALUE
+      @wait = @atomic = @create_namespace = @timeout = @helm = UNSET_VALUE
+    end
+
+    def finalize!
+      @repo = nil if @repo == UNSET_VALUE
+      @version = nil if @version == UNSET_VALUE
+      @namespace = nil if @namespace == UNSET_VALUE
+      @values = [] if @values == UNSET_VALUE
+      @set = {} if @set == UNSET_VALUE
+      @wait = false if @wait == UNSET_VALUE
+      @atomic = false if @atomic == UNSET_VALUE
+      @create_namespace = false if @create_namespace == UNSET_VALUE
+      @timeout = nil if @timeout == UNSET_VALUE
+      @helm = 'helm' if @helm == UNSET_VALUE
+    end
+
+    def validate(_machine)
+      errors = []
+      errors << 'helm.release is required' unless @release.is_a?(String) && !@release.empty?
+      errors << 'helm.chart is required' unless @chart.is_a?(String) && !@chart.empty?
+      errors << 'helm.values must be an array' unless @values.is_a?(Array)
+      errors << 'helm.set must be a hash' unless @set.is_a?(Hash)
+      { 'vagrant-k8s' => errors }
+    end
+  end
+
+  class HelmProvisioner < BaseProvisioner
+    def provision
+      command = [@config.helm, 'upgrade', '--install', @config.release, @config.chart]
+      append_release_options(command)
+      append_values_and_set(command)
+      append_cluster_options(command)
+      run(command)
+    end
+
+    private
+
+    def append_release_options(command)
+      command.push('--repo', @config.repo) if Kubeconfig.present?(@config.repo)
+      command.push('--version', @config.version) if Kubeconfig.present?(@config.version)
+      namespace = @config.namespace || @machine.config.k8s.namespace
+      command.push('--namespace', namespace) if Kubeconfig.present?(namespace)
+      command << '--create-namespace' if @config.create_namespace
+      command << '--wait' if @config.wait
+      command << atomic_flag if @config.atomic
+      command.push('--timeout', @config.timeout) if Kubeconfig.present?(@config.timeout)
+      command
+    end
+
+    def append_values_and_set(command)
+      @config.values.each { |value| command.push('--values', root_path(value)) }
+      @config.set.each { |key, value| command.push('--set', "#{key}=#{value}") }
+      command
+    end
+
+    # helm 4 deprecated --atomic in favour of --rollback-on-failure. Pick the
+    # flag matching the installed helm; fall back to --atomic when the version
+    # can't be determined (correct for helm 3, still accepted — with a
+    # deprecation notice — on helm 4).
+    def atomic_flag
+      helm_major >= 4 ? '--rollback-on-failure' : '--atomic'
+    end
+
+    def helm_major
+      out, _err, status = Open3.capture3(@config.helm, 'version', '--short')
+      return 3 unless status.success?
+
+      match = out.strip.match(/v?(\d+)\./)
+      match ? match[1].to_i : 3
+    rescue StandardError
+      3
+    end
+
+    def append_cluster_options(command)
+      global = @machine.config.k8s
+      kubeconfig = Kubeconfig.resolve_path(@machine, global.kubeconfig)
+      command.push('--kubeconfig', kubeconfig) if kubeconfig
+      command.push('--kube-context', global.context) if Kubeconfig.present?(global.context)
+      command
+    end
+  end
+end

data/lib/vagrant-k8s/kubeconfig.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module VagrantK8s
+  module Kubeconfig
+    module_function
+
+    def kubectl_command(machine, extra_args, namespace: nil, context: nil)
+      config = machine.config.k8s
+      command = [config.kubectl]
+      kubeconfig = resolve_path(machine, config.kubeconfig)
+      command += ['--kubeconfig', kubeconfig] if kubeconfig
+      selected_context = context || config.context
+      selected_namespace = namespace || config.namespace
+      command += ['--context', selected_context] if present?(selected_context)
+      command += ['--namespace', selected_namespace] if present?(selected_namespace)
+      command + extra_args
+    end
+
+    def resolve_path(machine, path)
+      return nil unless present?(path)
+      return path if Pathname.new(path).absolute?
+
+      File.expand_path(path, machine.env.root_path.to_s)
+    end
+
+    def present?(value)
+      value.is_a?(String) && !value.empty?
+    end
+  end
+end

data/lib/vagrant-k8s/kustomize_provisioner.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'provisioner'
+
+module VagrantK8s
+  class KustomizeConfig < Vagrant.plugin('2', :config)
+    attr_accessor :path, :namespace, :prune, :prune_selector, :server_side, :force_conflicts, :wait
+
+    def initialize
+      @path = @namespace = @prune_selector = UNSET_VALUE
+      @prune = @server_side = @force_conflicts = @wait = UNSET_VALUE
+    end
+
+    def finalize!
+      @namespace = nil if @namespace == UNSET_VALUE
+      @prune_selector = nil if @prune_selector == UNSET_VALUE
+      @prune = false if @prune == UNSET_VALUE
+      @server_side = false if @server_side == UNSET_VALUE
+      @force_conflicts = false if @force_conflicts == UNSET_VALUE
+      @wait = false if @wait == UNSET_VALUE
+    end
+
+    def validate(_machine)
+      errors = []
+      errors << 'kustomize.path is required' unless @path.is_a?(String) && !@path.empty?
+      if @prune && !Kubeconfig.present?(@prune_selector)
+        errors << 'kustomize.prune_selector is required when prune is true'
+      end
+      { 'vagrant-k8s' => errors }
+    end
+  end
+
+  class KustomizeProvisioner < BaseProvisioner
+    def provision
+      command = Kubeconfig.kubectl_command(@machine, ['apply', '-k', root_path(@config.path)],
+                                           namespace: @config.namespace)
+      command << '--server-side' if @config.server_side
+      command << '--force-conflicts' if @config.force_conflicts
+      command += ['--prune', '--selector', @config.prune_selector] if @config.prune
+      run(command)
+      return unless @config.wait
+
+      # A kustomization may apply only non-pod resources (e.g. a ConfigMap), in
+      # which case `kubectl wait pod --all` exits non-zero with "no matching
+      # resources found". That's nothing to wait for, not a failure.
+      run(Kubeconfig.kubectl_command(@machine, ['wait', '--for=condition=ready', 'pod', '--all', '--timeout=300s'],
+                                     namespace: @config.namespace),
+          tolerate: /no matching resources found/i,
+          tolerate_message: 'No pods to wait for — the kustomization applied no pod-bearing resources.')
+    end
+  end
+end

data/lib/vagrant-k8s/plugin.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'vagrant'
+require 'pathname'
+require_relative 'config'
+require_relative 'helm_provisioner'
+require_relative 'kustomize_provisioner'
+
+module VagrantK8s
+  class Plugin < Vagrant.plugin('2')
+    name 'vagrant-k8s'
+
+    config(:k8s) { Config }
+    config(:helm, :provisioner) { HelmConfig }
+    provisioner(:helm) { HelmProvisioner }
+    config(:kustomize, :provisioner) { KustomizeConfig }
+    provisioner(:kustomize) { KustomizeProvisioner }
+  end
+end

data/lib/vagrant-k8s/provisioner.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'command_runner'
+require_relative 'kubeconfig'
+
+module VagrantK8s
+  class BaseProvisioner < Vagrant.plugin('2', :provisioner)
+    def initialize(machine, config)
+      super
+      @machine = machine
+      @config = config
+    end
+
+    private
+
+    def run(command, tolerate: nil, tolerate_message: nil)
+      CommandRunner.run(@machine.ui, command, chdir: @machine.env.root_path.to_s,
+                                              tolerate: tolerate, tolerate_message: tolerate_message)
+    end
+
+    def root_path(path)
+      return path if Pathname.new(path).absolute?
+
+      File.expand_path(path, @machine.env.root_path.to_s)
+    end
+  end
+end

data/lib/vagrant-k8s/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module VagrantK8s
+  VERSION = File.read(File.join(__dir__, 'VERSION')).strip
+end

data/lib/vagrant-k8s.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'vagrant-k8s/version'
+require_relative 'vagrant-k8s/plugin'

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-k8s
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Julien Poirou
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-07-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.75'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.75'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Configures a Kubernetes cluster from a Vagrantfile and provides Helm
+  and Kustomize provisioners.
+email:
+- julienpoirou@protonmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.md
+- README.fr.md
+- README.md
+- lib/vagrant-k8s.rb
+- lib/vagrant-k8s/VERSION
+- lib/vagrant-k8s/command_runner.rb
+- lib/vagrant-k8s/config.rb
+- lib/vagrant-k8s/helm_provisioner.rb
+- lib/vagrant-k8s/kubeconfig.rb
+- lib/vagrant-k8s/kustomize_provisioner.rb
+- lib/vagrant-k8s/plugin.rb
+- lib/vagrant-k8s/provisioner.rb
+- lib/vagrant-k8s/version.rb
+homepage: https://github.com/julienpoirou/vagrant-k8s
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  bug_tracker_uri: https://github.com/julienpoirou/vagrant-k8s/issues
+  changelog_uri: https://github.com/julienpoirou/vagrant-k8s/blob/main/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/vagrant-k8s/
+  source_code_uri: https://github.com/julienpoirou/vagrant-k8s
+  homepage_uri: https://github.com/julienpoirou/vagrant-k8s
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Vagrant integration for Kubernetes with Helm and Kustomize provisioners
+test_files: []