Anpassa CoreDNS med Azure Kubernetes Service

Artikel
10/24/2023

Azure Kubernetes Service (AKS) använder CoreDNS-projektet för dns-klusterhantering och -matchning med alla 1.12.x och högre kluster. Mer information om CoreDNS-anpassning och Kubernetes finns i den officiella uppströmsdokumentationen.

AKS är en hanterad tjänst, så du kan inte ändra huvudkonfigurationen för CoreDNS (en CoreFile). I stället använder du en Kubernetes ConfigMap för att åsidosätta standardinställningarna. Om du vill se standardkonfigurationen för AKS CoreDNS Kartor använder du kubectl get configmaps --namespace=kube-system coredns -o yaml kommandot .

Den här artikeln visar hur du använder Config Kartor för grundläggande CoreDNS-anpassningsalternativ i AKS. Den här metoden skiljer sig från att konfigurera CoreDNS i andra sammanhang, till exempel CoreFile.

Kommentar

Tidigare användes kube-dns för dns-klusterhantering och -matchning, men det är nu inaktuellt. kube-dns erbjöd olika anpassningsalternativ via en Kubernetes-konfigurationskarta. CoreDNS är inte bakåtkompatibelt med kube-dns. Alla anpassningar som du tidigare använde måste uppdateras för CoreDNS.

Innan du börjar

Den här artikeln förutsätter att du har ett befintligt AKS-kluster. Om du behöver ett AKS-kluster kan du skapa ett med hjälp av Azure CLI, Azure PowerShell eller Azure-portalen.
Kontrollera vilken version av CoreDNS du kör. Konfigurationsvärdena kan ändras mellan versioner.
När du skapar konfigurationer som exemplen nedan måste dina namn i dataavsnittet sluta med .server eller .override. Den här namngivningskonventionen definieras i standard-AKS CoreDNS ConfigMap, som du kan visa med kommandot kubectl get configmaps --namespace=kube-system coredns -o yaml .

Stöd för plugin-program

Alla inbyggda CoreDNS-plugin-program stöds. Inga tillägg/plugin-program från tredje part stöds.

Skriv om DNS

Du kan anpassa CoreDNS med AKS för att utföra dns-namnomskrivningar direkt.

Skapa en fil med namnet corednsms.yaml och klistra in följande exempelkonfiguration. Ersätt <domain to be rewritten> med ditt eget fullständigt kvalificerade domännamn.

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: kube-system
data:
  test.server: |
    <domain to be rewritten>.com:53 {
    log
    errors
    rewrite stop {
      name regex (.*)\.<domain to be rewritten>\.com {1}.default.svc.cluster.local
      answer name (.*)\.default\.svc\.cluster\.local {1}.<domain to be rewritten>.com
    }
    forward . /etc/resolv.conf # you can redirect this to a specific DNS server such as 10.0.0.10, but that server must be able to resolve the rewritten domain name
    }

Viktigt!

Om du omdirigerar till en DNS-server, till exempel CoreDNS-tjänstens IP-adress, måste DNS-servern kunna matcha det omskrivna domännamnet.

Skapa ConfigMap med kommandot kubectl apply configmap och ange namnet på ditt YAML-manifest.
```
kubectl apply -f corednsms.yaml
```
Kontrollera att anpassningarna har tillämpats med hjälp av kubectl get configmaps och ange din coredns-anpassade ConfigMap.
```
kubectl get configmaps --namespace=kube-system coredns-custom -o yaml
```
Om du vill läsa in ConfigMap igen och göra det möjligt för Kubernetes Scheduler att starta om CoreDNS utan driftstopp utför du en löpande omstart med .kubectl rollout restart
```
kubectl -n kube-system rollout restart deployment coredns
```

Anpassad vidarebefordranserver

Om du behöver ange en vidarebefordranserver för nätverkstrafiken kan du skapa en ConfigMap för att anpassa DNS.

