k8s_internal_lb 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 300b5f39966679025bdaedf677e720a095c7674d68e695004c6dc7ed6fac59d6
+  data.tar.gz: c2faa51598fb6d92230bcbb21f1b402f37885e2f64182231f0ffd17158ea4b83
+SHA512:
+  metadata.gz: c306f3cb2a0052cc9938d5820d1c88e4b5d187cff0b66570dd48d159f884a581e1b24957c800cb6bdb572ebd7718267b27873a38841ec23f406915d910cebb83
+  data.tar.gz: ba80dde312f844a5babaff213ae5745e352fa65d0763ef07b06f02383997d1822162a178e0ce762e7babf3432a3b2d2ef86b0f5f2fc4997f4874b220ca8acf2b

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## Version 1.0.0 - 2020-03-13
+
+Marking the current code as stable as it has been running successfully for half a year.
+
+Still need to write up an example for doing endpoint discovery, but the code should support that fine as-is.

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Alexander Olofsson
+
+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,27 @@
+# Kubernetes Internal Load-balancer
+
+This is a Ruby application to configure your K8s cluster to work as a load-balancer, by utilizing the ingress and service/endpoint resources.
+
+The common flow is to set up an ingress to talk to a ClusterIP service without a selector, and letting this application populate the endpoints list.
+
+## Installation
+
+Install it yourself as:
+
+    $ gem install k8s_internal_lb
+
+## Usage
+
+Run the application by specifying a configuration rb file, it can run in both one-shot mode as well as continuously.
+
+    $ k8s_internal_lb
+
+Check the provided [examples](examples/) for ideas on how to configure the system.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ananace/k8s_internal_lb
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/k8s_internal_lb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'k8s_internal_lb'
+require 'optparse'
+require 'ostruct'
+
+options = OpenStruct.new
+parser = OptParse.new do |opts|
+  opts.banner = 'Usage: k8s_internal_lb [options...]'
+
+  opts.on('-c', '--config=FILE', 'Run with a specific configuration file, can be specified multiple times') do |file|
+    raise ArgumentError, 'Not a valid path' unless File.exist? file
+
+    (options.config_files ||= []) << file
+  end
+
+  opts.on('-v', '--verbose', 'Increase log level') do
+    options.verbose = true
+  end
+
+  opts.on('-h', '--help', 'Print this text and exit') do
+    puts parser
+    exit
+  end
+
+  opts.on('-V', '--version', 'Print the application version and exit') do
+    puts "K8sInternalLb v#{K8sInternalLb::VERSION}"
+    exit
+  end
+end
+parser.parse!
+
+if options.config_files&.any?
+  options.config_files.each do |file|
+    if File.directory? file
+      Dir.entries(file).select { |f| f.end_with? '.rb' }.each do |f|
+        load File.join(file, f)
+      end
+    else
+      load file
+    end
+  end
+else
+  load '/etc/k8s_internal_lb.rb' if File.exist? '/etc/k8s_internal_lb.rb'
+  load './config.rb' if File.exist? 'config.rb'
+end
+
+K8sInternalLb.debug! if options.verbose
+
+client = K8sInternalLb::Client.instance
+raise 'No services loaded, aborting' if client.services.empty?
+
+client.run

data/lib/k8s_internal_lb.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'k8s_internal_lb/version'
+require 'kubeclient'
+
+autoload :Logging, 'logging'
+
+module K8sInternalLb
+  autoload :Address, 'k8s_internal_lb/address'
+  autoload :Client, 'k8s_internal_lb/client'
+  autoload :Endpoint, 'k8s_internal_lb/endpoint'
+  autoload :Port, 'k8s_internal_lb/port'
+  autoload :Service, 'k8s_internal_lb/service'
+
+  module Services
+    autoload :HTTP, 'k8s_internal_lb/services/http'
+    autoload :TCP, 'k8s_internal_lb/services/tcp'
+  end
+
+  class Error < StandardError; end
+
+  def self.configure!(&block)
+    block.call Client.instance
+  end
+
+  def self.debug!
+    logger.level = :debug
+  end
+
+  def self.logger
+    @logger ||= ::Logging.logger[self].tap do |logger|
+      logger.add_appenders ::Logging.appenders.stdout
+      logger.level = :info
+    end
+  end
+end
+
+K8sInternalLb.logger # Set up logger

