Knative Anleitung: Serverlose Apps auf Kubernetes ausführen

Einführung

In der heutigen wettbewerbsorientierten Welt suchen Unternehmen zunehmend nach Möglichkeiten zur Optimierung und Reduzierung der Kosten, die mit ihrem Betrieb in der Cloud verbunden sind. Cloud-native Technologien entwickeln sich täglich weiter, und die Suche nach effizienten Lösungen, die ein Gleichgewicht zwischen Leistung und Erschwinglichkeit herstellen, ist unerlässlich geworden. Durch den Einsatz von Knative können Unternehmen die Leistungsfähigkeit von Kubernetes voll ausschöpfen und unnötige Kosten minimieren. In diesem Blog werden wir untersuchen, was Knative genau ist, seine Hauptkomponenten und wie es verwendet und eingesetzt wird.

Was ist Knative?

Knative ist eine auf Kubernetes basierende Open-Source-Plattform, die es uns ermöglicht, serverlose Workloads auf Kubernetes-Clustern bereitzustellen, auszuführen und zu verwalten. Sie macht die Serververwaltung überflüssig und ermöglicht es Entwicklern, sich auf ihren Code zu konzentrieren, ohne sich Gedanken über die zugrunde liegende Infrastruktur zu machen. Knative automatisiert eine Reihe komplexer Aufgaben in den Bereichen Skalierung, Traffic-Routing und ereignisgesteuerte Ausführung. Für DevOps-Ingenieure kann Knative den operativen Overhead erheblich reduzieren, die CI/CD-Pipeline vereinfachen und die Ressourcennutzung in den Clustern durch die Möglichkeit der automatischen Skalierung optimieren, die es erlaubt, die Arbeitslast auf Null zu reduzieren, wenn sie für eine bestimmte Zeit nicht genutzt wird. Dies macht es auch zu einer ausgezeichneten Wahl für Teams, die die Stabilität verbessern, die Kosten senken und die Anwendungsbereitstellung beschleunigen möchten.

Die Schlüsselkomponenten von Knative verstehen

1. Knative Servieren
   • Dienste konfigurieren/verteilen
   • Versionsverwaltung und Dienstaktualisierung: Stellt sicher, dass bei jeder Konfigurationsänderung eine neue Version des Dienstes erstellt wird, während die alte Version ebenfalls gespeichert wird
   • Dynamische Verkehrslenkung: Ermöglicht die Weiterleitung des Datenverkehrs an verschiedene Versionen des Dienstes, was unterschiedliche Bereitstellungsstrategien wie z. B. blau/grün ermöglicht
   • Automatische Skalierung von Diensten: Kann Dienste bei Bedarf auf bis zu Tausende hochskalieren und gleichzeitig auf 0 skalieren, wenn sie nicht genutzt werden
2. Knative Vielseitigkeit
   • Verantwortlich für die Auslösung von Diensten und Funktionen: Ereignisgesteuerte Architektur, bei der Dienste auf Ereignisse reagieren
   • Verwendet die Standard-HTTP-POST-Anfrage zum Senden und Empfangen von Ereignissen
   • Warteschlangen- und Routing-Ereignisse - es bietet Komponenten wie:
     • Makler - Ereignisweiterleitung und -verwaltung
     • Auslöser - Ereignisabonnement und Filterung
     • Kanäle - Mechanismus für den Ereignistransport
     • Abonnements - Kanalnachrichten-Konsumentenbindung
   • Vereinfacht die Behandlung von Ereignissen: keine Notwendigkeit für benutzerdefinierte Skripte oder zusätzliche Lösungen

Wie kann Knative verwendet werden?

Es kann in vielen Szenarien eingesetzt werden:

• Serverlose Workloads: Sie können Ihre Anwendung bereitstellen, die je nach eingehendem Datenverkehr und Bedarf automatisch und ohne menschliches Eingreifen hoch- und herunterskaliert wird. Sie zahlen nur für das, was Sie nutzen
• Ereignisgesteuerte Architekturen: Sie können Systeme aufbauen, die auf Ereignisse wie Datenbankänderungen, HTTP-Anfragen oder Ereignisse in der Nachrichtenwarteschlange reagieren.
• Integration von CI/CD-Pipelines

Schritt-für-Schritt-Anleitung für den Einsatz von Knative

Voraussetzungen

• Laufender Kubernetes-Cluster
• Kubectl ist für die Interaktion mit dem Cluster konfiguriert
• Eine Container-Registry zur Speicherung von Images (z.B. Docker Hub, ECR, GCR, etc.)

1. Knative Serving CRDs installieren

kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.16.0/serving-crds.yaml

2. Knative Serving Core installieren

kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.16.0/serving-core.yaml

3. Kourier als Vernetzungsschicht installieren

kubectl apply -f https://github.com/knative/net-kourier/releases/download/knative-v1.16.0/kourier.yaml

Was ist Kourier und warum verwenden wir es?

