kuby-cert-manager 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33ffd08b56cd673600ba896fbe25ea0c35b27f4510bc5b477b8e486c776f5259
-  data.tar.gz: 506285903110571e6bd4df69e976a6a5f680b4be6fe4f14606eafc681b5224cf
+  metadata.gz: 1d974571de438574b816bd970f7f567433ad5c167d8069fb3143115aee657736
+  data.tar.gz: d9a1f92b7dfe9a736334ad65da71c57310423e93c244e6b3e0715ca9bf0679c2
 SHA512:
-  metadata.gz: 7a3b841947207ea6613b9ae0e9f641169ff77aa7cda63c3abcae18dd467c7e29128bdda4b1a0a754561e75bce7fd397d32fb24b51e23ab2e61946ed46e83ead5
-  data.tar.gz: 88db549b59322273dd4d5b353c7893596da42fd9edd0ccb719d9c21915e6e90679ebd20c91196080d5aaffa657c25064551700059c95e3411a5c58e4142f3b22
+  metadata.gz: 6f1c3a6da89760f0c1de9932294bdd3be904f26a9ff7c1882504bc6353f3e9ada5d2d936c04a6df78d25404231fdb54de966ff5205f79cedaea0b69c6a0dbe9d
+  data.tar.gz: bdb83d06b860a4aab731815fadebf341bbc5ac1e93a4f97ca4801c9271373631b3ba52a4fcf861889a0a5d2f6d35ae3ad477573ddd8b58c948521b62d004159d

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.4.0
+* Upgrade to cert-manager v1.7.2.
+* Generate DSL files using schema pulled from Kind cluster instead of the hand-rolled ones we had before.
+* Use tapioca to pull in type annotations for gems.
+* Use parlour to publish type annotations in the rbi/ directory.
+
 ## 0.3.0
 * Conform to new plugin architecture.
 * Accept `environment` instead of `definition` instances.

data/Gemfile

@@ -2,17 +2,21 @@ source 'https://rubygems.org'
 
 gemspec
 
-# Declare platform-specific gems here so they install correctly.
-# See: https://github.com/rubygems/rubygems/issues/3646
-gem 'helm-rb'
-
 group :development, :test do
   gem 'kuby-core', path: '../kuby-core'
-  gem 'kuby-kube-db', path: '../kuby-kube-db'
+  gem 'kuby-crdb'
+  gem 'kube-dsl', '>= 0.7.3', '< 1'
+  gem 'kind-rb'
   gem 'pry-byebug'
   gem 'rake'
 end
 
+group :development do
+  gem 'sorbet'
+  gem 'tapioca', '~> 0.7'
+  gem 'parlour', '~> 6.0'
+end
+
 group :test do
   gem 'rspec', '~> 3.0'
 end

data/Rakefile

@@ -2,6 +2,7 @@ require 'bundler'
 require 'rspec/core/rake_task'
 require 'rubygems/package_task'
 
+require 'sorbet-runtime'
 require 'kuby/cert-manager'
 
 Bundler::GemHelper.install_tasks
@@ -12,3 +13,158 @@ desc 'Run specs'
 RSpec::Core::RakeTask.new do |t|
   t.pattern = './spec/**/*_spec.rb'
 end
