Kubernetes-Anwendungen veröffentlichen

Einführung

In diesem Lab erfahren Sie, wie Sie Kubernetes-Anwendungen mit verschiedenen Techniken zugänglich machen können. Dazu gehören die Erstellung interner und externer Dienste, die Arbeit mit Labels und die Erkundung der Grundlagen von Ingress. Sie beginnen damit, einen lokalen Kubernetes-Cluster mit Minikube einzurichten. Anschließend stellen Sie eine Beispiel-NGINX-Anwendung bereit und machen sie sowohl intern als auch extern zugänglich. Sie werden auch die Verwendung von Labels zur Organisation und Auswahl von Ressourcen untersuchen. Abschließend lernen Sie etwas über Ingress und sehen ein einfaches Ingress-YAML-Beispiel.

Starten Sie den Kubernetes-Cluster

In diesem Schritt erfahren Sie, wie Sie einen lokalen Kubernetes-Cluster mit Minikube starten und überprüfen können. Dies ist ein wesentlicher erster Schritt für die Entwicklung und das Testen von Kubernetes-Anwendungen auf Ihrem lokalen Rechner.

Zunächst starten Sie den Minikube-Cluster:

minikube start

Beispielausgabe:

😄  minikube v1.29.0 on Ubuntu 22.04
✨  Automatically selected the docker driver
📌  Using Docker driver with root permissions
🔥  Creating kubernetes in kubernetes cluster
🔄  Restarting existing kubernetes cluster
🐳  Preparing Kubernetes v1.26.1 on Docker 20.10.23...
🚀  Launching Kubernetes...
🌟  Enabling addons: storage-provisioner, default-storageclass
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace

Überprüfen Sie den Status des Clusters mit mehreren Befehlen:

minikube status
kubectl get nodes

Beispielausgabe für minikube status:

minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

Beispielausgabe für kubectl get nodes:

NAME       STATUS   ROLES           AGE   VERSION
minikube   Ready    control-plane   1m    v1.26.1

Diese Befehle bestätigen, dass:

Minikube erfolgreich läuft.
Ein lokaler Kubernetes-Cluster erstellt wurde.
Der Cluster einsatzbereit ist.
Sie einen Ein-Knoten-Cluster mit Control-Plane-Funktionalität haben.

Eine Beispielanwendung bereitstellen

In diesem Schritt erfahren Sie, wie Sie eine Kubernetes-Anwendung mithilfe einer YAML-Manifestdatei erstellen und bereitstellen können. Wir werden eine einfache NGINX-Webserver-Bereitstellung erstellen, um den Prozess der Definition und Anwendung von Kubernetes-Ressourcen zu demonstrieren.

Zunächst erstellen Sie ein Verzeichnis für Ihre Kubernetes-Manifestdateien:

mkdir -p ~/project/k8s-manifests
cd ~/project/k8s-manifests

Erstellen Sie eine YAML-Datei für die NGINX-Bereitstellung:

nano nginx-deployment.yaml

Fügen Sie das folgende Bereitstellungsmanifest hinzu:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          ports:
            - containerPort: 80

Speichern Sie die Datei (Strg+X, dann Y, dann Eingabe).

Wenden Sie die Bereitstellung auf den Kubernetes-Cluster an:

kubectl apply -f nginx-deployment.yaml

Beispielausgabe:

deployment.apps/nginx-deployment created

Überprüfen Sie die Bereitstellung und die Pods:

kubectl get deployments
kubectl get pods

Beispielausgabe für kubectl get deployments:

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   3/3     3            3           1m

Beispielausgabe für kubectl get pods:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-xxx-yyy            1/1     Running   0          1m
nginx-deployment-xxx-zzz            1/1     Running   0          1m
nginx-deployment-xxx-www            1/1     Running   0          1m

Warten Sie, bis die Pods im Zustand "Running" sind, bevor Sie fortfahren.

Lassen Sie uns das YAML-Manifest analysieren:

apiVersion: Gibt die Kubernetes-API-Version an.
kind: Definiert den Ressourcentyp (Deployment).
metadata: Liefert Name und Labels für die Bereitstellung.
spec.replicas: Legt die Anzahl der Pod-Replikate fest.
selector: Hilft der Bereitstellung, die richtigen Pods zu verwalten.
template: Definiert die Pod-Spezifikation.
containers: Gibt das Container-Image und den Port an.

Diese Bereitstellung erstellt drei identische NGINX-Pods und zeigt, wie Kubernetes containerisierte Anwendungen verwaltet.

Erstellen Sie einen Service über YAML, um die Anwendung intern oder extern bereitzustellen

In diesem Schritt erfahren Sie, wie Sie Kubernetes-Services erstellen können, um Ihre NGINX-Bereitstellung sowohl intern als auch extern zugänglich zu machen. Wir werden zwei häufige Service-Typen demonstrieren: ClusterIP und NodePort.

Zunächst navigieren Sie in Ihr Projektverzeichnis:

cd ~/project/k8s-manifests

Erstellen Sie eine YAML-Datei für einen ClusterIP-Service:

nano nginx-clusterip-service.yaml

Fügen Sie das folgende Service-Manifest hinzu:

apiVersion: v1
kind: Service
metadata:
  name: nginx-clusterip-service
spec:
  selector:
    app: nginx
  type: ClusterIP
  ports:
    - port: 80
      targetPort: 80

Nun erstellen Sie eine YAML-Datei für einen NodePort-Service:

nano nginx-nodeport-service.yaml

Fügen Sie das folgende Service-Manifest hinzu:

apiVersion: v1
kind: Service
metadata:
  name: nginx-nodeport-service
spec:
  selector:
    app: nginx
  type: NodePort
  ports:
    - port: 80
      targetPort: 80
      nodePort: 30080

Wenden Sie beide Service-Konfigurationen an:

kubectl apply -f nginx-clusterip-service.yaml
kubectl apply -f nginx-nodeport-service.yaml

Beispielausgabe:

service/nginx-clusterip-service created
service/nginx-nodeport-service created

Überprüfen Sie die Services:

kubectl get services

Beispielausgabe:

NAME                        TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
kubernetes                  ClusterIP   10.96.0.1        <none>        443/TCP        30m
nginx-clusterip-service     ClusterIP   10.104.xxx.xxx   <none>        80/TCP         1m
nginx-nodeport-service      NodePort    10.108.yyy.yyy   <none>        80:30080/TCP   1m

Um auf den NodePort-Service zuzugreifen, rufen Sie die Minikube-IP ab:

minikube ip

Beispielausgabe:

192.168.49.2

Wichtige Unterschiede zwischen den Service-Typen:

ClusterIP: Nur interner Zugriff innerhalb des Clusters
NodePort: Macht den Service auf einem statischen Port auf der IP jedes Knotens zugänglich
NodePort-Bereich: 30000 - 32767

Überprüfen Sie die Service-Konfiguration

In diesem Schritt erfahren Sie, wie Sie kubectl describe service verwenden können, um die detaillierte Konfiguration von Kubernetes-Services zu untersuchen und deren Netzwerkeigenschaften zu verstehen.

Stellen Sie zunächst sicher, dass Sie sich im Projektverzeichnis befinden:

cd ~/project/k8s-manifests

Beschreiben Sie den ClusterIP-Service im Detail:

kubectl describe service nginx-clusterip-service

Beispielausgabe:

Name:              nginx-clusterip-service
Namespace:         default
Labels:            <none>
Annotations:       <none>
Selector:          app=nginx
Type:              ClusterIP
IP Family Policy:  SingleStack
IP Families:       IPv4
IP:                10.104.xxx.xxx
IPs:               10.104.xxx.xxx
Port:              <unset>  80/TCP
TargetPort:        80/TCP
Endpoints:         10.244.0.7:80,10.244.0.8:80,10.244.0.9:80
Session Affinity:  None
Events:            <none>

