certmanager

package
v0.2.0-beta.21 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 28, 2026 License: Apache-2.0 Imports: 4 Imported by: 1

README

Cert-Manager Builders - Certificate Resource Constructors

Go Reference

The certmanager package provides the generated constructors and the admissible sugar for cert-manager Kubernetes resources. These are the low-level building blocks used by Kure's higher-level stack and workflow packages.

Overview

Every kind is built the same way: the generated Create<Kind> wrapper gives you an object carrying identity only, and the upstream cert-manager struct is the construction API — set Spec fields directly, or through the few Set*/Add* helpers the builder contract admits.

Each block on this page is the body of an Example function in example_test.go, which go test runs: it imports this package as certmanager, github.com/go-kure/kure/pkg/kubernetes, the upstream APIs as certv1 "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1", cmacme "github.com/cert-manager/cert-manager/pkg/apis/acme/v1" and cmmeta "github.com/cert-manager/cert-manager/pkg/apis/meta/v1", metav1 "k8s.io/apimachinery/pkg/apis/meta/v1", k8s.io/utils/ptr, time, and fmt for the line that prints what the example built.

Constructors

Every kind this package registers has a generated Create<Kind> wrapper in zz_generated_create.go, produced from the scheme by pkg/kubernetes/internal/gen (make gen-builders, checked by make check-builders in CI). A wrapper delegates to kubernetes.Create[T] and emits TypeMeta and identity only: no default, no label, no spec value. Namespaced kinds take (name, namespace), cluster-scoped kinds take (name).

obj := certmanager.CreateCertificate("my-cert", "default")
cl := certmanager.CreateClusterIssuer("letsencrypt-prod")
fmt.Println(obj.Kind, obj.Namespace+"/"+obj.Name, cl.Kind, cl.Name)

There is no second construction path. The config-struct layer this package used to carry (certmanager.Certificate(&certmanager.CertificateConfig{...}), Issuer, ClusterIssuer, and the sealed IssuerVariant / ACMESolver / DNS01Provider sums behind them) was retired by release 2 of the builder contract: it reached 5 of a Certificate's 24 spec fields and 2 of an issuer's 5 arms, and a consumer could not add a Vault issuer or an Azure DNS solver even by hand. The release 2 migration notes map every removed field to the upstream field that replaces it. No hand-written Create* helper for a spec fragment remains either — a sub-type that is not a client.Object takes a struct literal, which is shorter and shows every field being set.

The kinds this package registers, their scope, and what stated that scope are rows in the generated Supported kinds and field maturity tables. The sections below are worked examples, not the coverage list.

See the Kubernetes Builders page for the full builder contract: construction, sugar admission classes, purity and the migration ledgers.

Supported Resources

Certificate
cert := certmanager.CreateCertificate("my-cert", "default")
cert.Spec = certv1.CertificateSpec{
    SecretName: "my-cert-tls",
    IssuerRef:  cmmeta.IssuerReference{Name: "letsencrypt", Kind: "ClusterIssuer"},
    DNSNames:   []string{"example.com", "www.example.com"},
    Duration:   &metav1.Duration{Duration: 2160 * time.Hour},
}
fmt.Println(cert.Spec.SecretName, cert.Spec.DNSNames, cert.Spec.Duration.Duration)

Every field of certv1.CertificateSpec is reachable this way — PrivateKey, Usages, Subject, Keystores, the lot — because the spec is the upstream struct, not a copy of it.

Issuer

certv1.IssuerSpec embeds the upstream one-of, IssuerConfig, with a pointer per arm (ACME, CA, Vault, SelfSigned, Venafi). Set exactly one; cert-manager rejects an issuer with two at apply time. The two most common arms have a pointer setter:

issuer := certmanager.CreateIssuer("letsencrypt", "default")
certmanager.SetIssuerACME(issuer, &cmacme.ACMEIssuer{
    Server: "https://acme-v02.api.letsencrypt.org/directory",
    Email:  "admin@example.com",
    PrivateKey: cmmeta.SecretKeySelector{
        LocalObjectReference: cmmeta.LocalObjectReference{Name: "letsencrypt-account-key"},
    },
    Solvers: []cmacme.ACMEChallengeSolver{{
        HTTP01: &cmacme.ACMEChallengeSolverHTTP01{
            Ingress: &cmacme.ACMEChallengeSolverHTTP01Ingress{IngressClassName: ptr.To("nginx")},
        },
    }},
})
fmt.Println(issuer.Spec.ACME.Email, *issuer.Spec.ACME.Solvers[0].HTTP01.Ingress.IngressClassName)

