k8s-ruby 0.10.5

data/docker-compose.yaml

@@ -0,0 +1,10 @@
+rspec:
+  build: .
+  volumes:
+  - .:/app
+  entrypoint: bundle exec rspec
+k8s-ruby:
+  build: .
+  volumes:
+  - .:/app
+  entrypoint: bundle exec bin/k8s-client

data/k8s-ruby.gemspec

@@ -0,0 +1,40 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "k8s/ruby/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "k8s-ruby"
+  spec.version       = K8s::Ruby::VERSION
+  spec.authors       = ["rdx.net", "Kontena, Inc."]
+  spec.email         = ["firstname.lastname@rdx.net"]
+  spec.license       = "Apache-2.0"
+
+  spec.summary       = "Kubernetes client library for Ruby"
+  spec.homepage      = "https://github.com/rdxnet/k8s-ruby"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "bin"
+  spec.executables   = []
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = '~> 2.4'
+
+  spec.add_runtime_dependency "excon", "~> 0.71"
+  spec.add_runtime_dependency "dry-struct", "~> 0.5.0"
+  spec.add_runtime_dependency "dry-types", "~> 0.13.0"
+  spec.add_runtime_dependency "recursive-open-struct", "~> 1.1.0"
+  spec.add_runtime_dependency 'hashdiff', '~> 1.0.0'
+  spec.add_runtime_dependency 'jsonpath', '~> 0.9.5'
+  spec.add_runtime_dependency 'yajl-ruby', '~> 1.4.0'
+  spec.add_runtime_dependency "yaml-safe_load_stream", "~> 0.1"
+
+  spec.add_development_dependency "bundler", ">= 1.17", "< 3.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.7"
+  spec.add_development_dependency "webmock", "~> 3.6.2"
+  spec.add_development_dependency "rubocop", "~> 0.59"
+end

data/lib/k8s-ruby.rb

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

data/lib/k8s/api.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'dry-types'
+require 'dry-struct'
+
+module K8s
+  # Kube API definitions
+  module API
+    # Common Dry::Types used in the API
+    module Types
+      include Dry::Types.module
+    end
+
+    # Common API struct type, handling JSON transforms with symbol keys
+    class Struct < Dry::Struct
+      # input from JSON with string keys
+      transform_keys(&:to_sym)
+
+      # @param data [Hash]
+      # @return [self]
+      def self.from_json(data)
+        new(Yajl::Parser.parse(data))
+      end
+
+      # @return [String]
+      def to_json(*_args)
+        to_hash.to_json
+      end
+    end
+  end
+end

data/lib/k8s/api/metav1.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'k8s/api'
+
+module K8s
+  module API
+    # API types common to all apigroups/versions
+    #
+    # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1
+    module MetaV1
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#TypeMeta
+      class Resource < Struct
+        # XXX: making these optional seems dangerous, but some APIs (GET /api/v1) are missing these
+        attribute :kind, Types::Strict::String.optional.default(nil)
+        attribute :apiVersion, Types::Strict::String.optional.default(nil)
+      end
+    end
+  end
+end
+
+require 'k8s/api/metav1/api_group'
+require 'k8s/api/metav1/api_resource'
+require 'k8s/api/metav1/list'
+require 'k8s/api/metav1/object'
+require 'k8s/api/metav1/status'
+require 'k8s/api/metav1/watch_event'

data/lib/k8s/api/metav1/api_group.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module K8s
+  module API
+    module MetaV1
+      # structured list of available APIGroup versions
+      # groupVersion provided for convenience
+      class APIGroupVersion < Struct
+        attribute :groupVersion, Types::Strict::String
+        attribute :version, Types::Strict::String
+      end
+
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#APIGroup
+      class APIGroup < Struct
+        attribute :name, Types::Strict::String
+        attribute :versions, Types::Strict::Array.of(APIGroupVersion)
+        attribute :preferredVersion, APIGroupVersion
+      end
+
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#APIGroupList
+      class APIGroupList < Resource
+        attribute :groups, Types::Strict::Array.of(APIGroup)
+      end
+    end
+  end
+end

