ExternalDNS

ExternalDNS holder postene i dine Frostmoln Administrert DNS-soner synkronisert med Kubernetes-ressursene Ingress, Service og Gateway API — fra hvilken som helst Kubernetes-klynge. Når du eksponerer en arbeidslast, opprettes, oppdateres og ryddes vertsnavnets poster opp automatisk; du redigerer aldri DNS for hånd.

Frostmoln leverer en webhook-leverandør som kjører som en sidecar i external-dns-poden og oversetter ExternalDNS' planer til kall mot Frostmolns DNS-API.

Pilot — DNS-tilgang gis per tenant

ExternalDNS bygger på Administrert DNS, som er en pilot-funksjon aktivert per tenant. Hvis dns-rettigheten ikke er på tenanten din ennå, se Administrert DNS for hvordan du ber om tilgang.

Forutsetninger

• En Frostmoln DNS-sone for domenet du vil ha poster i — se Administrert DNS for å opprette en.
• dns-rettigheten på tenanten din (samme pilottilgang som Administrert DNS).
• En tenant-API-nøkkel (fmk_...) som eies av en bruker i den tenanten. Opprett en i portalen under Innstillinger → API-nøkler, eller med CLI-en — se fm account api-key.

Slik fungerer det

• Poster — webhooken lister tenantens soner og postsett og returnerer dem til ExternalDNS som endepunkter (ett postsett = ett (navn, type) med alle verdiene).
• Anvend — opprettelser og oppdateringer går gjennom DNS-API-ets idempotente upsert på samlingsnivå; slettinger løses opp via postsettets stabile ID.
• Domenefilter — som standard henter webhooken tenantens sonenavn ved oppstart og administrerer bare disse. Opprett en ny sone → start poden på nytt slik at den plukkes opp (eller angi DOMAIN_FILTER eksplisitt).
• Eierskap — bruk ExternalDNS' standard TXT-register (--registry=txt med --txt-owner-id=<klynge-id>) slik at en post bare endres av klyngen som opprettet den. TXT-postsett går uendret gjennom API-et.

Installer

På Frostmoln Administrert Kubernetes er ExternalDNS med Frostmoln-webhooken et klyngetillegg med ett klikk. Velg external-dns når du oppretter klyngen (portalen → Tillegg, eller addons: ["external-dns"] i API-et/Terraform-ressursen), så installerer plattformen alt for deg — navnerommet external-dns, RBAC, ExternalDNS-kontrolleren og Frostmoln-webhook-sidecaren, med --txt-owner-id allerede satt til klyngens id. Webhook-bildet leveres av plattformen og er forhåndsinstallert på klyngenodene; du bygger, henter eller refererer aldri til det selv.

Det eneste steget som gjenstår for deg er API-nøkkel-Secreten (neste avsnitt): til den finnes venter webhook-containeren i CreateContainerConfigError. Opprett DNS-sonen din først (eller start external-dns-Deploymenten på nytt etter at du har opprettet den), og sørg for at tenanten din har rettigheten dns — uten den logger webhooken 403 FEATURE_NOT_ENABLED.

Velges ved klyngeopprettelse

Tillegget velges når klyngen opprettes. For å legge til ExternalDNS i en eksisterende klynge, opprett den på nytt med tillegget valgt — å legge til i etterkant er planlagt. ExternalDNS med Frostmoln-webhooken er foreløpig tilgjengelig kun på Frostmoln Administrert Kubernetes.

Administrert Kubernetes: aktiver tillegget

På Frostmoln Administrert Kubernetes er den enkleste veien klyngetillegget external-dns: velg det når klyngen opprettes (portalen → Tillegg, eller addons: ["external-dns"] i API-et/Terraform-ressursen), så installerer plattformen alt i denne veiledningen — navnerommet external-dns, RBAC og Deploymenten, med --txt-owner-id allerede satt til klyngens id.

Det eneste manuelle steget er API-nøkkel-Secreten (neste avsnitt): til den finnes venter webhook-containeren i CreateContainerConfigError. Opprett DNS-sonen din først (eller start external-dns-Deploymenten på nytt etter at du har opprettet den), og sørg for at tenanten din har rettigheten dns — uten den logger webhooken 403 FEATURE_NOT_ENABLED.

Kun ved klyngeopprettelse

Tillegget kan bare velges når klyngen opprettes. På en eksisterende klynge, bruk manifestet under Distribuer i stedet.

Lagre API-nøkkelen

Legg tenant-API-nøkkelen i en Secret som webhooken kan lese:

kubectl create namespace external-dns   # hopp over hvis tillegget allerede har opprettet det
kubectl create secret generic frostmoln-dns \
  --namespace external-dns \
  --from-literal=api-key=fmk_...

Distribuer

På Administrert Kubernetes med tillegget aktivert kan du hoppe over dette avsnittet — bare Secreten ovenfor trengs.

Manifestet nedenfor kjører external-dns med Frostmoln-webhooken som en sidecar, pluss ServiceAccount og RBAC som external-dns trenger. Erstatt <klynge-id> med en verdi som er unik for denne klyngen — den stempler TXT-eierskapspostene slik at flere klynger trygt kan dele en sone. Podden deklarerer hele Pod Security-kontrakten restricted (Administrert Kubernetes håndhever den på hele klyngen; den eksplisitte runAsUser er viktig fordi external-dns-bildet oppstrøms kjører som root).