A DNS-01 solver is the same shape with a provider set on ACMEChallengeSolverDNS01 — Cloudflare, Route 53, Google CloudDNS, and every other provider cert-manager knows (Azure DNS, DigitalOcean, RFC 2136, AcmeDNS, a webhook). AddACMEIssuerSolver appends one solver at a time when the list is assembled incrementally:

issuer := certmanager.CreateIssuer("letsencrypt", "default")

acme := &cmacme.ACMEIssuer{Server: "https://acme-v02.api.letsencrypt.org/directory", Email: "admin@example.com"}
certmanager.AddACMEIssuerSolver(acme, cmacme.ACMEChallengeSolver{
    DNS01: &cmacme.ACMEChallengeSolverDNS01{
        Cloudflare: &cmacme.ACMEIssuerDNS01ProviderCloudflare{
            Email: "admin@example.com",
            APIToken: &cmmeta.SecretKeySelector{
                LocalObjectReference: cmmeta.LocalObjectReference{Name: "cf-api-token"},
                Key:                  "api-token",
            },
        },
    },
})
certmanager.SetIssuerACME(issuer, acme)
fmt.Println(issuer.Spec.ACME.Solvers[0].DNS01.Cloudflare.APIToken.Name)

The other arms are plain pointer assignments on the embedded struct:

vault := certmanager.CreateIssuer("vault", "default")
vault.Spec.Vault = &certv1.VaultIssuer{Server: "https://vault.example.com", Path: "pki/sign/example"}

selfSigned := certmanager.CreateIssuer("self-signed", "default")
selfSigned.Spec.SelfSigned = &certv1.SelfSignedIssuer{}
fmt.Println(vault.Spec.Vault.Path, selfSigned.Spec.SelfSigned != nil)
ClusterIssuer
clusterIssuer := certmanager.CreateClusterIssuer("letsencrypt-prod")
certmanager.SetClusterIssuerCA(clusterIssuer, &certv1.CAIssuer{SecretName: "ca-key-pair"})
fmt.Println(clusterIssuer.Spec.CA.SecretName)

Modifier Functions

Update existing resources:

cert := certmanager.CreateCertificate("my-cert", "default")
issuer := certmanager.CreateIssuer("letsencrypt", "default")
caIssuer := certmanager.CreateIssuer("internal-ca", "default")
clusterIssuer := certmanager.CreateClusterIssuer("letsencrypt-prod")
caClusterIssuer := certmanager.CreateClusterIssuer("internal-ca")
acmeConfig := &cmacme.ACMEIssuer{Server: "https://acme-v02.api.letsencrypt.org/directory"}
caConfig := &certv1.CAIssuer{SecretName: "ca-key-pair"}

// Replace the whole Certificate spec
cert.Spec = certv1.CertificateSpec{SecretName: "my-cert-tls", DNSNames: []string{"example.com"}}

// Append to the DNS names, set the pointer-typed durations
certmanager.AddCertificateDNSName(cert, "alt.example.com")
certmanager.SetCertificateDuration(cert, &metav1.Duration{Duration: 2160 * time.Hour})
certmanager.SetCertificateRenewBefore(cert, &metav1.Duration{Duration: 360 * time.Hour})

// Labels and annotations use the generic helpers, which work over any object
// with ObjectMeta -- this package carries no per-kind metadata helpers
kubernetes.AddLabel(cert, "app", "my-app")
kubernetes.AddAnnotation(issuer, "note", "production")

// Update issuer configuration: one arm per issuer
certmanager.SetIssuerACME(issuer, acmeConfig)
certmanager.SetIssuerCA(caIssuer, caConfig)
certmanager.SetClusterIssuerACME(clusterIssuer, acmeConfig)
certmanager.SetClusterIssuerCA(caClusterIssuer, caConfig)