data/lib/k8s/api/metav1/api_resource.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module K8s
+  module API
+    module MetaV1
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#APIResource
+      class APIResource < Struct
+        attribute :name, Types::Strict::String
+        attribute :singularName, Types::Strict::String
+        attribute :namespaced, Types::Strict::Bool
+        attribute :group, Types::Strict::String.optional.default(nil)
+        attribute :version, Types::Strict::String.optional.default(nil)
+        attribute :kind, Types::Strict::String
+        attribute :verbs, Types::Strict::Array.of(Types::Strict::String)
+        attribute :shortNames, Types::Strict::Array.of(Types::Strict::String).optional.default(proc { [] })
+        attribute :categories, Types::Strict::Array.of(Types::Strict::String).optional.default(proc { [] })
+      end
+
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#APIResourceList
+      class APIResourceList < Resource
+        attribute :groupVersion, Types::Strict::String
+        attribute :resources, Types::Strict::Array.of(APIResource)
+      end
+    end
+  end
+end

data/lib/k8s/api/metav1/list.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module K8s
+  module API
+    module MetaV1
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#ListMeta
+      class ListMeta < Struct
+        attribute :selfLink, Types::Strict::String.optional.default(nil)
+        attribute :resourceVersion, Types::Strict::String.optional.default(nil)
+        attribute :continue, Types::Strict::String.optional.default(nil)
+      end
+
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#List
+      class List < Resource
+        attribute :metadata, ListMeta
+        attribute :items, Types::Strict::Array # untyped
+      end
+    end
+  end
+end

data/lib/k8s/api/metav1/object.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'k8s/api/metav1/status'
+
+module K8s
+  module API
+    module MetaV1
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#OwnerReference
+      class OwnerReference < Resource
+        attribute :name, Types::Strict::String
+        attribute :uid, Types::Strict::String
+        attribute :controller, Types::Strict::Bool.optional.default(nil)
+        attribute :blockOwnerDeletion, Types::Strict::Bool.optional.default(nil)
+      end
+
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#Initializer
+      class Initializer < Struct
+        attribute :name, Types::Strict::String
+      end
+
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#Initializers
+      class Initializers < Struct
+        attribute :pending, Initializer
+        attribute :result, Status.optional.default(nil)
+      end
+
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#ObjectMeta
+      class ObjectMeta < Resource
+        attribute :name, Types::Strict::String.optional.default(nil)
+        attribute :generateName, Types::Strict::String.optional.default(nil)
+        attribute :namespace, Types::Strict::String.optional.default(nil)
+        attribute :selfLink, Types::Strict::String.optional.default(nil)
+        attribute :uid, Types::Strict::String.optional.default(nil)
+        attribute :resourceVersion, Types::Strict::String.optional.default(nil)
+        attribute :generation, Types::Strict::Integer.optional.default(nil)
+        attribute :creationTimestamp, Types::DateTime.optional.default(nil)
+        attribute :deletionTimestamp, Types::DateTime.optional.default(nil)
+        attribute :deletionGracePeriodSeconds, Types::Strict::Integer.optional.default(nil)
+        attribute :labels, Types::Strict::Hash.map(Types::Strict::String, Types::Strict::String).optional.default(nil)
+        attribute :annotations, Types::Strict::Hash.map(Types::Strict::String, Types::Strict::String).optional.default(nil)
+        attribute :ownerReferences, Types::Strict::Array.of(OwnerReference).optional.default([])
+        attribute :initializers, Initializers.optional.default(nil)
+        attribute :finalizers, Types::Strict::Array.of(Types::Strict::String).optional.default([])
+        attribute :clusterName, Types::Strict::String.optional.default(nil)
+      end
+
+      # common attributes shared by all object types
+      class ObjectCommon < Resource
+        attribute :metadata, ObjectMeta.optional.default(nil)
+      end
+    end
+  end
+end