data/lib/k8s_internal_lb/address.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+autoload :Resolv, 'resolv'
+
+module K8sInternalLb
+  class Address
+    attr_reader :hostname, :ip
+
+    def initialize(hostname: nil, ip: nil, fqdn: nil)
+      raise ArgumentError, 'missing keyword: ip' if fqdn.nil? && ip.nil?
+
+      if fqdn
+        ip ||= Resolv.getaddress fqdn
+        hostname ||= fqdn.split('.').first
+      end
+
+      self.hostname = hostname
+      self.ip = ip
+    end
+
+    def hostname=(hostname)
+      if hostname.nil? || hostname.empty?
+        @hostname = nil
+        return
+      end
+
+      hostname = hostname.to_s.downcase
+
+      raise ArgumentError, 'Hostname is not allowed to be an FQDN' if hostname.include? '.'
+
+      @hostname = hostname
+    end
+
+    def ip=(ip)
+      ip = IPAddr.new(ip.to_s) unless ip.is_a? IPAddr
+
+      @ip = ip
+    end
+
+    # JSON encoding
+    def to_json(*params)
+      {
+        hostname: hostname,
+        ip: ip
+      }.compact.to_json(*params)
+    end
+
+    # Equality overriding
+    def ==(other)
+      return unless other.respond_to?(:hostname) && other.respond_to?(:ip)
+
+      hostname == other.hostname && ip == other.ip
+    end
+
+    def hash
+      [hostname, ip].hash
+    end
+
+    def eql?(other)
+      self == other
+    end
+  end
+end

data/lib/k8s_internal_lb/client.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module K8sInternalLb
+  class Client
+    TIMESTAMP_ANNOTATION = 'com.github.ananace.k8s-internal-lb/timestamp'
+
+    attr_accessor :kubeclient_options, :namespace, :auth_options, :ssl_options, :server, :api_version
+    attr_accessor :sleep_duration
+    attr_reader :services
+
+    def self.instance
+      @instance ||= Client.new
+    end
+
+    def in_cluster?
+      # FIXME: Better detection, actually look for the necessary cluster components
+      Dir.exist? '/var/run/secrets/kubernetes.io'
+    end
+
+    def add_service(name, **data)
+      service = nil
+
+      if name.is_a? Service
+        service = name
+        name = service.name
+      else
+        data[:name] ||= name
+        service = Service.create(**data)
+      end
+
+      k8s_service = get_endpoint(service)
+      raise 'Unable to find service' if k8s_service.nil?
+
+      if k8s_service.metadata&.annotations&.to_hash&.key? TIMESTAMP_ANNOTATION
+        ts = k8s_service.annotations[TIMESTAMP_ANNOTATION]
+        if ts =~ /\A\d+\z/
+          service.last_update = Time.at(ts.to_i)
+        else
+          service.last_update = Time.parse(ts)
+        end
+      end
+
+      @services[name] = service
+    end
+
+    def remove_service(name)
+      @services.delete name
+    end
+
+    def run
+      loop do
+        sleep_duration = @sleep_duration
+
+        @services.each do |name, service|
+          logger.debug "Checking #{name} for interval"
+
+          diff = (Time.now - service.last_update)
+          until_next = service.interval - diff
+          sleep_duration = until_next if until_next.positive? && until_next < sleep_duration
+
+          next unless diff >= service.interval
+
+          logger.debug "Interval reached on #{name}, running update"
+          update(service)
+        end
+
+        sleep sleep_duration
+      end
+    end
+
+    private
+
+    def initialize
+      @sleep_duration = 5
+
+      @kubeclient_options = {}
+      @auth_options = {}
+      @ssl_options = {}
+
+      @namespace = nil
+      @server = nil
+      @api_version = 'v1'
+
+      @services = {}
+
+      return unless in_cluster?
+
+      @server = 'https://kubernetes.default.svc'
+      @namespace ||= File.read('/var/run/secrets/kubernetes.io/serviceaccount/namespace')
+      if @auth_options.empty?
+        @auth_options = {
+          bearer_token_file: '/var/run/secrets/kubernetes.io/serviceaccount/token'
+        }
+      end
+
+      return unless File.exist?('/var/run/secrets/kubernetes.io/serviceaccount/ca.crt')
+
+      @ssl_options[:ca_file] = '/var/run/secrets/kubernetes.io/serviceaccount/ca.crt'
+    end
+
+    def logger
+      @logger ||= Logging::Logger[self]
+    end
+
+    def update(service, force: false)
+      service = @services[service] unless service.is_a? Service
+
+      old_endpoints = service.endpoints.dup
+      service.last_update = Time.now
+      service.update
+      endpoints = service.endpoints
+
+      return true if old_endpoints == endpoints && !force
+
+      logger.info "Active endpoints have changed for #{service.name}, updating cluster data to #{service.to_subsets.to_json}"
+
+      kubeclient.patch_endpoint(
+        service.name,
+        {
+          metadata: {
+            annotations: {
+              TIMESTAMP_ANNOTATION => Time.now.to_s
+            }
+          },
+          subsets: service.to_subsets
+        },
+        service.namespace || namespace
+      )
+    rescue StandardError => e
+      raise e
+    end
+
+    def get_service(service)
+      kubeclient.get_service(service.name, service.namespace || namespace)
+    rescue Kubeclient::ResourceNotFoundError
+      nil
+    end
+
+    def get_endpoint(service)
+      kubeclient.get_endpoint(service.name, service.namespace || namespace)
+    rescue Kubeclient::ResourceNotFoundError
+      nil
+    end
+
+    def kubeclient
+      @kubeclient ||= Kubeclient::Client.new(
+        server,
+        api_version,
+        auth_options: auth_options,
+        ssl_options: ssl_options,
+        **kubeclient_options
+      )
+    end
+  end
+end