Nun beschreiben Sie den NodePort-Service:

kubectl describe service nginx-nodeport-service

Beispielausgabe:

Name:                     nginx-nodeport-service
Namespace:                default
Labels:                   <none>
Annotations:              <none>
Selector:                 app=nginx
Type:                     NodePort
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.108.yyy.yyy
IPs:                      10.108.yyy.yyy
Port:                     <unset>  80/TCP
TargetPort:               80/TCP
NodePort:                 <unset>  30080/TCP
Endpoints:                10.244.0.7:80,10.244.0.8:80,10.244.0.9:80
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>

Untersuchen Sie die Service-Endpunkte, um die Netzwerkverbindung zu überprüfen:

kubectl get endpoints

Beispielausgabe:

NAME                        ENDPOINTS                               AGE
kubernetes                  192.168.49.2:8443                       45m
nginx-clusterip-service     10.244.0.7:80,10.244.0.8:80,10.244.0.9:80   15m
nginx-nodeport-service      10.244.0.7:80,10.244.0.8:80,10.244.0.9:80   15m

Wichtige Informationen, die aus der Service-Beschreibung zu verstehen sind:

Selector: Zeigt an, welche Pods Teil des Services sind.
IP: Cluster-interne IP-Adresse des Services.
Endpoints: Liste der Pod-IP-Adressen und -Ports, die den Service bedienen.
Port und TargetPort: Definieren, wie der Datenverkehr geroutet wird.
NodePort: Externer Port für den Service-Typ NodePort.

Verwenden Sie Labels, um Ressourcen zu organisieren und auszuwählen

In diesem Schritt erfahren Sie, wie Sie Labels in Kubernetes verwenden können, um Ressourcen effizient zu organisieren und auszuwählen. Labels sind Schlüssel-Wert-Paare, die Ihnen helfen, Kubernetes-Objekte zu verwalten und zu organisieren.

Zunächst überprüfen Sie die aktuellen Labels auf Ihren Pods:

kubectl get pods --show-labels

Beispielausgabe:

NAME                                READY   STATUS    RESTARTS   AGE   LABELS
nginx-deployment-xxx-yyy            1/1     Running   0          30m   app=nginx,pod-template-hash=xxx
nginx-deployment-xxx-zzz            1/1     Running   0          30m   app=nginx,pod-template-hash=yyy
nginx-deployment-xxx-www            1/1     Running   0          30m   app=nginx,pod-template-hash=zzz

Wählen Sie Pods anhand spezifischer Labels aus:

kubectl get pods -l app=nginx

Beispielausgabe:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-xxx-yyy            1/1     Running   0          30m
nginx-deployment-xxx-zzz            1/1     Running   0          30m
nginx-deployment-xxx-www            1/1     Running   0          30m

Fügen Sie einem der Pods ein benutzerdefiniertes Label hinzu:

kubectl label pods nginx-deployment-xxx-yyy environment=development

Ersetzen Sie nginx-deployment-xxx-yyy durch den Namen eines Ihrer Pods.

Beispielausgabe:

pod/nginx-deployment-xxx-yyy labeled

Wählen Sie nun Pods mit mehreren Label-Selektoren aus:

kubectl get pods -l app=nginx,environment=development

Beispielausgabe:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-xxx-yyy            1/1     Running   0          30m

Entfernen Sie ein Label von einem Pod:

kubectl label pods nginx-deployment-xxx-yyy environment-

Beispielausgabe:

pod/nginx-deployment-xxx-yyy unlabeled

Demonstrieren Sie die Label-Auswahl in Services:

kubectl describe service nginx-clusterip-service

Suchen Sie nach dem Abschnitt "Selector", der zeigt, wie Services Labels verwenden, um Pods zu identifizieren.

Wichtige Punkte zu Labels:

Labels sind Schlüssel-Wert-Paare, die an Kubernetes-Objekte angehängt werden.
Sie werden zur Organisation, Auswahl und Filterung von Ressourcen verwendet.
Sie können dynamisch hinzugefügt, geändert oder entfernt werden.
Services und Bereitstellungen verwenden Labels, um verwandte Pods zu verwalten.