+
+task generate: [:schemagen, :codegen]
+
+task :schemagen do
+  require 'base64'
+  require 'json'
+  require 'kind-rb'
+  require 'net/http'
+  require 'uri'
+  require 'yaml'
+
+  # delete first just in case
+  system("#{KindRb.executable} delete cluster --name kuby-cert-manager")
+  system("#{KindRb.executable} create cluster --name kuby-cert-manager")
+
+  system("kubectl apply -f https://github.com/jetstack/cert-manager/releases/download/v#{Kuby::CertManager::Plugin::CERT_MANAGER_VERSION}/cert-manager.yaml")
+
+  cluster_name = 'kind-kuby-cert-manager'
+  kubeconfig = YAML.load_file(File.join(Dir.home, '.kube', 'config'))
+  cluster = kubeconfig['clusters'].find { |cluster| cluster['name'] == cluster_name }
+  ca_cert_data = Base64.decode64(cluster.dig(*%w(cluster certificate-authority-data)))
+
+  cert_store = OpenSSL::X509::Store.new
+  cert_store.add_cert(OpenSSL::X509::Certificate.new(ca_cert_data))
+  server = URI.parse(cluster.dig(*%w(cluster server)))
+
+  http = Net::HTTP.new(server.host, server.port).tap do |http|
+    http.use_ssl = true
+    http.cert_store = cert_store
+    http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+  end
+
+  token = nil
+  STDOUT.write("Getting API token from cluster...")
+
+  loop do
+    secrets = JSON.parse(`kubectl --context #{cluster_name} get secrets -o json`)
+    secret = secrets['items'].find do |secret|
+      secret.dig(*%w(metadata annotations kubernetes.io/service-account.name)) == 'default'
+    end
+
+    if secret
+      token = Base64.decode64(secret.dig(*%w(data token)))
+      puts ' done'
+      break
+    else
+      STDOUT.write('.')
+      sleep 1
+    end
+  end
+
+  get = Net::HTTP::Get.new('/openapi/v2')
+  get['Authorization'] = "Bearer #{token}"
+
+  crds = []
+  schema = nil
+  STDOUT.write("Requesting OpenAPI v2 schema from cluster...")
+
+  loop do
+    response = http.request(get)
+    schema = JSON.parse(response.body)
+
+    crds = schema['definitions'].each_with_object({}) do |(id, data), memo|
+      memo[id] = data if id.start_with?('io.cert-manager')
+    end
+
+    if crds.empty?
+      STDOUT.write('.')
+      sleep 1
+    else
+      puts ' done'
+      break
+    end
+  end
+
+  FileUtils.rm_rf('vendor')
+  FileUtils.mkdir('vendor')
+
+  schema = schema.merge('definitions' => crds)
+  File.write(File.join('vendor', 'open_api.json'), schema.to_json)
+
+  puts 'Pulling openapi2jsonschema Docker image'
+  system('docker pull garethr/openapi2jsonschema')
+
+  puts 'Converting OpenAPI format to JSON schema format'
+  system(<<~END)
+    docker run --rm \
+      -v #{File.expand_path('vendor')}:/usr/local/scratch \
+      garethr/openapi2jsonschema \
+      --kubernetes --output /usr/local/scratch/json_schema /usr/local/scratch/open_api.json
+  END
+
+  puts "Cleaning up"
+  system("#{KindRb.executable} delete cluster --name kuby-cert-manager")
+end
+
+task :codegen do
+  require 'pry-byebug'
+
+  require 'dry/inflector'
+  require 'fileutils'
+
+  # delete anything that should be re-generated
+  FileUtils.rm_rf('./lib/kuby/cert-manager/dsl.rb')
+  FileUtils.rm_rf('./lib/kuby/cert-manager/dsl')
+  FileUtils.rm_rf('./lib/kuby/cert-manager/entrypoint.rb')
+  FileUtils.rm_rf('./sorbet/rbi/kuby/cert-manager')
+  FileUtils.mkdir_p('./lib/kuby/cert-manager/dsl')
+
+  local_json_schema_path = 'vendor/json_schema'
+
+  generator = KubeDSL::Generator.new(
+    schema_dir: local_json_schema_path,
+    output_dir: File.join('lib'),
+    autoload_prefix: File.join('kuby', 'cert-manager', 'dsl'),
+    dsl_namespace: ['Kuby', 'CertManager', 'DSL'],
+    entrypoint_namespace: ['Kuby', 'CertManager'],
+    inflector: Dry::Inflector.new do |inflections|
+      inflections.acronym('DSL')
+    end
+  )
+
+  generator.builder.register_resolver('io.k8s') do |ref_str, builder|
+    external_ref = ::KubeDSL::ExternalRef.new(
+      ref_str,
+      ['KubeDSL', 'DSL'],
+      builder.inflector,
+      builder.schema_dir,
+      builder.autoload_prefix,
+      builder.serialize_handlers
+    )
+
+    ns = external_ref.ruby_namespace + [external_ref.kind]
+    exists = ns.inject(Object) { |mod, n| mod.const_get(n, false) } rescue false
+    exists ? external_ref : builder.parse_ref(ref_str)
+  end
+
+  generator.builder.register_serialize_handler('cert-manager', 'v1', 'IssuerSpec', 'selfSigned') do |field, inflector|
+    "#{field.send(:ruby_safe_name)}_present? ? ::KubeDSL::AllowBlank.new(#{field.serialize_call(inflector)}) : nil"
+  end
+
+  generator.builder.register_serialize_handler('cert-manager', 'v1', 'ClusterIssuerSpec', 'selfSigned') do |field, inflector|
+    "#{field.send(:ruby_safe_name)}_present? ? ::KubeDSL::AllowBlank.new(#{field.serialize_call(inflector)}) : nil"
+  end
+
+  generator.generate_resource_files
+  generator.generate_autoload_files
+  generator.generate_entrypoint_file do |resource, ns|
+    # only generate entrypoint methods for resources defined at the top-level, i.e.
+    # not resources defined inside other resources
+    !resource.ref.inline?
+  end
+
+  FileUtils.rm_rf(File.join('lib', 'kuby.rb'))
+end

