0Pricing
DevOps Bootcamp · Lektion

Ingress für externen Zugriff

Konfigurieren Sie Ingress zur Verwaltung des externen Zugriffs auf Services, einschließlich HTTP/S-Routing und Load-Balancing.

Ingress für externen Zugriff ist eine kostenlose DevOps Bootcamp-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des DevOps Bootcamp-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der DevOps Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Über NodePort und LoadBalancer hinaus

Wir haben verschiedene Kubernetes-Service-Typen wie NodePort und LoadBalancer kennengelernt, um Anwendungen extern bereitzustellen.

Diese Typen sind zwar nützlich, können aber bei komplexen Anforderungen an den externen Zugriff umständlich werden – insbesondere, wenn Sie viele Anwendungen oder APIs über eine einzige IP-Adresse mit spezifischen Weiterleitungsregeln bereitstellen möchten.

Hier kommt Ingress ins Spiel: eine leistungsfähigere und flexiblere Lösung.

Kubernetes Ingress vorgestellt

Ingress ist ein Kubernetes-API-Objekt, das den externen Zugriff auf die Services in einem Cluster verwaltet, hauptsächlich für HTTP- und HTTPS-Datenverkehr.

  • Es dient als zentraler Einstiegspunkt für externe Anfragen.
  • Es ermöglicht HTTP/S-Routing anhand von Hostnamen oder URL-Pfaden.
  • Es kann außerdem Funktionen wie die SSL/TLS-Terminierung und Load Balancing bereitstellen.

Betrachten Sie Ingress als intelligente Verkehrssteuerung, die Webdatenverkehr an die richtigen internen Services weiterleitet.

Der Ingress Controller

Eine Ingress-Ressource besteht selbst nur aus einer Reihe von Regeln und verarbeitet Datenverkehr nicht direkt. Damit Ingress funktioniert, benötigen Sie einen im Cluster ausgeführten Ingress Controller.

Der Ingress Controller überwacht Ingress-Ressourcen und konfiguriert anhand der definierten Regeln einen externen Load Balancer (oder Reverse Proxy).

Zu den beliebten Ingress Controllern gehören Nginx, Traefik und Cloud-spezifische Lösungen wie GCE Ingress für Google Cloud oder AWS Load Balancer Controller.

Funktionsweise von Ingress-Regeln

Ingress definiert Regeln, die eingehende externe Anfragen bestimmten Backend-Services innerhalb Ihres Clusters zuordnen. Diese Regeln legen typischerweise Folgendes fest:

  • Host: Der Domainname (z. B. www.my-app.com).
  • Path: Der URL-Pfad (z. B. /api, /blog).
  • Backend Service: Der Kubernetes-Service und der Port, an den der Datenverkehr weitergeleitet werden soll.

Der Ingress Controller wertet diese Regeln für jede eingehende Anfrage aus, um das richtige Ziel zu bestimmen.

Ein Ingress-YAML erstellen

Wie andere Kubernetes-Ressourcen wird Ingress mit einem YAML-Manifest definiert. Hier sehen Sie eine grundlegende Struktur mit den wichtigsten Feldern:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-app-ingress
spec:
  rules:
  - host: myapp.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: my-web-service
            port:
              number: 80

Einfacher pfadbasierter Ingress

Erstellen wir eine Ingress-Ressource, die den gesamten Datenverkehr für den Root-Pfad (/) von myapp.example.com an einen Service namens my-web-service an Port 80 weiterleitet.

Stellen Sie sicher, dass in Ihrem Cluster bereits ein Deployment und ein Service namens my-web-service ausgeführt werden, bevor Sie diesen Ingress anwenden.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: basic-app-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: myapp.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: my-web-service
            port:
              number: 80

Ihren Ingress bereitstellen

Um Ihre Ingress-Ressource bereitzustellen, speichern Sie das YAML in einer Datei (z. B. basic-ingress.yaml) und verwenden Sie kubectl apply:

kubectl apply -f basic-ingress.yaml

Mit kubectl get ingress können Sie den Status Ihres Ingress prüfen. Der Ingress Controller konfiguriert anschließend anhand dieser Regeln den externen Load Balancer.

Für einen Test müssen Sie in der Regel Ihre lokale Datei /etc/hosts (oder den DNS) so anpassen, dass myapp.example.com auf die externe IP-Adresse Ihres Ingress Controllers verweist.

Beispiel für hostbasiertes Routing

Ingress eignet sich ideal, um mehrere Anwendungen über verschiedene Hostnamen unter einer einzigen externen IP-Adresse bereitzustellen. Hier wird app1.example.com an service-app1 und app2.example.com an service-app2 weitergeleitet.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: host-routing-ingress
spec:
  rules:
  - host: app1.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: service-app1
            port:
              number: 80
  - host: app2.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: service-app2
            port:
              number: 80

Mehrere Pfade, ein Host

Sie können auch verschiedene URL-Pfade desselben Hostnamens an unterschiedliche Backend-Services weiterleiten. Das eignet sich ideal für Microservices-Architekturen oder verschiedene Bereiche einer einzelnen Anwendung.

Anfragen an api.example.com/users werden beispielsweise an users-service und Anfragen an api.example.com/products an products-service weitergeleitet.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: path-routing-ingress
spec:
  rules:
  - host: api.example.com
    http:
      paths:
      - path: /users
        pathType: Prefix
        backend:
          service:
            name: users-service
            port:
              number: 80
      - path: /products
        pathType: Prefix
        backend:
          service:
            name: products-service
            port:
              number: 80

Ingress-Wissenstest

Welche der folgenden Punkte sind wesentliche Vorteile der Verwendung von Kubernetes Ingress?

Zusammenfassung: Ingress für intelligentes Routing

Sehr gut! Sie haben Kubernetes Ingress kennengelernt, eine wichtige Komponente für die Verwaltung der Interaktion externer Benutzer mit Ihren Anwendungen.

  • Ingress ermöglicht flexibles HTTP/S-Routing anhand von Hostnamen und URL-Pfaden.
  • Er benötigt einen Ingress Controller (z. B. Nginx), der Ingress-Regeln überwacht und das Routing konfiguriert.
  • Er vereinfacht die Bereitstellung mehrerer Services über eine einzige externe IP-Adresse und macht Ihren Cluster dadurch effizienter und leichter verwaltbar.

Die Beherrschung von Ingress ist entscheidend für robuste und zugängliche cloudnative Anwendungen!

Häufig gestellte Fragen

Ist die Lektion „Ingress für externen Zugriff“ kostenlos?

Ja — der vollständige Text von „Ingress für externen Zugriff“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des DevOps Bootcamp-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der DevOps Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Ingress für externen Zugriff“?

Konfigurieren Sie Ingress zur Verwaltung des externen Zugriffs auf Services, einschließlich HTTP/S-Routing und Load-Balancing. Du übst DevOps Bootcamp mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um DevOps Bootcamp zu starten?

Keine Vorkenntnisse erforderlich. DevOps Bootcamp auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Ingress für externen Zugriff“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser DevOps Bootcamp-Lektion Code schreiben und ausführen?

Ja. Jede DevOps Bootcamp-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Apps mit Services zugänglich machen
  2. Service-Typen: ClusterIP, NodePort, LoadBalancer
  3. Ingress für externen Zugriff
  4. DNS und Service Discovery
← Zurück zu DevOps Bootcamp