data/lib/k8s_internal_lb/endpoint.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module K8sInternalLb
+  class Endpoint
+    attr_reader :address, :port, :status
+
+    def initialize(address:, port:, status:)
+      self.address = address
+      self.port = port
+      self.status = status
+    end
+
+    def address=(address)
+      raise ArgumentError, 'Address must be an Address object' unless address.is_a? Address
+
+      @address = address
+    end
+
+    def port=(port)
+      raise ArgumentError, 'Port must be a Port object' unless port.is_a? Port
+
+      @port = port
+    end
+
+    def status=(status)
+      status = status ? :ready : :not_ready if [true, false].include? status
+      status = status.to_s.downcase.to_sym
+
+      raise ArgumentError, 'Status must be one of :ready, :not_ready' unless %i[ready not_ready].include? status
+
+      @status = status
+    end
+
+    def ready?
+      @status == :ready
+    end
+
+    def not_ready?
+      @status == :not_ready
+    end
+
+    # Equality overriding
+    def ==(other)
+      return unless other.respond_to?(:address) && other.respond_to?(:port) && other.respond_to?(:status)
+
+      address == other.address && port == other.port && status == other.status
+    end
+
+    def hash
+      [address, port, status].hash
+    end
+
+    def eql?(other)
+      self == other
+    end
+  end
+end