data/kuby-cert-manager.gemspec

@@ -12,9 +12,8 @@ Gem::Specification.new do |s|
 
   s.platform = Gem::Platform::RUBY
 
-  s.add_dependency 'helm-cli', '~> 0.1'
   s.add_dependency 'kube-dsl', '~> 0.1'
 
   s.require_path = 'lib'
-  s.files = Dir['{lib,spec}/**/*', 'Gemfile', 'LICENSE', 'CHANGELOG.md', 'README.md', 'Rakefile', 'kuby-cert-manager.gemspec']
+  s.files = Dir['{lib,spec,rbi}/**/*', 'Gemfile', 'LICENSE', 'CHANGELOG.md', 'README.md', 'Rakefile', 'kuby-cert-manager.gemspec']
 end

data/lib/kuby/cert-manager/dsl/acme/v1/challenge.rb

@@ -0,0 +1,37 @@
+# typed: true
+
+module Kuby
+  module CertManager
+    module DSL
+      module Acme
+        module V1
+          class Challenge < ::KubeDSL::DSLObject
+            object_field(:status) { Kuby::CertManager::DSL::Acme::V1::ChallengeStatus.new }
+            object_field(:spec) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpec.new }
+            value_field :api_version
+            object_field(:metadata) { KubeDSL::DSL::Meta::V1::ObjectMeta.new }
+
+            validates :status, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeStatus }
+            validates :spec, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpec }
+            validates :api_version, field: { format: :string }, presence: false
+            validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ObjectMeta }
+
+            def serialize
+              {}.tap do |result|
+                result[:status] = status.serialize
+                result[:kind] = "Challenge"
+                result[:spec] = spec.serialize
+                result[:apiVersion] = api_version
+                result[:metadata] = metadata.serialize
+              end
+            end
+
+            def kind_sym
+              :challenge
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/cert-manager/dsl/acme/v1/challenge_list.rb

@@ -0,0 +1,34 @@
+# typed: true
+
+module Kuby
+  module CertManager
+    module DSL
+      module Acme
+        module V1
+          class ChallengeList < ::KubeDSL::DSLObject
+            array_field(:item) { Kuby::CertManager::DSL::Acme::V1::Challenge.new }
+            value_field :api_version
+            object_field(:metadata) { KubeDSL::DSL::Meta::V1::ListMeta.new }
+
+            validates :items, array: { kind_of: Kuby::CertManager::DSL::Acme::V1::Challenge }, presence: false
+            validates :api_version, field: { format: :string }, presence: false
+            validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ListMeta }
+
+            def serialize
+              {}.tap do |result|
+                result[:items] = items.map(&:serialize)
+                result[:kind] = "ChallengeList"
+                result[:apiVersion] = api_version
+                result[:metadata] = metadata.serialize
+              end
+            end
+
+            def kind_sym
+              :challenge_list
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/cert-manager/dsl/acme/v1/challenge_spec.rb

@@ -0,0 +1,51 @@
+# typed: true
+
+module Kuby
+  module CertManager
+    module DSL
+      module Acme
+        module V1
+          class ChallengeSpec < ::KubeDSL::DSLObject
+            object_field(:issuer_ref) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecIssuerRef.new }
+            object_field(:solver) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolver.new }
+            value_field :url
+            value_field :token
+            value_field :dns_name
+            value_field :key
+            value_field :wildcard
+            value_field :type
+            value_field :authorization_url
+
+            validates :issuer_ref, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecIssuerRef }
+            validates :solver, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolver }
+            validates :url, field: { format: :string }, presence: true
+            validates :token, field: { format: :string }, presence: true
+            validates :dns_name, field: { format: :string }, presence: true
+            validates :key, field: { format: :string }, presence: true
+            validates :wildcard, field: { format: :boolean }, presence: true
+            validates :type, field: { format: :string }, presence: true
+            validates :authorization_url, field: { format: :string }, presence: true
+
+            def serialize
+              {}.tap do |result|
+                result[:issuerRef] = issuer_ref.serialize
+                result[:solver] = solver.serialize
+                result[:url] = url
+                result[:token] = token
+                result[:dnsName] = dns_name
+                result[:key] = key
+                result[:wildcard] = wildcard
+                result[:type] = type
+                result[:authorizationURL] = authorization_url
+              end
+            end
+
+            def kind_sym
+              :challenge_spec
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/cert-manager/dsl/acme/v1/challenge_spec_issuer_ref.rb