fmt.Println(cert.Spec.DNSNames, cert.Spec.RenewBefore.Duration, caIssuer.Spec.CA.SecretName)

Documentation

Overview

Package certmanager exposes the generated constructors and the admissible sugar for cert-manager resources: Certificate, Issuer and ClusterIssuer. Each constructor returns a controller-runtime object carrying identity only; the upstream cert-manager struct is the construction API.

## Constructors

Create<Kind> is generated from the registered scheme and emits apiVersion, kind, metadata.name and, for a namespaced kind, metadata.namespace. Spec fields are the caller's own assignments:

cert := certmanager.CreateCertificate("my-cert", "default")
cert.Spec = certv1.CertificateSpec{
        SecretName: "my-cert-tls",
        IssuerRef:  cmmeta.IssuerReference{Name: "letsencrypt", Kind: "ClusterIssuer"},
        DNSNames:   []string{"example.com"},
}

An issuer's one-of (ACME, CA, Vault, SelfSigned, Venafi) is the upstream IssuerConfig struct: set the arm you want, as a pointer.

issuer := certmanager.CreateClusterIssuer("letsencrypt")
certmanager.SetClusterIssuerACME(issuer, &cmacme.ACMEIssuer{
        Server: "https://acme-v02.api.letsencrypt.org/directory",
        Email:  "admin@example.com",
})

## Update helpers

Functions prefixed with Set or Add write exactly the one field they name and fall into the builder contract's admitted classes: AddCertificateDNSName and AddACMEIssuerSolver append, the remaining Set* helpers assign a pointer-typed field. Labels and annotations use the generic kubernetes.AddLabel / kubernetes.AddAnnotation over metav1.Object; this package carries no per-kind metadata helpers.

The config-struct layer this package used to carry — Certificate, Issuer and ClusterIssuer taking a *Config, and the sealed IssuerVariant, ACMESolver and DNS01Provider sums — was retired by release 2 of the builder contract; see docs/builder-contract-release-2.md for the field-by-field mapping.

Example (AgentsSecretKeySelector)
package main

import (
	"fmt"

	cmmeta "github.com/cert-manager/cert-manager/pkg/apis/meta/v1"
)

func main() {
	key := cmmeta.SecretKeySelector{
		LocalObjectReference: cmmeta.LocalObjectReference{Name: "secret-name"},
		Key:                  "key-name",
	}
	fmt.Println(key.Name, key.Key)
}
Output:
secret-name key-name
Example (ArchitectureCertificate)
package main

import (
	"fmt"

	cmacme "github.com/cert-manager/cert-manager/pkg/apis/acme/v1"

	cmmeta "github.com/cert-manager/cert-manager/pkg/apis/meta/v1"

	"github.com/go-kure/kure/pkg/kubernetes/certmanager"
)

func main() {
	// ACME challenge configuration. SetClusterIssuerACME assigns a pointer-typed
	// field, which is what makes it admissible sugar — it takes the *ACMEIssuer,
	// built here as an upstream struct literal, and writes it straight to the spec.
	issuer := certmanager.CreateClusterIssuer("letsencrypt")
	certmanager.SetClusterIssuerACME(issuer, &cmacme.ACMEIssuer{
		Server: "https://acme-v02.api.letsencrypt.org/directory",
		Email:  "admin@example.com",
		Solvers: []cmacme.ACMEChallengeSolver{{
			DNS01: &cmacme.ACMEChallengeSolverDNS01{
				Cloudflare: &cmacme.ACMEIssuerDNS01ProviderCloudflare{
					APIToken: &cmmeta.SecretKeySelector{
						LocalObjectReference: cmmeta.LocalObjectReference{Name: "cloudflare-api-token"},
						Key:                  "token",
					},
				},
			},
		}},
	})

	// Certificate with DNS validation. IssuerRef is a plain field; DNSNames is a
	// slice, so it keeps an appender.
	cert := certmanager.CreateCertificate("api-tls", "default")
	cert.Spec.IssuerRef = cmmeta.IssuerReference{
		Name: "letsencrypt",
		Kind: "ClusterIssuer",
	}
	certmanager.AddCertificateDNSName(cert, "api.example.com")
	fmt.Println(issuer.Spec.ACME.Solvers[0].DNS01.Cloudflare.APIToken.Name, cert.Spec.IssuerRef.Kind, cert.Spec.DNSNames)
}
Output:
cloudflare-api-token ClusterIssuer [api.example.com]
Example (ArchitectureSecretReference)
package main