data/lib/k8s/api/metav1/status.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module K8s
+  module API
+    module MetaV1
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#Status
+      class Status < Resource
+        # structured cause
+        class Cause < Struct
+          attribute :reason, Types::Strict::String.optional.default(nil)
+          attribute :message, Types::Strict::String.optional.default(nil) # human-readable
+          attribute :field, Types::Strict::String.optional.default(nil) # human-readable
+        end
+
+        # structured details
+        class Details < Struct
+          attribute :name, Types::Strict::String.optional.default(nil)
+          attribute :group, Types::Strict::String.optional.default(nil)
+          attribute :kind, Types::Strict::String.optional.default(nil)
+          attribute :uid, Types::Strict::String.optional.default(nil)
+          attribute :causes, Types::Strict::Array.of(Cause).optional.default(nil)
+          attribute :retryAfterSeconds, Types::Strict::Integer.optional.default(nil)
+        end
+
+        attribute :metadata, ListMeta
+        attribute :status, Types::Strict::String.enum('Success', 'Failure').optional.default(nil)
+        attribute :message, Types::Strict::String.optional.default(nil) # human-readable
+        attribute :reason, Types::Strict::String.optional.default(nil) # machine-readable
+        attribute :details, Details.optional.default(nil)
+        attribute :code, Types::Strict::Integer.optional.default(nil)
+      end
+    end
+  end
+end

data/lib/k8s/api/metav1/watch_event.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../../resource'
+
+module K8s
+  module API
+    module MetaV1
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#WatchEvent
+      class WatchEvent < Resource
+        attribute :type, Types::Strict::String
+        attribute :object, Types::Strict::Hash
+
+        # @return [K8s::Resource]
+        def resource
+          @resource ||= K8s::Resource.new(object)
+        end
+      end
+    end
+  end
+end

data/lib/k8s/api/version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module K8s
+  module API
+    # GET /version
+    class Version < Struct
+      attribute :buildDate, Types::Strict::String # TODO: parse datetime?
+      attribute :compiler, Types::Strict::String
+      attribute :gitCommit, Types::Strict::String
+      attribute :gitTreeState, Types::Strict::String
+      attribute :gitVersion, Types::Strict::String
+      attribute :major, Types::Strict::String
+      attribute :minor, Types::Strict::String
+      attribute :platform, Types::Strict::String
+    end
+  end
+end