@@ -0,0 +1,33 @@
+# typed: true
+
+module Kuby
+  module CertManager
+    module DSL
+      module Acme
+        module V1
+          class ChallengeSpecIssuerRef < ::KubeDSL::DSLObject
+            value_field :kind
+            value_field :group
+            value_field :name
+
+            validates :kind, field: { format: :string }, presence: false
+            validates :group, field: { format: :string }, presence: false
+            validates :name, field: { format: :string }, presence: true
+
+            def serialize
+              {}.tap do |result|
+                result[:kind] = kind
+                result[:group] = group
+                result[:name] = name
+              end
+            end
+
+            def kind_sym
+              :challenge_spec_issuer_ref
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/cert-manager/dsl/acme/v1/challenge_spec_solver.rb

@@ -0,0 +1,33 @@
+# typed: true
+
+module Kuby
+  module CertManager
+    module DSL
+      module Acme
+        module V1
+          class ChallengeSpecSolver < ::KubeDSL::DSLObject
+            object_field(:dns01) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01.new }
+            object_field(:selector) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverSelector.new }
+            object_field(:http01) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverHttp01.new }
+
+            validates :dns01, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01 }
+            validates :selector, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverSelector }
+            validates :http01, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverHttp01 }
+
+            def serialize
+              {}.tap do |result|
+                result[:dns01] = dns01.serialize
+                result[:selector] = selector.serialize
+                result[:http01] = http01.serialize
+              end
+            end
+
+            def kind_sym
+              :challenge_spec_solver
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/cert-manager/dsl/acme/v1/challenge_spec_solver_dns01.rb

@@ -0,0 +1,54 @@
+# typed: true
+
+module Kuby
+  module CertManager
+    module DSL
+      module Acme
+        module V1
+          class ChallengeSpecSolverDns01 < ::KubeDSL::DSLObject
+            value_field :cname_strategy
+            object_field(:akamai) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01Akamai.new }
+            object_field(:cloud_dns) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01CloudDNS.new }
+            object_field(:webhook) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01Webhook.new }
+            object_field(:acme_dns) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01AcmeDNS.new }
+            object_field(:digitalocean) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01Digitalocean.new }
+            object_field(:rfc2136) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01Rfc2136.new }
+            object_field(:cloudflare) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01Cloudflare.new }
+            object_field(:route53) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01Route53.new }
+            object_field(:azure_dns) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01AzureDNS.new }
+
+            validates :cname_strategy, field: { format: :string }, presence: false
+            validates :akamai, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01Akamai }
+            validates :cloud_dns, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01CloudDNS }
+            validates :webhook, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01Webhook }
+            validates :acme_dns, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01AcmeDNS }
+            validates :digitalocean, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01Digitalocean }
+            validates :rfc2136, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01Rfc2136 }
+            validates :cloudflare, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01Cloudflare }
+            validates :route53, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01Route53 }
+            validates :azure_dns, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01AzureDNS }
+
+            def serialize
+              {}.tap do |result|
+                result[:cnameStrategy] = cname_strategy
+                result[:akamai] = akamai.serialize
+                result[:cloudDNS] = cloud_dns.serialize
+                result[:webhook] = webhook.serialize
+                result[:acmeDNS] = acme_dns.serialize
+                result[:digitalocean] = digitalocean.serialize
+                result[:rfc2136] = rfc2136.serialize
+                result[:cloudflare] = cloudflare.serialize
+                result[:route53] = route53.serialize
+                result[:azureDNS] = azure_dns.serialize
+              end
+            end
+
+            def kind_sym
+              :challenge_spec_solver_dns01
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/cert-manager/dsl/acme/v1/challenge_spec_solver_dns01_acme_dns.rb

@@ -0,0 +1,30 @@
+# typed: true
+
+module Kuby
+  module CertManager
+    module DSL
+      module Acme
+        module V1
+          class ChallengeSpecSolverDns01AcmeDNS < ::KubeDSL::DSLObject
+            object_field(:account_secret_ref) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01AcmeDNSAccountSecretRef.new }
+            value_field :host
+
+            validates :account_secret_ref, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01AcmeDNSAccountSecretRef }
+            validates :host, field: { format: :string }, presence: true
+
+            def serialize
+              {}.tap do |result|
+                result[:accountSecretRef] = account_secret_ref.serialize
+                result[:host] = host
+              end
+            end
+
+            def kind_sym
+              :challenge_spec_solver_dns01_acme_dns
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/cert-manager/dsl/acme/v1/challenge_spec_solver_dns01_acme_dns_account_secret_ref.rb

