Docker och Kubernetes för utvecklare · Lektion

Tjänsteupptäckt och DNS i K8s

Utforska hur Kubernetes hanterar tjänsteupptäckt och DNS-upplösning för kommunikation mellan tjänster.

Lektion 3 av 411 steg

Tjänsteupptäckt och DNS i K8s är en gratis lektion i Docker och Kubernetes för utvecklare på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Docker och Kubernetes för utvecklare, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Docker och Kubernetes för utvecklare innehåller totalt 4 lektioner.

Introduktion till Service Discovery

Välkomna till Service Discovery och DNS i K8s! I ett dynamiskt Kubernetes-kluster skapas, förstörs och flyttas Pods ständigt, vilket leder till IP-adresser som hela tiden förändras.

Hur hittar och kommunicerar applikationer i en Pod med applikationer i en annan Pod eller Service?

Det är här Service Discovery kommer in. Det är mekanismen som gör att tjänster hittar varandra utan att behöva känna till deras specifika, tillfälliga IP-adresser.

DNS: rollen i K8s

Ni känner kanske redan till DNS (Domain Name System) på internet. Det översätter läsbara namn som google.com till IP-adresser.

Kubernetes använder ett liknande koncept internt. I stället för att förlita sig på instabila Pod-IP-adresser tilldelar K8s stabila DNS-namn till sina Services.

Det gör att era applikationer kan ansluta till andra tjänster med enkla, konsekventa namn.

CoreDNS: K8s DNS-server

Varje Kubernetes-kluster har en egen DNS-server, vanligtvis CoreDNS (eller ibland kube-dns i äldre versioner).

CoreDNS körs som en Pod i klustret och ansvarar för att slå upp alla interna Kubernetes-tjänstenamn och översätta dem till motsvarande kluster-IP-adresser.

Den konfigureras automatiskt när ni installerar klustret.

Så får Pods sin DNS-konfiguration

När en Pod startar injicerar Kubernetes automatiskt DNS-konfiguration i den.

Varje Pods /etc/resolv.conf-fil uppdateras så att den pekar på IP-adressen till klustrets CoreDNS-Service.
Den innehåller även sökvägar, vilket gör att ni kan använda kortare tjänstenamn.

Det innebär att alla applikationer i en Pod direkt kan använda klustrets DNS för namnupplösning.

DNS-namn för Services

När ni skapar en Kubernetes-Service (t.ex. en ClusterIP-Service) skapar CoreDNS automatiskt en DNS-post för den.

Det vanligaste formatet för en Services DNS-namn i dess eget namespace är helt enkelt: <service-name>.

Exempelvis kan en Service med namnet my-web-app i namespacet default nås av andra Pods i samma namespace genom att endast använda my-web-app.

Exempel: Åtkomst i samma namespace

Anta att ni har en deployment hello-app och en Service hello-service i namespacet default. Alla andra Pods i default kan nå den via hello-service.

Här är ett enkelt exempel på en Deployment och en Service:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-app
spec:
  selector:
    matchLabels:
      app: hello
  replicas: 1
  template:
    metadata:
      labels:
        app: hello
    spec:
      containers:
      - name: hello-container
        image: busybox
        command: ["sh", "-c", "while true; do echo Hello K8s; sleep 5; done"]

---

apiVersion: v1
kind: Service
metadata:
  name: hello-service
spec:
  selector:
    app: hello
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: ClusterIP

Testa DNS i samma namespace

När ni har tillämpat YAML-filen från föregående scen kan ni testa Service Discovery. Skapa först en tillfällig Pod (t.ex. debug-pod) i samma namespace.

Kör sedan exec i debug-pod och försök pinga tjänsten:

kubectl run debug-pod --image=busybox --restart=Never --rm -it --command -- sh
I poden: ping hello-service

Ni bör se att hello-services ClusterIP slås upp!

DNS mellan namespaces (FQDN)

Vad händer om era tjänster finns i olika namespaces? Kubernetes använder formatet Fully Qualified Domain Name (FQDN):

<service-name>.<namespace-name>.svc.cluster.local

För enkelhetens skull kan ni ofta använda en kortare form om Pod:ens namespace finns i dess DNS-sökväg (vilket den vanligtvis gör):

<service-name>.<namespace-name>

Detta möjliggör tydlig och entydig kommunikation mellan olika delar av er applikation.

Exempel: åtkomst mellan namespaces

Föreställ er en backend-service i namespacet prod. Från en Pod i namespacet default får ni åtkomst till den så här:

ping backend-service.prod

Kubernetes DNS hanterar namnuppslagningen och dirigerar trafiken till rätt tjänst, även mellan olika namespaces.

Det ger stark isolering samtidigt som kommunikation möjliggörs där det behövs.

Snabb kontroll

Vilka av följande påståenden om Kubernetes Service Discovery och DNS är SANNA?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Service Discovery och DNS

Bra jobbat! I den här lektionen har ni lärt er hur Kubernetes hanterar service discovery och DNS-upplösning för intern kommunikation:

Pods har tillfälliga IP-adresser, vilket kräver en stabil mekanism för service discovery.
CoreDNS är klustrets interna DNS-server.
Services får stabila DNS-namn som kan slås upp av andra Pods.
Pods konfigureras automatiskt för att använda klustrets DNS.
Ni kan komma åt tjänster i samma namespace via namn eller i andra namespaces med hjälp av FQDN.

Detta kraftfulla system säkerställer att era applikationer alltid kan hitta varandra på ett tillförlitligt sätt!

Gratis att börja

Lär dig Docker och Kubernetes för utvecklare med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Tjänsteupptäckt och DNS i K8s” gratis?

Ja – hela texten till ”Tjänsteupptäckt och DNS i K8s” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Docker och Kubernetes för utvecklare, kan Ni uppgradera till CoddyKit PRO. Kursen i Docker och Kubernetes för utvecklare innehåller totalt 4 lektioner.

Vad lär jag mig i ”Tjänsteupptäckt och DNS i K8s”?

Utforska hur Kubernetes hanterar tjänsteupptäckt och DNS-upplösning för kommunikation mellan tjänster. Ni övar på Docker och Kubernetes för utvecklare med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Docker och Kubernetes för utvecklare?

Du behöver inga förkunskaper. Utbildningen i Docker och Kubernetes för utvecklare på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Tjänsteupptäckt och DNS i K8s”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Docker och Kubernetes för utvecklare-lektionen?

Ja. Varje Docker och Kubernetes för utvecklare-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Kubernetes Ingress och routing
Implementera nätverksprinciper
Tjänsteupptäckt och DNS i K8s
TLS-terminering och säkring av Ingress med HTTPS

← Tillbaka till Docker och Kubernetes för utvecklare