data/lib/k8s/api_client.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module K8s
+  # Per-APIGroup/version client.
+  #
+  # Offers access to {ResourceClient} instances for the APIResource types defined in this apigroup/version
+  class APIClient
+    # @param api_version [String] either core version (v1) or apigroup/apiversion (apps/v1)
+    # @return [String]
+    def self.path(api_version)
+      if api_version.include? '/'
+        File.join('/apis', api_version)
+      else
+        File.join('/api', api_version)
+      end
+    end
+
+    # @param transport [K8s::Transport]
+    # @param api_version [String] "group/version" or "version" (core)
+    def initialize(transport, api_version)
+      @transport = transport
+      @api_version = api_version
+    end
+
+    # @return [String]
+    attr_reader :api_version
+
+    # @param path [Array<String>] join path from parts
+    # @return [String]
+    def path(*path)
+      @transport.path(self.class.path(@api_version), *path)
+    end
+
+    # @return [Bool] loaded yet?
+    def api_resources?
+      !!@api_resources
+    end
+
+    # @param api_resources [Array<K8s::API::MetaV1::APIResource>]
+    attr_writer :api_resources
+
+    # Force-update APIResources
+    #
+    # @return [Array<K8s::API::MetaV1::APIResource>]
+    def api_resources!
+      @api_resources = @transport.get(path,
+                                      response_class: K8s::API::MetaV1::APIResourceList).resources
+    end
+
+    # Cached APIResources
+    #
+    # @return [Array<K8s::API::MetaV1::APIResource>]
+    def api_resources
+      @api_resources || api_resources!
+    end
+
+    # @param resource_name [String]
+    # @raise [K8s::Error::UndefinedResource]
+    # @return [K8s::API::MetaV1::APIResource]
+    def find_api_resource(resource_name)
+      found_resource = api_resources.find{ |api_resource| api_resource.name == resource_name }
+      found_resource ||= api_resources!.find{ |api_resource| api_resource.name == resource_name }
+      raise K8s::Error::UndefinedResource, "Unknown resource #{resource_name} for #{@api_version}" unless found_resource
+
+      found_resource
+    end
+
+    # @param resource_name [String]
+    # @param namespace [String, nil]
+    # @raise [K8s::Error::UndefinedResource]
+    # @return [K8s::ResourceClient]
+    def resource(resource_name, namespace: nil)
+      ResourceClient.new(@transport, self, find_api_resource(resource_name), namespace: namespace)
+    end
+
+    # @param resource [K8s::Resource]
+    # @param namespace [String, nil] default if resource is missing namespace
+    # @raise [K8s::Error::UndefinedResource]
+    # @return [K8s::ResourceClient]
+    def client_for_resource(resource, namespace: nil)
+      unless @api_version == resource.apiVersion
+        raise K8s::Error::UndefinedResource, "Invalid apiVersion=#{resource.apiVersion} for #{@api_version} client"
+      end
+
+      found_resource = api_resources.find{ |api_resource| api_resource.kind == resource.kind }
+      found_resource ||= api_resources!.find{ |api_resource| api_resource.kind == resource.kind }
+      raise K8s::Error::UndefinedResource, "Unknown resource kind=#{resource.kind} for #{@api_version}" unless found_resource
+
+      ResourceClient.new(@transport, self, found_resource, namespace: resource.metadata.namespace || namespace)
+    end
+
+    # TODO: skip non-namespaced resources if namespace is given, or ignore namespace?
+    #
+    # @param namespace [String, nil]
+    # @return [Array<K8s::ResourceClient>]
+    def resources(namespace: nil)
+      api_resources.map{ |api_resource|
+        ResourceClient.new(@transport, self, api_resource,
+                           namespace: namespace)
+      }
+    end
+
+    # Pipeline list requests for multiple resource types.
+    #
+    # Returns flattened array with mixed resource kinds.
+    #
+    # @param resources [Array<K8s::ResourceClient>] default is all listable resources for api
+    # @param options @see [K8s::ResourceClient#list]
+    # @return [Array<K8s::Resource>]
+    def list_resources(resources = nil, **options)
+      resources ||= self.resources.select(&:list?)
+
+      ResourceClient.list(resources, @transport, **options)
+    end
+  end
+end

