Aller au contenu principal

Générer un certificat Let’s Encrypt avec Cert-Manager via un challenge DNS

Ce guide décrit comment générer un certificat wildcard auto-renouvelé pour un domaine de type *.my.domain.com, en utilisant Cert-Manager et un challenge DNS validé par Let’s Encrypt.

info

Cert-Manager est installé par défaut dans un cluster Kumba et utilise plusieurs ressources Kubernetes personnalisées (CRD) dans un ordre précis.

Certificate → CertificateRequest → Order → Challenge

Principe du challenge DNS​

Let’s Encrypt valide le challenge en résolvant une entrée DNS construite à partir du sous-domaine _acme-challenge du domaine ciblé. Par exemple, pour *.my.domain.com, Let’s Encrypt tentera de résoudre _acme-challenge.my.domain.com

Cert-Manager ne place pas directement la valeur du challenge dans cette entrée DNS. À la place, cette entrée est définie comme un CNAME pointant vers un sous-domaine géré par un serveur ACME-DNS.

remarque

Un exemple de serveur ACME-DNS public est https://auth.acme-dns.io.

Vous pouvez aussi héberger votre propre serveur ACME-DNS, comme celui disponible ici : https://github.com/joohoi/acme-dns.

Etapes​

1. Enregistrer un compte ACME-DNS​

curl -X POST https://auth.acme-dns.io/register | jq > acmedns.json

Exemple de contenu du fichier acmedns.json :

{
  "username": "de86f786-bd19-XXXX-b689-46bXXXX4479e",
  "password": "_dxeETXXX7_e8U9o0vq0Dk0ftsRJiCFrz58pgv_",
  "fulldomain": "XXXXXX-6957-4c66-8a92-3a04535d844d.auth.acme-dns.io",
  "subdomain": "72070f1a-6957-4c66-8a92-3a04535d844d",
  "allowfrom": []
}

2. Ajouter le domaine dans le fichier JSON​

Modifiez le fichier pour introduire une clé correspondant au domaine.

{
  "my.domain.com": {
    "username": "...",
    "password": "...",
    "fulldomain": "...",
    "subdomain": "...",
    "allowfrom": []
  }
}

3. Créer un secret Kubernetes​

kubectl create secret generic acmedns --from-file=./acmedns.json -n cert-manager

4. Créer une ressource ClusterIssuer​

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: acmedns
spec:
  acme:
    email: nope@sorry.com
    preferredChain: ''
    privateKeySecretRef:
        # This secret will be created by Cert-Manager
      name: acmedns-account-key
    server: https://acme-v02.api.letsencrypt.org/directory
    solvers:
      - dns01:
          acmeDNS:
            accountSecretRef:
              name: acmedns
              key: acmedns.json
            host: https://auth.acme-dns.io
        selector:
          dnsZones:
            - $CLUSTER_NAME.kumba.adista.fr
            - '*.$CLUSTER_NAME.kumba.adista.fr'

5. Créer une ressource Certificate​

apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: wildcard-certificate
  namespace: my-namespace
spec:
  dnsNames:
    - "my.domain.com"
    - "*.my.domain.com"
  issuerRef:
    name: acmedns
    kind: ClusterIssuer
  secretName: wildcard-certificate-secret
  # secretTemplate is optional. If set, these annotations and labels will be
  # copied to the Secret named example-com-tls. These labels and annotations will
  # be re-reconciled if the Certificate's secretTemplate changes. secretTemplate
  # is also enforced, so relevant label and annotation changes on the Secret by a
  # third party will be overwriten by cert-manager to match the secretTemplate.
  secretTemplate:
    annotations:
      reflector.v1.k8s.emberstack.com/reflection-allowed: "true"
      reflector.v1.k8s.emberstack.com/reflection-auto-enabled: "true"
      reflector.v1.k8s.emberstack.com/reflection-auto-namespaces: "default"
    labels:
#     my-secret-label: foo

6. Suivre la négociation​

La création de la ressource Certificate déclenche automatiquement la négociation du certificat :

  1. CertificateRequest : généré par Cert-Manager.
  2. Order : déclenché par la demande.
  3. Challenge : créé pour valider le DNS.
  4. Status : chaque ressource inclut un champ status pour suivre l’avancement.
remarque

Le déroulement des étapes peut être consulté via l’interface kumba.

7. Récuperer le certificat​

Une fois le challenge validé, Cert-Manager crée un secret Kubernetes nommé wildcard-certificate-secret contenant :

  • tls.crt : le certificat
  • tls.key : la clé privée

Ce certificat est ensuite utilisable dans vos ressources Kubernetes comme les IngressRoutes.