data/lib/k8s_internal_lb/port.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module K8sInternalLb
+  class Port
+    attr_reader :protocol, :port
+    attr_accessor :name
+
+    def initialize(name: nil, port:, protocol: :TCP)
+      name = nil if name&.empty?
+      @name = name
+      self.port = port
+      self.protocol = protocol
+    end
+
+    def protocol=(protocol)
+      protocol = protocol.to_s.upcase.to_sym
+
+      raise ArgumentError, 'Protocol must be one of :TCP, :UDP, :SCTP' unless %i[TCP UDP SCTP].include? protocol
+
+      @protocol = protocol
+    end
+
+    def port=(port)
+      port = port.to_i unless port.is_a? Integer
+
+      raise ArgumentError, 'Port must be a valid port number' unless (1..65_535).include? port
+
+      @port = port
+    end
+
+    def tcp?
+      protocol == :TCP
+    end
+
+    def udp?
+      protocol == :UDP
+    end
+
+    def sctp?
+      protocol == :SCTP
+    end
+
+    # JSON encoding
+    def to_json(*params)
+      {
+        name: name,
+        port: port,
+        protocol: protocol
+      }.compact.to_json(*params)
+    end
+
+    # Equality overriding
+    def ==(other)
+      return unless other.respond_to?(:name) && other.respond_to?(:port) && other.respond_to?(:protocol)
+
+      name == other.name && port == other.port && protocol == other.protocol
+    end
+
+    def hash
+      [name, port, protocol].hash
+    end
+
+    def eql?(other)
+      self == other
+    end
+  end
+end

data/lib/k8s_internal_lb/service.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module K8sInternalLb
+  class Service
+    attr_reader :name
+    attr_accessor :namespace, :interval, :last_update, :endpoints, :ports
+
+    def self.create(type: :TCP, **params)
+      raise ArgumentError, 'Must specify service type' if type.nil?
+
+      klass = Services.const_get type
+      raise ArgumentError, 'Unknown service type' if klass.nil?
+
+      klass.new(**params)
+    end
+
+    def logger
+      @logger ||= Logging::Logger[self]
+    end
+
+    def update
+      raise NotImplementedError
+    end
+
+    def to_subsets
+      grouped = endpoints.group_by(&:port)
+
+      # TODO: Find all port combinations that result in the same list of ready
+      #       and not-ready addresses, and combine them into a single pair of
+      #       multiple ports.
+      #
+      # {
+      #   1 => { active: [A, B], inactive: [C] },
+      #   2 => { active: [A, B], inactive: [C] }
+      # }
+      # =>
+      # {
+      #   [1,2] => { active: [A, B], inactive: [C] }
+      # }
+
+      grouped = grouped.map do |p, g|
+        {
+          addresses: g.select(&:ready?).map(&:address),
+          notReadyAddresses: g.select(&:not_ready?).map(&:address),
+          ports: [p]
+        }
+      end
+
+      # grouped = grouped.group_by { |s| s[:addresses] + s[:notReadyAddresses] }
+      #                  .map do |_, s|
+      #   v = s.first
+      #
+      #   v[:ports] = s.reduce([]) { |sum, e| sum << e[:ports] }
+      #
+      #   v
+      # end
+
+      grouped
+    end
+
+    protected
+
+    def initialize(name:, namespace: nil, ports:, interval: 10, **_params)
+      raise ArgumentError, 'Ports must be a list of Port objects' unless ports.is_a?(Array) && ports.all? { |p| p.is_a? Port }
+      raise ArgumentError, 'Interval must be a positive number' unless interval.is_a?(Numeric) && interval.positive?
+
+      @name = name
+      @namespace = namespace
+      @ports = ports
+      @interval = interval
+      @last_update = Time.at(0)
+      @endpoints = []
+    end
+  end
+end