Löschen und Verwalten von Services

In diesem Schritt lernen Sie, wie Sie Kubernetes-Services (Kubernetes-Dienste) mit kubectl-Befehlen löschen und verwalten. Das Verständnis der Service-Verwaltung ist entscheidend für die Wartung und Bereinigung Ihrer Kubernetes-Ressourcen.

Zunächst listen Sie die aktuellen Services auf:

kubectl get services

Beispielausgabe:

NAME                        TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
kubernetes                  ClusterIP   10.96.0.1        <none>        443/TCP        1h
nginx-clusterip-service     ClusterIP   10.104.xxx.xxx   <none>        80/TCP         45m
nginx-nodeport-service      NodePort    10.108.yyy.yyy   <none>        80:30080/TCP   45m

Löschen Sie einen bestimmten Service mit kubectl delete:

kubectl delete service nginx-clusterip-service

Beispielausgabe:

service "nginx-clusterip-service" deleted

Überprüfen Sie das Löschen des Services:

kubectl get services

Beispielausgabe:

NAME                        TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
kubernetes                  ClusterIP   10.96.0.1        <none>        443/TCP        1h
nginx-nodeport-service      NodePort    10.108.yyy.yyy   <none>        80:30080/TCP   45m

Um das Löschen mehrerer Services deutlicher zu demonstrieren, erstellen wir unsere Services neu und löschen sie dann zusammen:

## Recreate services
kubectl apply -f nginx-clusterip-service.yaml
kubectl apply -f nginx-nodeport-service.yaml

## Delete multiple services at once
kubectl delete service nginx-clusterip-service nginx-nodeport-service

Beispielausgabe:

service "nginx-clusterip-service" deleted
service "nginx-nodeport-service" deleted

Überprüfen Sie, ob alle Services entfernt wurden (außer dem Standard-Kubernetes-Service):

kubectl get services

Beispielausgabe:

NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP   1h

Wichtige Punkte zum Löschen von Services:

Das Löschen eines Services entfernt den Netzwerkendpunkt.
Pods werden nicht gelöscht, wenn ein Service entfernt wird.
Der Standard-Kubernetes-Service kann nicht gelöscht werden.
Sie können Services anhand des Namens, einer YAML-Datei oder von Labels löschen.
Mehrere Services können gleichzeitig gelöscht werden, indem Sie sie auflisten oder Label-Selektoren verwenden.

Einführung in die Grundlagen von Ingress und ein einfaches Ingress YAML-Beispiel

In diesem Schritt lernen Sie Kubernetes Ingress kennen, eine leistungsstarke Methode zur Verwaltung des externen Zugangs zu Diensten in einem Kubernetes-Cluster.

Was ist Ingress?

Ingress ist ein API-Objekt, das den externen Zugang zu Diensten in einem Kubernetes-Cluster verwaltet, typischerweise für HTTP-Verkehr. Ingress bietet:

Lastverteilung: Verteilt den Verkehr auf mehrere Backend-Dienste
SSL/TLS-Terminierung: Handhabt sichere Verbindungen
Namensbasierte Virtuelle Hosting: Leitet Anfragen basierend auf dem Hostnamen an verschiedene Dienste weiter
Pfadbasierte Routing: Leitet Anfragen basierend auf dem URL-Pfad an verschiedene Dienste weiter

Ingress besteht aus zwei Komponenten:

Ingress-Ressource: Ein Kubernetes-API-Objekt, das die Routing-Regeln definiert
Ingress-Controller: Die Implementierung, die die in der Ingress-Ressource definierten Regeln durchsetzt

Hinweis: Dieser Lab bietet nur eine grundlegende Einführung in Ingress. In Produktionsumgebungen können Ingress-Konfigurationen viel komplexer sein, einschließlich fortgeschrittenem Routing, Authentifizierung, Rate-Limiting und vieles mehr.