Skapa en fil med namnet corednsms.yaml och klistra in följande exempelkonfiguration. Ersätt forward namnet och adressen med värdena för din egen miljö.

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: kube-system
data:
  test.server: | # you may select any name here, but it must end with the .server file extension
    <domain to be rewritten>.com:53 {
        forward foo.com 1.1.1.1
    }

Skapa ConfigMap med kommandot kubectl apply configmap och ange namnet på ditt YAML-manifest.
```
kubectl apply -f corednsms.yaml
```
Om du vill läsa in ConfigMap igen och göra det möjligt för Kubernetes Scheduler att starta om CoreDNS utan driftstopp utför du en löpande omstart med .kubectl rollout restart
```
kubectl -n kube-system rollout restart deployment coredns
```

Använda anpassade domäner

Du kanske vill konfigurera anpassade domäner som bara kan lösas internt. Du kanske till exempel vill matcha den anpassade domänen puglife.local, som inte är en giltig toppnivådomän. Utan en anpassad domänkonfigurationskarta kan AKS-klustret inte matcha adressen.

Skapa en ny fil med namnet corednsms.yaml och klistra in följande exempelkonfiguration. Se till att uppdatera den anpassade domänen och IP-adressen med värdena för din egen miljö.

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: kube-system
data:
  puglife.server: | # you may select any name here, but it must end with the .server file extension
    puglife.local:53 {
        errors
        cache 30
        forward . 192.11.0.1  # this is my test/dev DNS server
    }

Skapa ConfigMap med kommandot kubectl apply configmap och ange namnet på ditt YAML-manifest.
```
kubectl apply -f corednsms.yaml
```
Om du vill läsa in ConfigMap igen och göra det möjligt för Kubernetes Scheduler att starta om CoreDNS utan driftstopp utför du en löpande omstart med .kubectl rollout restart
```
kubectl -n kube-system rollout restart deployment coredns 
```

Stub-domäner

CoreDNS kan också användas för att konfigurera stub-domäner.

Skapa en fil med namnet corednsms.yaml och klistra in följande exempelkonfiguration. Se till att uppdatera anpassade domäner och IP-adresser med värdena för din egen miljö.

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: kube-system
data:
  test.server: | # you may select any name here, but it must end with the .server file extension
    abc.com:53 {
     errors
     cache 30
     forward . 1.2.3.4
    }
    my.cluster.local:53 {
        errors
        cache 30
        forward . 2.3.4.5
    }

Skapa ConfigMap med kommandot kubectl apply configmap och ange namnet på ditt YAML-manifest.
```
kubectl apply -f corednsms.yaml
```
Om du vill läsa in ConfigMap igen och göra det möjligt för Kubernetes Scheduler att starta om CoreDNS utan driftstopp utför du en löpande omstart med .kubectl rollout restart
```
kubectl -n kube-system rollout restart deployment coredns
```

Plugin-program för värdar

Alla inbyggda plugin-program stöds, så coreDNS-värdprogrammet är tillgängligt för att anpassa /etc/värdar också.

Skapa en fil med namnet corednsms.yaml och klistra in följande exempelkonfiguration. Se till att uppdatera IP-adresserna och värdnamnen med värdena för din egen miljö.

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom # this is the name of the configmap you can overwrite with your changes
  namespace: kube-system
data:
    test.override: | # you may select any name here, but it must end with the .override file extension
          hosts { 
              10.0.0.1 example1.org
              10.0.0.2 example2.org
              10.0.0.3 example3.org
              fallthrough
          }

Skapa ConfigMap med kommandot kubectl apply configmap och ange namnet på ditt YAML-manifest.
```
kubectl apply -f corednsms.yaml
```
Om du vill läsa in ConfigMap igen och göra det möjligt för Kubernetes Scheduler att starta om CoreDNS utan driftstopp utför du en löpande omstart med .kubectl rollout restart
```
kubectl -n kube-system rollout restart deployment coredns
```

Felsökning

Allmänna felsökningssteg för CoreDNS, till exempel kontroll av slutpunkter eller matchning, finns i Felsöka DNS-matchning.

Konfigurera CoreDNS-poddskalning