import (
	"fmt"

	certv1 "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1"

	cmmeta "github.com/cert-manager/cert-manager/pkg/apis/meta/v1"

	"github.com/go-kure/kure/pkg/kubernetes/certmanager"
)

func main() {
	// Standard pattern for secret references
	key := cmmeta.SecretKeySelector{
		LocalObjectReference: cmmeta.LocalObjectReference{Name: "secret-name"},
		Key:                  "key-name",
	}

	// The reference is a field on the upstream struct; there is no kure setter for it
	issuer := certmanager.CreateIssuer("vault", "default")
	issuer.Spec.Vault = &certv1.VaultIssuer{
		Server: "https://vault.example.com:8200",
		Path:   "pki/sign/example",
		Auth:   certv1.VaultAuth{TokenSecretRef: &key},
	}
	fmt.Println(issuer.Spec.Vault.Auth.TokenSecretRef.Name, issuer.Spec.Vault.Auth.TokenSecretRef.Key)
}
Output:
secret-name key-name
Example (ArchitectureSecrets)
package main

import (
	"fmt"

	"github.com/go-kure/kure/pkg/kubernetes"
	"github.com/go-kure/kure/pkg/kubernetes/certmanager"
)

func main() {
	// NEVER do this - a literal secret in the program that generates the manifests
	// is a literal secret in the Git repository those manifests are committed to.
	secret := kubernetes.CreateSecret("db-credentials", "default")
	secret.Data = map[string][]byte{"password": []byte("hunter2")} // WRONG

	// CORRECT approach - name the secret, let the cluster hold the value
	cert := certmanager.CreateCertificate("tls-cert", "default")
	cert.Spec.SecretName = "tls-cert-secret" // where cert-manager writes the key
	fmt.Println(len(secret.Data), cert.Spec.SecretName)
}
Output:
1 tls-cert-secret

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func AddACMEIssuerSolver

func AddACMEIssuerSolver(issuer *cmacme.ACMEIssuer, solver cmacme.ACMEChallengeSolver)

AddACMEIssuerSolver appends a challenge solver to the ACME issuer configuration, which is the value SetIssuerACME / SetClusterIssuerACME take.

Example
package main

import (
	"fmt"

	cmacme "github.com/cert-manager/cert-manager/pkg/apis/acme/v1"

	cmmeta "github.com/cert-manager/cert-manager/pkg/apis/meta/v1"

	"github.com/go-kure/kure/pkg/kubernetes/certmanager"
)

func main() {
	issuer := certmanager.CreateIssuer("letsencrypt", "default")

	acme := &cmacme.ACMEIssuer{Server: "https://acme-v02.api.letsencrypt.org/directory", Email: "admin@example.com"}
	certmanager.AddACMEIssuerSolver(acme, cmacme.ACMEChallengeSolver{
		DNS01: &cmacme.ACMEChallengeSolverDNS01{
			Cloudflare: &cmacme.ACMEIssuerDNS01ProviderCloudflare{
				Email: "admin@example.com",
				APIToken: &cmmeta.SecretKeySelector{
					LocalObjectReference: cmmeta.LocalObjectReference{Name: "cf-api-token"},
					Key:                  "api-token",
				},
			},
		},
	})
	certmanager.SetIssuerACME(issuer, acme)
	fmt.Println(issuer.Spec.ACME.Solvers[0].DNS01.Cloudflare.APIToken.Name)
}
Output:
cf-api-token

func AddCertificateDNSName

func AddCertificateDNSName(obj *certv1.Certificate, dns string)

AddCertificateDNSName appends a DNS name to the Certificate spec.

Example
package main

import (
	"fmt"
	"time"

	cmacme "github.com/cert-manager/cert-manager/pkg/apis/acme/v1"
	certv1 "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	"github.com/go-kure/kure/pkg/kubernetes"
	"github.com/go-kure/kure/pkg/kubernetes/certmanager"
)