På Administrert Kubernetes er webhook-bildet forhåndslastet på nodene dine, og det ligger i et Frostmoln-internt register klyngen din ikke når — så <webhook-image> er ikke ditt valg. Den må være en referanse som allerede ligger på nodene; enhver annen verdi etterlater sidecaren i ImagePullBackOff. Hent den fra klyngen og lim den inn ordrett:

kubectl get nodes -o json \
  | jq -r '.items[].status.images[]?.names[]?' \
  | grep 'external-dns-frostmoln-webhook:' | sort -u

Mer enn én referanse betyr at nodepoolen din spenner over to nodebildegenerasjoner: bruk den som ligger på hver node, eller rull poolen på nytt så de samsvarer. Ingen utdata i det hele tatt betyr at bildet ikke er listet på en travel node — prøv én node om gangen (kubectl get node <name> -o json), eller kontakt supporten.

apiVersion: v1
kind: ServiceAccount
metadata:
  name: external-dns
  namespace: external-dns
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: external-dns
rules:
  - apiGroups: ['']
    resources: ['services', 'endpoints', 'pods', 'nodes']
    verbs: ['get', 'watch', 'list']
  - apiGroups: ['discovery.k8s.io']
    resources: ['endpointslices']
    verbs: ['get', 'watch', 'list']
  - apiGroups: ['extensions', 'networking.k8s.io']
    resources: ['ingresses']
    verbs: ['get', 'watch', 'list']
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: external-dns
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: external-dns
subjects:
  - kind: ServiceAccount
    name: external-dns
    namespace: external-dns
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: external-dns
  namespace: external-dns
spec:
  replicas: 1
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app: external-dns
  template:
    metadata:
      labels:
        app: external-dns
    spec:
      serviceAccountName: external-dns
      securityContext:
        runAsNonRoot: true
        runAsUser: 65532
        runAsGroup: 65532
        seccompProfile:
          type: RuntimeDefault
      containers:
        - name: external-dns
          image: registry.k8s.io/external-dns/external-dns:v0.21.0
          args:
            - --source=ingress
            - --source=service
            - --provider=webhook
            - --registry=txt
            - --txt-owner-id=<cluster-id>
          securityContext:
            readOnlyRootFilesystem: true
            allowPrivilegeEscalation: false
            capabilities:
              drop: [ALL]
        - name: frostmoln-webhook
          image: <webhook-image>
          imagePullPolicy: IfNotPresent
          env:
            - name: FROSTMOLN_API_KEY
              valueFrom:
                secretKeyRef:
                  name: frostmoln-dns
                  key: api-key
          ports:
            - containerPort: 8080
              name: http
          livenessProbe:
            httpGet:
              path: /healthz
              port: http
          readinessProbe:
            httpGet:
              path: /healthz
              port: http
          securityContext:
            readOnlyRootFilesystem: true
            allowPrivilegeEscalation: false
            capabilities:
              drop: [ALL]

Anvend det:

kubectl apply -f external-dns.yaml

Webhook-API-et lytter bare på podens loopback — det er uautentisert etter kontrakt og nekter enhver annen bindingsadresse — og FROSTMOLN_API_URL må være https. Begge håndheves ved oppstart.

Konfigurasjon

Tillegget setter fornuftige standardverdier. For å justere webhook-sidecaren, rediger external-dns-Deploymenten og sett disse miljøvariablene:

Variabel	Standard	Beskrivelse
FROSTMOLN_API_KEY	— (påkrevd)	Tenant-API-nøkkel (fmk_...); tenanten må ha dns-rettigheten
FROSTMOLN_API_KEY_FILE	—	Les nøkkelen fra en montert fil i stedet, for å holde den ute av pod-env
FROSTMOLN_API_URL	https://api.frostmoln.cloud/api	Basis-URL for kunde-API-et (må være https)
FROSTMOLN_TENANT_ID	utledet fra nøkkelen	Overstyring av tenant
DOMAIN_FILTER	dine sonenavn	Overstyring av kommaseparert domenefilter
ZONE_CACHE_TTL	1m	Hvor lenge sonekatalogen bufres
DRY_RUN	false	Logg endringene ExternalDNS ville gjort uten å anvende dem

Merknader og forbehold

• Offentlige soner avviser private mål og loopback-mål. En A/AAAA-post i en offentlig sone må peke på en rutbar adresse — en lastbalanserer eller en offentlig IP, ikke en klyngeintern IP. For interne navn, bruk en privat (vpcId) sone.
• Deleger sonen før du forventer offentlig oppslag. En sone svarer på internett først når domenet ditt er delegert til navnetjenerne dens — se Administrert DNS → Deleger domenet ditt.
• Nye soner krever en omstart av webhooken. Domenefilteret hentes én gang ved oppstart, så start external-dns-poden på nytt etter at du oppretter en sone du vil at ExternalDNS skal administrere.
• TXT-eierskap støttes innebygd — behold --registry=txt med en stabil --txt-owner-id slik at flere klynger trygt kan dele en sone.

Relatert

• Administrert DNS
• Nettverk: Offentlige IP-adresser · Lastbalansere
• fm CLI-referanse: fm account api-key