Aktivieren Sie das Ingress-Addon in Minikube:

minikube addons enable ingress

Beispielausgabe:

💡  ingress ist ein von Kubernetes verwaltetes Addon. Bei Fragen wenden Sie sich an minikube auf GitHub.
🔉  ingress wurde erfolgreich aktiviert

Erstellen Sie eine Bereitstellung für zwei Beispielanwendungen:

kubectl create deployment web1 --image=nginx:alpine
kubectl create deployment web2 --image=httpd:alpine

Stellen Sie diese Bereitstellungen als Dienste zur Verfügung:

kubectl expose deployment web1 --port=80 --type=ClusterIP --name=web1-service
kubectl expose deployment web2 --port=80 --type=ClusterIP --name=web2-service

Erstellen Sie eine Ingress YAML-Datei:

nano ingress-example.yaml

Fügen Sie die folgende Ingress-Konfiguration hinzu:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
    - http:
        paths:
          - path: /web1
            pathType: Prefix
            backend:
              service:
                name: web1-service
                port:
                  number: 80
          - path: /web2
            pathType: Prefix
            backend:
              service:
                name: web2-service
                port:
                  number: 80

Wichtige Komponenten dieser Ingress-Konfiguration:

metadata.annotations: Spezifische Konfigurationen für den Ingress-Controller
spec.rules: Definieren, wie der Verkehr an Dienste geroutet wird
path: URL-Pfad, der übereinstimmen muss
pathType: Wie der Pfad übereinstimmen soll (Prefix, Exact oder ImplementationSpecific)
backend.service: Der Dienst und der Port, an den der Verkehr geroutet wird

Wenden Sie die Ingress-Konfiguration an:

kubectl apply -f ingress-example.yaml

Überprüfen Sie die Ingress-Ressource:

kubectl get ingress

Beispielausgabe:

NAME              CLASS   HOSTS   ADDRESS        PORTS   AGE
example-ingress   nginx   *       192.168.49.2   80      1m

Prüfen Sie die Ingress-Details:

kubectl describe ingress example-ingress

Die Beispielausgabe zeigt die Routing-Regeln und die Backend-Dienste.

Testen Sie den Ingress:

## Holen Sie sich die Minikube-IP
minikube ip

## Testen Sie den Zugang zu den Diensten über Ingress
curl $(minikube ip)/web1
curl $(minikube ip)/web2

Jeder Befehl sollte die Standardseite des jeweiligen Webservers zurückgeben.

In Produktionsumgebungen kann Ingress mit folgenden Merkmalen konfiguriert werden:

Mehrere hostnamenbasierte Regeln
TLS-Zertifikate für HTTPS
Authentifizierungsmechanismen
Rate-Limiting
Benutzerdefinierte Timeout-Konfigurationen
Sitzungsaffinität
Und viele weitere fortgeschrittene Funktionen

Für eine umfassendere Abdeckung von Ingress verweisen Sie auf die Kubernetes-Dokumentation und erwägen Sie, die spezifische Dokumentation von Ingress-Controllern wie NGINX Ingress oder Traefik zu erkunden.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie einen lokalen Kubernetes-Cluster mit Minikube starten und überprüfen können. Dies ist für die Entwicklung und das Testen von Kubernetes-Anwendungen auf Ihrem lokalen Rechner unerlässlich. Anschließend haben Sie mithilfe einer YAML-Manifestdatei eine einfache NGINX-Webserver-Bereitstellung erstellt und deployed, wodurch der Prozess der Definition und Anwendung von Kubernetes-Ressourcen demonstriert wurde. Darüber hinaus haben Sie gelernt, wie Sie einen Kubernetes-Service erstellen, um Ihre Anwendung intern oder extern bereitzustellen, und wie Sie Labels verwenden können, um Ressourcen zu organisieren und auszuwählen. Schließlich haben Sie die Grundlagen von Kubernetes Ingress kennengelernt und ein einfaches Ingress-YAML-Beispiel gesehen.