func main() {
	cert := certmanager.CreateCertificate("my-cert", "default")
	issuer := certmanager.CreateIssuer("letsencrypt", "default")
	caIssuer := certmanager.CreateIssuer("internal-ca", "default")
	clusterIssuer := certmanager.CreateClusterIssuer("letsencrypt-prod")
	caClusterIssuer := certmanager.CreateClusterIssuer("internal-ca")
	acmeConfig := &cmacme.ACMEIssuer{Server: "https://acme-v02.api.letsencrypt.org/directory"}
	caConfig := &certv1.CAIssuer{SecretName: "ca-key-pair"}

	// Replace the whole Certificate spec
	cert.Spec = certv1.CertificateSpec{SecretName: "my-cert-tls", DNSNames: []string{"example.com"}}

	// Append to the DNS names, set the pointer-typed durations
	certmanager.AddCertificateDNSName(cert, "alt.example.com")
	certmanager.SetCertificateDuration(cert, &metav1.Duration{Duration: 2160 * time.Hour})
	certmanager.SetCertificateRenewBefore(cert, &metav1.Duration{Duration: 360 * time.Hour})

	// Labels and annotations use the generic helpers, which work over any object
	// with ObjectMeta -- this package carries no per-kind metadata helpers
	kubernetes.AddLabel(cert, "app", "my-app")
	kubernetes.AddAnnotation(issuer, "note", "production")

	// Update issuer configuration: one arm per issuer
	certmanager.SetIssuerACME(issuer, acmeConfig)
	certmanager.SetIssuerCA(caIssuer, caConfig)
	certmanager.SetClusterIssuerACME(clusterIssuer, acmeConfig)
	certmanager.SetClusterIssuerCA(caClusterIssuer, caConfig)

	fmt.Println(cert.Spec.DNSNames, cert.Spec.RenewBefore.Duration, caIssuer.Spec.CA.SecretName)
}
Output:
[example.com alt.example.com] 360h0m0s ca-key-pair

func CreateCertificate

func CreateCertificate(name, namespace string) *certmanagerv1.Certificate

CreateCertificate returns a cert-manager.io/v1 Certificate carrying TypeMeta and identity only.

Example
package main

import (
	"fmt"

	"github.com/go-kure/kure/pkg/kubernetes/certmanager"
)

func main() {
	obj := certmanager.CreateCertificate("my-cert", "default")
	cl := certmanager.CreateClusterIssuer("letsencrypt-prod")
	fmt.Println(obj.Kind, obj.Namespace+"/"+obj.Name, cl.Kind, cl.Name)
}
Output:
Certificate default/my-cert ClusterIssuer letsencrypt-prod
Example (Spec)
package main

import (
	"fmt"
	"time"

	certv1 "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1"

	cmmeta "github.com/cert-manager/cert-manager/pkg/apis/meta/v1"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	"github.com/go-kure/kure/pkg/kubernetes/certmanager"
)

func main() {
	cert := certmanager.CreateCertificate("my-cert", "default")
	cert.Spec = certv1.CertificateSpec{
		SecretName: "my-cert-tls",
		IssuerRef:  cmmeta.IssuerReference{Name: "letsencrypt", Kind: "ClusterIssuer"},
		DNSNames:   []string{"example.com", "www.example.com"},
		Duration:   &metav1.Duration{Duration: 2160 * time.Hour},
	}
	fmt.Println(cert.Spec.SecretName, cert.Spec.DNSNames, cert.Spec.Duration.Duration)
}
Output:
my-cert-tls [example.com www.example.com] 2160h0m0s

func CreateCertificateRequest

func CreateCertificateRequest(name, namespace string) *certmanagerv1.CertificateRequest

CreateCertificateRequest returns a cert-manager.io/v1 CertificateRequest carrying TypeMeta and identity only.

func CreateChallenge

func CreateChallenge(name, namespace string) *acmev1.Challenge

CreateChallenge returns a acme.cert-manager.io/v1 Challenge carrying TypeMeta and identity only.

func CreateClusterIssuer

func CreateClusterIssuer(name string) *certmanagerv1.ClusterIssuer