@@ -0,0 +1,30 @@
+# typed: true
+
+module Kuby
+  module CertManager
+    module DSL
+      module Acme
+        module V1
+          class ChallengeSpecSolverDns01AcmeDNSAccountSecretRef < ::KubeDSL::DSLObject
+            value_field :name
+            value_field :key
+
+            validates :name, field: { format: :string }, presence: true
+            validates :key, field: { format: :string }, presence: false
+
+            def serialize
+              {}.tap do |result|
+                result[:name] = name
+                result[:key] = key
+              end
+            end
+
+            def kind_sym
+              :challenge_spec_solver_dns01_acme_dns_account_secret_ref
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/cert-manager/dsl/acme/v1/challenge_spec_solver_dns01_akamai.rb

@@ -0,0 +1,36 @@
+# typed: true
+
+module Kuby
+  module CertManager
+    module DSL
+      module Acme
+        module V1
+          class ChallengeSpecSolverDns01Akamai < ::KubeDSL::DSLObject
+            value_field :service_consumer_domain
+            object_field(:client_token_secret_ref) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01AkamaiClientTokenSecretRef.new }
+            object_field(:access_token_secret_ref) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01AkamaiAccessTokenSecretRef.new }
+            object_field(:client_secret_secret_ref) { Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01AkamaiClientSecretSecretRef.new }
+
+            validates :service_consumer_domain, field: { format: :string }, presence: true
+            validates :client_token_secret_ref, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01AkamaiClientTokenSecretRef }
+            validates :access_token_secret_ref, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01AkamaiAccessTokenSecretRef }
+            validates :client_secret_secret_ref, object: { kind_of: Kuby::CertManager::DSL::Acme::V1::ChallengeSpecSolverDns01AkamaiClientSecretSecretRef }
+
+            def serialize
+              {}.tap do |result|
+                result[:serviceConsumerDomain] = service_consumer_domain
+                result[:clientTokenSecretRef] = client_token_secret_ref.serialize
+                result[:accessTokenSecretRef] = access_token_secret_ref.serialize
+                result[:clientSecretSecretRef] = client_secret_secret_ref.serialize
+              end
+            end
+
+            def kind_sym
+              :challenge_spec_solver_dns01_akamai
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/cert-manager/dsl/acme/v1/challenge_spec_solver_dns01_akamai_access_token_secret_ref.rb

@@ -0,0 +1,30 @@
+# typed: true
+
+module Kuby
+  module CertManager
+    module DSL
+      module Acme
+        module V1
+          class ChallengeSpecSolverDns01AkamaiAccessTokenSecretRef < ::KubeDSL::DSLObject
+            value_field :name
+            value_field :key
+
+            validates :name, field: { format: :string }, presence: true
+            validates :key, field: { format: :string }, presence: false
+
+            def serialize
+              {}.tap do |result|
+                result[:name] = name
+                result[:key] = key
+              end
+            end
+
+            def kind_sym
+              :challenge_spec_solver_dns01_akamai_access_token_secret_ref
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/cert-manager/dsl/acme/v1/challenge_spec_solver_dns01_akamai_client_secret_secret_ref.rb

@@ -0,0 +1,30 @@
+# typed: true
+
+module Kuby
+  module CertManager
+    module DSL
+      module Acme
+        module V1
+          class ChallengeSpecSolverDns01AkamaiClientSecretSecretRef < ::KubeDSL::DSLObject
+            value_field :name
+            value_field :key
+
+            validates :name, field: { format: :string }, presence: true
+            validates :key, field: { format: :string }, presence: false
+
+            def serialize
+              {}.tap do |result|
+                result[:name] = name
+                result[:key] = key
+              end
+            end
+
+            def kind_sym
+              :challenge_spec_solver_dns01_akamai_client_secret_secret_ref
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/cert-manager/dsl/acme/v1/challenge_spec_solver_dns01_akamai_client_token_secret_ref.rb

@@ -0,0 +1,30 @@
+# typed: true
+
+module Kuby
+  module CertManager
+    module DSL
+      module Acme
+        module V1
+          class ChallengeSpecSolverDns01AkamaiClientTokenSecretRef < ::KubeDSL::DSLObject
+            value_field :name
+            value_field :key
+
+            validates :name, field: { format: :string }, presence: true
+            validates :key, field: { format: :string }, presence: false
+
+            def serialize
+              {}.tap do |result|
+                result[:name] = name
+                result[:key] = key
+              end
+            end
+
+            def kind_sym
+              :challenge_spec_solver_dns01_akamai_client_token_secret_ref
+            end
+          end
+        end
+      end
+    end
+  end
+end