data/lib/k8s_internal_lb/services/http.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+module K8sInternalLb
+  module Services
+    class HTTP < Service
+      attr_accessor :timeout, :http_opts
+      attr_reader :addresses, :method, :expects
+
+      def initialize(addresses:, method: :head, expects: :success, timeout: 5, http_opts: {}, **params)
+        params[:ports] ||= []
+        super
+
+        self.method = method
+        self.expects = expects
+        self.addresses = addresses
+
+        @timeout = timeout
+        @http_opts = http_opts
+
+        @address_hash = nil
+        @port_hash = nil
+      end
+
+      def ports
+        # Ensure data is recalculated if addresses or ports change
+        address_hash = @addresses.hash
+        port_hash = super.hash
+        @http_ports = nil if @address_hash != address_hash
+        @http_ports = nil if @port_hash != port_hash
+        @address_hash = address_hash
+        @port_hash = port_hash
+
+        @http_ports ||= begin
+          http_ports = @addresses.map { |addr| Port.new(port: addr.port) }.uniq
+        
+          # Copy port names over where appropriate
+          super.each do |port|
+            http_port = http_ports.find { |hp| hp.port == port.port }
+            next unless http_port
+
+            http_port.name = port.name
+          end
+
+          http_ports
+        end
+      end
+
+      def addresses=(addresses)
+        addresses = addresses.map do |addr|
+          addr = URI(addr)
+
+          addr.path = '/' if addr.path.empty?
+
+          addr
+        end
+
+        @addresses = addresses
+      end
+
+      def method=(method)
+        raise ArgumentError, 'Invalid HTTP request method' unless %i[get get2 head head2 options post put].include? method
+
+        @method = method
+      end
+
+      def expects=(expects)
+        raise ArgumentError, 'Invalid expects type' unless expects == :success || [Integer, Proc].include?(expects.class)
+
+        @expects = expects
+      end
+
+      def update
+        @endpoints = addresses.map do |addr|
+          available = false
+
+          begin
+            ssl = addr.scheme == 'https'
+
+            Net::HTTP.start(addr.host, addr.port, use_ssl: ssl, read_timeout: timeout, **http_opts) do |h|
+              resp = h.send(@method, addr.path)
+              logger.debug "#{addr} - #{resp.inspect}"
+
+              available = if @expects == :success
+                            resp.is_a? Net::HTTPSuccess
+                          elsif @expects.is_a? Numeric
+                            resp.code == @expects
+                          elsif @expects.is_a? Proc
+                            @expects.call(resp)
+                          end
+            end
+          rescue StandardError => e
+            logger.debug "#{addr} - #{e.class}: #{e.message}\n#{e.backtrace[0, 20].join("\n")}"
+            available = false # Assume failures to mean inaccessibility
+          end
+
+          e_addr = Address.new fqdn: addr.host
+          Endpoint.new address: e_addr, port: ports.find { |p| p.port == addr.port }, status: available
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/k8s_internal_lb/services/tcp.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'timeout'
+
+module K8sInternalLb
+  module Services
+    class TCP < Service
+      attr_accessor :addresses, :timeout
+
+      def initialize(addresses:, timeout: 1, **params)
+        super
+
+        @addresses = addresses
+        @timeout = timeout
+      end
+
+      def update
+        raise 'No TCP ports provided' if ports.select(&:tcp?).empty?
+
+        @endpoints = addresses.map do |addr|
+          ports.select(&:tcp?).map do |port|
+            available = \
+              begin
+                Timeout.timeout(timeout) do
+                  begin
+                    TCPSocket.new(addr.ip.to_s, port.port).close
+                    true
+                  rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+                    false
+                  end
+                end
+              rescue Timeout::Error
+                false
+              end
+
+            Endpoint.new address: addr, port: port, status: available
+          end
+        end.flatten
+
+        true
+      end
+    end
+  end
+end

data/lib/k8s_internal_lb/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module K8sInternalLb
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: k8s_internal_lb
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Alexander Olofsson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: kubeclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A ruby application for setting up your k8s cluster as a load balancer.
+email:
+- alexander.olofsson@liu.se
+executables:
+- k8s_internal_lb
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- LICENSE.md
+- README.md
+files:
+- CHANGELOG.md
+- LICENSE.md
+- README.md
+- bin/k8s_internal_lb
+- lib/k8s_internal_lb.rb
+- lib/k8s_internal_lb/address.rb
+- lib/k8s_internal_lb/client.rb
+- lib/k8s_internal_lb/endpoint.rb
+- lib/k8s_internal_lb/port.rb
+- lib/k8s_internal_lb/service.rb
+- lib/k8s_internal_lb/services/http.rb
+- lib/k8s_internal_lb/services/tcp.rb
+- lib/k8s_internal_lb/version.rb
+homepage: https://github.com/ananace/k8s_internal_lb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: A ruby application for setting up your k8s cluster as a load balancer.
+test_files: []