Plötsliga toppar i DNS-trafik i AKS-kluster är en vanlig förekomst på grund av den elasticitet som AKS tillhandahåller för arbetsbelastningar. Dessa toppar kan leda till ökad minnesförbrukning av CoreDNS-poddar. I vissa fall kan den ökade minnesförbrukningen orsaka Out of memory problem. För att föregripa det här problemet skalar AKS automatiskt CoreDNS-poddar för att minska minnesanvändningen per podd. Standardinställningarna för den här logiken för automatisk skalning lagras i coredns-autoscaler ConfigMap. Du kan dock observera att den automatiska standardskalningen av CoreDNS-poddar inte alltid är tillräckligt aggressiv för att förhindra Out of memory problem för dina CoreDNS-poddar. I det här fallet kan du ändra coredns-autoscaler ConfigMap direkt. Observera att det bara kan vara en tillfällig korrigering att bara öka antalet CoreDNS-poddar utan att åtgärda rotorsaken Out of memory till problemet. Om det inte finns tillräckligt med minne tillgängligt på noderna där CoreDNS-poddarna körs hjälper det inte att öka antalet CoreDNS-poddar. Du kan behöva undersöka ytterligare och implementera lämpliga lösningar som att optimera resursanvändningen, justera resursbegäranden och begränsningar eller lägga till mer minne i noderna.

CoreDNS använder horisontell klusterproportameter för automatisk skalning av poddar. coredns-autoscaler ConfigMap kan redigeras för att konfigurera skalningslogik för antalet CoreDNS-poddar. coredns-autoscaler ConfigMap stöder för närvarande två olika ConfigMap-nyckelvärden: linear och ladder som motsvarar två kontrolllägen som stöds. Kontrollanten linear ger ett antal repliker i intervallet [min,max] som motsvarar max( ceil( cores * 1/coresPerReplica ) , ceil( nodes * 1/nodesPerReplica ) ). Kontrollanten ladder beräknar antalet repliker genom att konsultera två olika stegfunktioner, en för kärnskalning och en annan för nodskalning, vilket ger maxvärdet för de två replikvärdena. Mer information om kontrolllägen och ConfigMap-format finns i den överordnade dokumentationen.

Viktigt!

Minst 2 CoreDNS-poddrepliker per kluster rekommenderas. Om du konfigurerar minst 1 CoreDNS-poddreplik kan det leda till fel under åtgärder som kräver noddränering, till exempel klusteruppgraderingsåtgärder.

Om du vill hämta coredns-autoscaler ConfigMap kan du köra kubectl get configmap coredns-autoscaler -n kube-system -o yaml kommandot som returnerar följande:

apiVersion: v1
data:
  ladder: '{"coresToReplicas":[[1,2],[512,3],[1024,4],[2048,5]],"nodesToReplicas":[[1,2],[8,3],[16,4],[32,5]]}'
kind: ConfigMap
metadata:
  name: coredns-autoscaler
  namespace: kube-system
  resourceVersion: "..."
  creationTimestamp: "..."

Aktivera DNS-frågeloggning

Lägg till följande konfiguration i din coredns-anpassade ConfigMap:

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: kube-system
data:
  log.override: | # you may select any name here, but it must end with the .override file extension
        log

Använd konfigurationsändringarna och tvinga CoreDNS att läsa in ConfigMap igen med hjälp av följande kommandon:

# Apply configuration changes
kubectl apply -f corednsms.yaml

# Force CoreDNS to reload the ConfigMap
kubectl -n kube-system rollout restart deployment coredns

Visa CoreDNS-felsökningsloggning med hjälp av kubectl logs kommandot .
```
kubectl logs --namespace kube-system -l k8s-app=kube-dns
```

Nästa steg

Den här artikeln visade några exempelscenarier för CoreDNS-anpassning. Information om CoreDNS-projektet finns på sidan för CoreDNS-uppströmsprojekt.

Mer information om grundläggande nätverksbegrepp finns i Nätverksbegrepp för program i AKS.

Dela via