data/lib/k8s/client.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+require 'openssl'
+require 'base64'
+require 'yajl'
+require 'monitor'
+require 'uri'
+
+require 'k8s/util'
+
+require 'k8s/api/metav1'
+require 'k8s/api/version'
+require 'k8s/config'
+require 'k8s/logging'
+require 'k8s/api_client'
+require "k8s/error"
+require 'k8s/resource'
+require 'k8s/resource_client'
+require 'k8s/stack'
+require 'k8s/transport'
+
+module K8s
+  # @param server [String] http/s URL
+  # @param options [Hash] @see Transport.new
+  # @return [K8s::Client]
+  def self.client(server, **options)
+    Client.new(Transport.new(server, **options))
+  end
+
+  # Top-level client wrapper.
+  # Uses a {Transport} instance to talk to the kube API.
+  # Offers access to {APIClient} and {ResourceClient} instances.
+  class Client
+    # @param config [Phraos::Kube::Config]
+    # @param namespace [String] @see #initialize
+    # @param options [Hash] @see Transport.config
+    # @return [K8s::Client]
+    def self.config(config, namespace: nil, **options)
+      new(
+        Transport.config(config, **options),
+        namespace: namespace
+      )
+    end
+
+    # An K8s::Client instance from in-cluster config within a kube pod, using the kubernetes service envs and serviceaccount secrets
+    # @see K8s::Transport#in_cluster_config
+    #
+    # @param namespace [String] default namespace for all operations
+    # @param options [Hash] options passed to transport, @see Transport#in_cluster_config
+    # @return [K8s::Client]
+    # @raise [K8s::Error::Config,Errno::ENOENT,Errno::EACCES]
+    def self.in_cluster_config(namespace: nil, **options)
+      new(Transport.in_cluster_config(**options), namespace: namespace)
+    end
+
+    # Attempts to create a K8s::Client instance automatically using environment variables, existing configuration
+    # files or in cluster configuration.
+    #
+    # Look-up order:
+    #   - KUBE_TOKEN, KUBE_CA, KUBE_SERVER environment variables
+    #   - KUBECONFIG environment variable
+    #   - $HOME/.kube/config file
+    #   - In cluster configuration
+    #
+    # Will raise when no means of configuration is available
+    #
+    # @param options [Hash] default namespace for all operations
+    # @raise [K8s::Error::Config,Errno::ENOENT,Errno::EACCES]
+    # @return [K8s::Client]
+    def self.autoconfig(namespace: nil, **options)
+      if ENV.values_at('KUBE_TOKEN', 'KUBE_CA', 'KUBE_SERVER').none? { |v| v.nil? || v.empty? }
+        unless Base64.decode64(ENV['KUBE_CA']).match?(/CERTIFICATE/)
+          raise ArgumentError, 'KUBE_CA does not seem to be base64 encoded'
+        end
+
+        begin
+          token = options[:auth_token] || Base64.strict_decode64(ENV['KUBE_TOKEN'])
+        rescue ArgumentError
+          raise ArgumentError, 'KUBE_TOKEN does not seem to be base64 encoded'
+        end
+
+        configuration = K8s::Config.build(server: ENV['KUBE_SERVER'], ca: ENV['KUBE_CA'], auth_token: token)
+      elsif !ENV['KUBECONFIG'].to_s.empty?
+        configuration = K8s::Config.from_kubeconfig_env(ENV['KUBECONFIG'])
+      else
+        found_config = [
+          File.join(Dir.home, '.kube', 'config'),
+          '/etc/kubernetes/admin.conf',
+          '/etc/kubernetes/kubelet.conf'
+        ].find { |f| File.exist?(f) && File.readable?(f) }
+
+        configuration = K8s::Config.load_file(found_config) if found_config
+      end
+
+      if configuration
+        config(configuration, namespace: namespace, **options)
+      else
+        in_cluster_config(namespace: namespace, **options)
+      end
+    end
+
+    include MonitorMixin
+
+    attr_reader :transport
+
+    # @param transport [K8s::Transport]
+    # @param namespace [String, nil] default namespace for all operations
+    def initialize(transport, namespace: nil)
+      @transport = transport
+      @namespace = namespace
+
+      @api_clients = {}
+      super()
+    end
+
+    # @raise [K8s::Error]
+    # @return [K8s::API::Version]
+    def version
+      @version ||= @transport.version
+    end
+
+    # @param api_version [String] "group/version" or "version" (core)
+    # @return [APIClient]
+    def api(api_version = 'v1')
+      @api_clients[api_version] ||= APIClient.new(@transport, api_version)
+    end
+
+    # Force-update /apis cache.
+    # Required if creating new CRDs/apiservices.
+    #
+    # @return [Array<String>]
+    def api_groups!
+      synchronize do
+        @api_groups = @transport.get(
+          '/apis',
+          response_class: K8s::API::MetaV1::APIGroupList
+        ).groups.flat_map{ |api_group| api_group.versions.map(&:groupVersion) }
+
+        @api_clients.clear
+      end
+
+      @api_groups
+    end
+
+    # Cached /apis preferred group apiVersions
+    # @return [Array<String>]
+    def api_groups
+      @api_groups || api_groups!
+    end
+
+    # @param api_versions [Array<String>] defaults to all APIs
+    # @param prefetch_resources [Boolean] prefetch any missing api_resources for each api_version
+    # @param skip_missing [Boolean] return APIClient without api_resources? if 404
+    # @return [Array<APIClient>]
+    def apis(api_versions = nil, prefetch_resources: false, skip_missing: false)
+      api_versions ||= ['v1'] + api_groups
+
+      if prefetch_resources
+        # api groups that are missing their api_resources
+        api_paths = api_versions
+                    .uniq
+                    .reject{ |api_version| api(api_version).api_resources? }
+                    .map{ |api_version| APIClient.path(api_version) }
+
+        # load into APIClient.api_resources=
+        begin
+          @transport.gets(*api_paths, response_class: K8s::API::MetaV1::APIResourceList, skip_missing: skip_missing).each do |api_resource_list|
+            api(api_resource_list.groupVersion).api_resources = api_resource_list.resources if api_resource_list
+          end
+        rescue K8s::Error::NotFound, K8s::Error::ServiceUnavailable # rubocop:disable Lint/HandleExceptions
+          # kubernetes api is in unstable state
+          # because this is only performance optimization, better to skip prefetch and move on
+        end
+      end
+
+      api_versions.map{ |api_version| api(api_version) }
+    end
+
+    # @param namespace [String, nil]
+    # @return [Array<K8s::ResourceClient>]
+    def resources(namespace: nil)
+      apis(prefetch_resources: true).map { |api|
+        begin
+          api.resources(namespace: namespace)
+        rescue K8s::Error::ServiceUnavailable, K8s::Error::NotFound
+          []
+        end
+      }.flatten
+    end
+
+    # Pipeline list requests for multiple resource types.
+    #
+    # Returns flattened array with mixed resource kinds.
+    #
+    # @param resources [Array<K8s::ResourceClient>] default is all listable resources for api
+    # @param options @see K8s::ResourceClient#list
+    # @return [Array<K8s::Resource>]
+    def list_resources(resources = nil, **options)
+      cached_clients = @api_clients.size.positive?
+      resources ||= self.resources.select(&:list?)
+
+      begin
+        ResourceClient.list(resources, @transport, **options)
+      rescue K8s::Error::NotFound
+        raise unless cached_clients
+
+        cached_clients = false
+        api_groups!
+        retry
+      end
+    end
+
+    # @param resource [K8s::Resource]
+    # @param namespace [String, nil] default if resource is missing namespace
+    # @raise [K8s::Error::NotFound] API Group does not exist
+    # @raise [K8s::Error::UndefinedResource]
+    # @return [K8s::ResourceClient]
+    def client_for_resource(resource, namespace: nil)
+      api(resource.apiVersion).client_for_resource(resource, namespace: namespace)
+    end
+
+    # @param resource [K8s::Resource]
+    # @return [K8s::Resource]
+    def create_resource(resource)
+      client_for_resource(resource).create_resource(resource)
+    end
+
+    # @param resource [K8s::Resource]
+    # @return [K8s::Resource]
+    def get_resource(resource)
+      client_for_resource(resource).get_resource(resource)
+    end
+
+    # Returns nils for any resources that do not exist.
+    # This includes custom resources that were not yet defined.
+    #
+    # @param resources [Array<K8s::Resource>]
+    # @return [Array<K8s::Resource, nil>] matching resources array 1:1
+    def get_resources(resources)
+      # prefetch api resources, skip missing APIs
+      resource_apis = apis(resources.map(&:apiVersion), prefetch_resources: true, skip_missing: true)
+
+      # map each resource to excon request options, or nil if resource is not (yet) defined
+      requests = resources.zip(resource_apis).map{ |resource, api_client|
+        next nil unless api_client.api_resources?
+
+        resource_client = api_client.client_for_resource(resource)
+
+        {
+          method: 'GET',
+          path: resource_client.path(resource.metadata.name, namespace: resource.metadata.namespace),
+          response_class: resource_client.resource_class
+        }
+      }
+
+      # map non-nil requests to response objects, or nil for nil request options
+      Util.compact_map(requests) { |reqs|
+        @transport.requests(*reqs, skip_missing: true)
+      }
+    end
+
+    # @param resource [K8s::Resource]
+    # @return [K8s::Resource]
+    def update_resource(resource)
+      client_for_resource(resource).update_resource(resource)
+    end
+
+    # @param resource [K8s::Resource]
+    # @param options [Hash]
+    # @see ResourceClient#delete for options
+    # @return [K8s::Resource]
+    def delete_resource(resource, **options)
+      client_for_resource(resource).delete_resource(resource, **options)
+    end
+
+    # @param resource [K8s::Resource]
+    # @param attrs [Hash]
+    # @return [K8s::Client]
+    def patch_resource(resource, attrs)
+      client_for_resource(resource).json_patch(resource.metadata.name, attrs)
+    end
+  end
+end