Kourier ist ein leichtgewichtiger, leistungsstarker Ingress-Controller, der für Knative Serving entwickelt wurde. Er verwaltet eingehende HTTP-Anfragen und leitet sie an die entsprechenden Knative-Dienste weiter.

Vorteile:

• Einfachheit: Еeinfachere Einrichtung und Verwaltung als bei Istio
• Leistung: Leistungsstarkes Routing mit minimalem Ressourcenverbrauch
• Nahtlose Integration: Knative Serving ist funktionsoptimiert, einschließlich Funktionen wie automatische Skalierung und Traffic-Splitting

4. Konfigurieren Sie Knative so, dass Kourier als Standard-Ingress verwendet wird

kubectl patch configmap/config-network \
  --namespace knative-serving \
  --type merge \
  --patch '{"data":{"ingress.class":"kourier.ingress.networking.knative.dev"}}'

5. Überprüfen Sie die Installation

kubectl get pods -n knative-serving
kubectl get pods -n kourier-system

Bereitstellung des ersten Knative-Dienstes

1. Erstellen Sie eine YAML-Datei (my-service.yaml)

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: my-service		# Replace with your desired service name
  namespace: default 		# Replace with your desired namespace
spec:
  template:
    metadata:
      annotations:
        autoscaling.knative.dev/class: "kpa.autoscaling.knative.dev" 	# Use "kpa.autoscaling.knative.dev" for Kubernetes-based Pod Autoscaler (KPA) or "hpa.autoscaling.knative.dev" for Horizontal Pod Autoscaler (HPA)
        autoscaling.knative.dev/target: "50"  	# Target average concurrent requests per pod; adjust based on workload
        autoscaling.knative.dev/minScale: "0"		# Minimum number of pods (0 allows scale-to-zero)
        autoscaling.knative.dev/maxScale: "10"	# Maximum number of pods
        autoscaling.knative.dev/scale-to-zero-pod-retention-period: "5m"	 # Time to wait before scaling to zero
    spec:
      containers:
        - image: gcr.io/knative-samples/helloworld-go		# Replace with your container image URL
          imagePullPolicy: Always
          ports:
            - containerPort: 8080 		# Replace with your container port if different
          # optional - resources can be specified if required
          # resources: 
          #   requests:
          #     cpu: 100m
          #     memory: 640M
          #   limits:
          #     cpu: 1
      timeoutSeconds: 120		# Request timeout in seconds

2. Übernehmen Sie die YAML-Datei

kubectl apply -f my-service.yaml

3. Prüfen Sie, ob der Dienst verfügbar und bereit ist

kubectl get ksvc my-service

Wie kann man den bereits eingerichteten Knative-Dienst auslösen?

Um zu überprüfen, was wir nach den obigen Schritten bereitgestellt haben, müssen wir einen weiteren curl-pod im Kubernetes-Cluster bereitstellen, mit dem wir den Knative-Dienst manuell auslösen können, um zu sehen, ob er hoch- und herunterskaliert. Bitte befolgen Sie die folgenden Schritte:

Erstellen einer YAML-Datei für den curl-pod

apiVersion: v1
kind: Pod
metadata:
  name: curl-pod
  namespace: default
spec:
  containers:
  - name: curl-container
    image: curlimages/curl:latest
    command: ["/bin/sh"]
    args: ["-c", "sleep infinity"]
  restartPolicy: Never

Sobald der curl-pod eingerichtet ist und läuft, rufen Sie die Shell auf und führen Sie den folgenden Befehl aus. Dadurch wird mehr Datenverkehr für den Dienst erzeugt und wir können sehen, ob er tatsächlich skaliert. (möglicherweise muss der Wert "autoscaling.knative.dev/target" in der Datei my-service.yaml angepasst werden):

for i in {1..100}; do curl -s http://my-service.default.svc.cluster.local & done
wait

Dieser Befehl sollte den Knative-Dienst auslösen und hochskalieren. Er lässt ihn so lange laufen, wie er in der Annotation in seiner YAML-Datei angegeben ist.

Überwachen Sie die von Knative erstellten Pods

kubectl get pods -l serving.knative.dev/service=my-service

Schlussfolgerung

Knative revolutioniert serverlose Anwendungen durch die nahtlose Integration mit Kubernetes zur Automatisierung von Bereitstellung, Skalierung und Ereignisbehandlung. Durch den Einsatz von Knative können Unternehmen nicht nur die Betriebskosten senken , sondern auch die Stabilität und Effizienz ihrer Workloads verbessern. Die Fähigkeit, Ressourcen dynamisch zu skalieren, bis hin zu Null während der Leerlaufzeiten, gewährleistet eine optimale Ressourcennutzung. Darüber hinaus vereinfacht die Integration in CI/CD-Pipelines und die ereignisgesteuerte Architektur den Entwicklungsprozess für DevOps-Teams und ermöglicht eine schnellere und zuverlässigere Anwendungsbereitstellung.