CreateClusterIssuer returns a cluster-scoped cert-manager.io/v1 ClusterIssuer carrying TypeMeta and identity only.

func CreateIssuer

func CreateIssuer(name, namespace string) *certmanagerv1.Issuer

CreateIssuer returns a cert-manager.io/v1 Issuer carrying TypeMeta and identity only.

Example (OtherArms)
package main

import (
	"fmt"

	certv1 "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1"

	"github.com/go-kure/kure/pkg/kubernetes/certmanager"
)

func main() {
	vault := certmanager.CreateIssuer("vault", "default")
	vault.Spec.Vault = &certv1.VaultIssuer{Server: "https://vault.example.com", Path: "pki/sign/example"}

	selfSigned := certmanager.CreateIssuer("self-signed", "default")
	selfSigned.Spec.SelfSigned = &certv1.SelfSignedIssuer{}
	fmt.Println(vault.Spec.Vault.Path, selfSigned.Spec.SelfSigned != nil)
}
Output:
pki/sign/example true

func CreateOrder

func CreateOrder(name, namespace string) *acmev1.Order

CreateOrder returns a acme.cert-manager.io/v1 Order carrying TypeMeta and identity only.

func SetCertificateDuration

func SetCertificateDuration(obj *certv1.Certificate, dur *metav1.Duration)

SetCertificateDuration sets the desired certificate duration.

func SetCertificateRenewBefore

func SetCertificateRenewBefore(obj *certv1.Certificate, dur *metav1.Duration)

SetCertificateRenewBefore sets the renewBefore field of the certificate spec.

func SetClusterIssuerACME

func SetClusterIssuerACME(obj *certv1.ClusterIssuer, acme *cmacme.ACMEIssuer)

SetClusterIssuerACME sets the ACME config on the ClusterIssuer.

func SetClusterIssuerCA

func SetClusterIssuerCA(obj *certv1.ClusterIssuer, ca *certv1.CAIssuer)

SetClusterIssuerCA sets the CA configuration on the ClusterIssuer spec.

Example
package main

import (
	"fmt"

	certv1 "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1"

	"github.com/go-kure/kure/pkg/kubernetes/certmanager"
)

func main() {
	clusterIssuer := certmanager.CreateClusterIssuer("letsencrypt-prod")
	certmanager.SetClusterIssuerCA(clusterIssuer, &certv1.CAIssuer{SecretName: "ca-key-pair"})
	fmt.Println(clusterIssuer.Spec.CA.SecretName)
}
Output:
ca-key-pair

func SetIssuerACME

func SetIssuerACME(obj *certv1.Issuer, acme *cmacme.ACMEIssuer)

SetIssuerACME sets the ACME configuration on the issuer spec.

Example
package main

import (
	"fmt"

	cmacme "github.com/cert-manager/cert-manager/pkg/apis/acme/v1"

	cmmeta "github.com/cert-manager/cert-manager/pkg/apis/meta/v1"
	"k8s.io/utils/ptr"

	"github.com/go-kure/kure/pkg/kubernetes/certmanager"
)

func main() {
	issuer := certmanager.CreateIssuer("letsencrypt", "default")
	certmanager.SetIssuerACME(issuer, &cmacme.ACMEIssuer{
		Server: "https://acme-v02.api.letsencrypt.org/directory",
		Email:  "admin@example.com",
		PrivateKey: cmmeta.SecretKeySelector{
			LocalObjectReference: cmmeta.LocalObjectReference{Name: "letsencrypt-account-key"},
		},
		Solvers: []cmacme.ACMEChallengeSolver{{
			HTTP01: &cmacme.ACMEChallengeSolverHTTP01{
				Ingress: &cmacme.ACMEChallengeSolverHTTP01Ingress{IngressClassName: ptr.To("nginx")},
			},
		}},
	})
	fmt.Println(issuer.Spec.ACME.Email, *issuer.Spec.ACME.Solvers[0].HTTP01.Ingress.IngressClassName)
}
Output:
admin@example.com nginx

func SetIssuerCA

func SetIssuerCA(obj *certv1.Issuer, ca *certv1.CAIssuer)

SetIssuerCA sets the CA configuration on the issuer spec.

Types

This section is empty.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL