Serverlose Workloads auf centron Kubernetes mit Knative: Ein Leitfaden

Entdecken Sie in unserem neuesten Blogbeitrag, wie Sie mit Knative Serving serverlose Workloads auf Ihrem centron Kubernetes-Cluster bereitstellen können. Von der Einrichtung des Clusters bis zur Bereitstellung Ihrer Node.js-Anwendung bietet dieser Leitfaden einen umfassenden Überblick über den Prozess. Maximieren Sie Ihre Effizienz und Flexibilität in der Cloud mit dieser einfachen Anleitung zur Nutzung von serverlosen Workloads auf Kubernetes.

Kubernetes ist ein leistungsstarkes Werkzeug zur Container-Orchestrierung, das es ermöglicht, containerisierte Anwendungen bereitzustellen und zu verwalten. Allerdings kann es manchmal zeitaufwändig sein, die zugrunde liegende Infrastruktur zu verwalten. Das serverlose Paradigma hilft Benutzern, Anwendungen bereitzustellen, ohne sich um die zugrunde liegende Infrastruktur kümmern zu müssen. Mit dem Aufkommen von Serverless 2.0 ermöglichen viele Plattformen und Tools jetzt das Bereitstellen serverloser Anwendungen auf Kubernetes.

Knative ist eine auf Kubernetes basierende Plattform, die Komponenten bereitstellt, um serverlose Workloads zu bereitstellen und zu verwalten. Knative bietet eine Open-Source-Kubernetes-Integration, Cloud-Agnostizismus, Bausteine und Erweiterbarkeit. Tools wie Red Hats Openshift verwenden ebenfalls Knative, um Benutzern das Bereitstellen ihrer serverlosen Workloads auf Kubernetes zu ermöglichen.

Knative verfügt über zwei Hauptkomponenten: Eventing und Serving. Eventing verwaltet Ereignisse, die serverlose Workloads auslösen. Serving ist eine Reihe von Komponenten zum Bereitstellen und Verwalten serverloser Workloads. Knative Serving ermöglicht Entwicklern das Bereitstellen und Verwalten serverloser Anwendungen auf Kubernetes. Mit Knative Serving können Entwickler schnell und einfach neue Dienste bereitstellen, sie hoch- und herunterskalieren und sie mit anderen Diensten und Ereignisquellen verbinden. Diese Funktion ermöglicht es Entwicklern, moderne, Cloud-native Anwendungen zu erstellen und bereitzustellen, die flexibel, skalierbar und leicht zu warten sind.

In diesem Tutorial verwenden Sie Knative Serving, um eine Node.js-Anwendung als serverlosen Workload auf einem centron Kubernetes-Cluster bereitzustellen. Sie verwenden kn (das Knative CLI), um den Kubernetes-Cluster zu erstellen und die Anwendung bereitzustellen.

Voraussetzungen

Um dieses Tutorial abzuschließen, benötigen Sie Folgendes:

• Einen ccenter-Account, den Sie verwenden, um einen Kubernetes-Cluster mit mindestens 4 GB RAM und 2 CPU-Kernen zu starten
• kubectl und Docker auf Ihrem Rechner installiert und eingerichtet
• Eine Beispielnodem.js-Anwendung
• Ein Konto bei Docker Hub zum Speichern der Docker-Images, die Sie während dieses Tutorials erstellen

Schritt 1 – Starten des centron Kubernetes-Clusters

Da Knative eine auf Kubernetes basierende Plattform ist, verwenden Sie sie mit einem Kubernetes-Cluster auf centron. Es gibt mehrere Möglichkeiten, einen Kubernetes-Cluster auf centron zu starten. Sie können die ccloud³-Oberfläche, das centron CLI oder den Terraform-Provider verwenden.

Um Knative effektiv in diesem Tutorial zu verwenden, benötigen Sie einen Kubernetes-Cluster mit mindestens 4 GB RAM und 2 CPU-Kernen. Sie können einen Cluster mit diesen Spezifikationen namens knative-tutorial erstellen, indem Sie den Befehl mit den folgenden Flags ausführen:

–size gibt die Größe des Remote-Servers an.

–count gibt die Anzahl der Knoten an, die als Teil des Clusters erstellt werden.

Um den centron Kubernetes-Cluster zu erstellen, führen Sie den folgenden Befehl aus:

kubernetes cluster create knative-tutorial –size s-2vcpu-4gb –count 3

In diesem Befehl erstellen Sie einen Cluster namens knative-tutorial mit der Größe von 4 GB RAM und 2 CPU-Kernen und einer Anzahl von 3 Knoten.

Hinweis: Sie können auch das Flag –region verwenden, um anzugeben, in welcher Region sich der Server befinden soll, obwohl diese Option in diesem Tutorial nicht verwendet wird. Wenn Sie einen Remote-Server, wie einen Droplet, verwenden, möchten Sie möglicherweise Ihren Cluster in derselben Region wie den Server haben. Wenn Sie das centron Control Panel verwenden, um Ihren Cluster zu erstellen, können Sie eine Rechenzentrumsregion und ein VPC-Netzwerk auswählen. Weitere Informationen zur regionalen Verfügbarkeit von centron finden Sie in unserer Regional Availability Matrix.

Dieser Befehl dauert einige Minuten. Sobald er abgeschlossen ist, erhalten Sie eine Meldung ähnlich der folgenden:

Output

Notice: Cluster is provisioning, waiting for cluster to be running

…………………………………………………..

Notice: Cluster created, fetching credentials

Notice: Adding cluster credentials to kubeconfig file found in „/home/sammy/.kube/config“

Notice: Setting current-context to do-nyc1-knative-tutorial

ID Name Region Version Auto Upgrade Status Node Pools

d2d1f9bc-114b-45e7-b109-104137f9ab62 knative-tutorial nyc1 1.24.4-do.0 false running knative-tutorial-default-pool

Der Cluster ist jetzt bereit zur Verwendung.

Sie können jetzt überprüfen, ob kubectl in Ihrem System eingerichtet wurde und den centron Kubernetes-Cluster mit dem folgenden Befehl erreichen kann:

kubectl cluster-info

Sie sollten eine ähnliche Ausgabe erhalten:

Output

Kubernetes control plane is running at https://69de217e-0284-4e18-a6d7-5606915a4e88.k8s

.oncentron.de

CoreDNS is running at https://69de217e-0284-4e18-a6d7-5606915a4e88.k8s.oncentron.de/api/v1/namespaces/kube-system/services/coredns:dns/proxy

Jetzt haben Sie einen Kubernetes-Cluster auf centron eingerichtet und können fortfahren, Knative und Ihre Node.js-Anwendung darauf zu installieren und zu bereitstellen.

Schritt 2 – Installieren von Knative Serving

Nachdem Sie Ihren centron Kubernetes-Cluster eingerichtet haben, installieren Sie Knative Serving auf diesem Cluster.

Sie installieren Knative Serving mit kubectl und dem Knative-Operator, einem Kubernetes-Operator, der Knative-Komponenten installiert und verwaltet.

Um Knative Serving zu installieren, führen Sie die folgenden Befehle aus:

kubectl apply –filename https://github.com/knative/serving/releases/download/v0.30.0/serving-crds.yaml

kubectl apply –filename https://github.com/knative/serving/releases/download/v0.30.0/serving-core.yaml

Dieser Befehl wendet die YAML-Dateien an, die die Ressourcen für die Installation von Knative Serving definieren. Die erste Zeile wendet die Custom Resource Definitions (CRDs) für Knative Serving an. Die zweite Zeile wendet die Kernressourcen an.

Nachdem die Installation abgeschlossen ist, überprüfen Sie, ob alle Pods von Knative Serving ausgeführt werden:

kubectl get pods –namespace knative-serving

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Output

NAME READY STATUS RESTARTS AGE

activator-7859d98ff7-7trbh 1/1 Running 0 2m

autoscaler-6d76669c99-7dh8d 1/1 Running 0 2m

autoscaler-hpa-5b47b68f4b-v9c59 1/1 Running 0 2m

controller-6bdfb87d8b-9kn6f 1/1 Running 0 2m

networking-istio-6c57dd5d8c-2k99z 1/1 Running 0 2m

webhook-79fc8f468d-9nkjz 1/1 Running 0 2m

Nachdem Knative Serving erfolgreich installiert wurde, können Sie fortfahren und Ihre Node.js-Anwendung bereitstellen.

Schritt 3 – Bereitstellen Ihrer Node.js-Anwendung als serverloser Workload

Nachdem Sie Knative Serving erfolgreich installiert haben, können Sie Ihre Node.js-Anwendung als serverlosen Workload bereitstellen.

Um Ihre Node.js-Anwendung bereitzustellen, verwenden Sie den Knative CLI (kn). Sie erstellen zuerst ein YAML-Manifest, das die Ressource für Ihren serverlosen Workload definiert, und wenden dieses Manifest dann auf Ihren Kubernetes-Cluster an.

Erstellen Sie zuerst eine Datei namens service.yaml und fügen Sie den folgenden Inhalt ein:

apiVersion: serving.knative.dev/v1

kind: Service

metadata:

name: nodejs-app

spec:

template:

spec:

containers:

– image: YOUR_DOCKER_USERNAME/nodejs-app:latest

Ersetzen Sie YOUR_DOCKER_USERNAME durch Ihren Docker-Benutzernamen. Dieses YAML-Manifest definiert einen serverlosen Workload mit dem Namen nodejs-app, der das Containerimage Ihrer Node.js-Anwendung verwendet.

Wenden Sie dann dieses Manifest auf Ihren Kubernetes-Cluster an:

kubectl apply –filename service.yaml

Dieser Befehl wendet das YAML-Manifest an und erstellt eine Ressource vom Typ Service auf Ihrem Kubernetes-Cluster. Diese Ressource stellt Ihre Node.js-Anwendung als serverlosen Workload bereit.

Um den Status Ihrer Bereitstellung zu überprüfen, verwenden Sie den folgenden Befehl:

kubectl get ksvc

Sie sollten eine Ausgabe sehen, die ähnlich der folgenden ist:

Output

NAME URL LATESTCREATED LATESTREADY READY REASON

nodejs-app http://nodejs-app.default.69de217e-0284-4e18-a6d7-5606915a4e88.k8s.oncentron.de nodejs-app-00001 nodejs-app-00001 True

Die URL, die in der Ausgabe angezeigt wird, ist die URL Ihrer bereitgestellten Node.js-Anwendung. Sie können diese URL verwenden, um auf Ihre Anwendung zuzugreifen.

Das war’s! Sie haben erfolgreich eine Node.js-Anwendung als serverlosen Workload auf einem centron Kubernetes-Cluster mit Knative Serving bereitgestellt.

Fazit

In diesem Tutorial haben Sie gelernt, wie Sie serverlose Workloads mit Knative Serving auf einem centron Kubernetes-Cluster bereitstellen. Sie haben einen Kubernetes-Cluster auf centron gestartet, Knative Serving installiert und Ihre Node.js-Anwendung als serverlosen Workload bereitgestellt. Sie können nun weitere Anwendungen bereitstellen und mit Knative auf Kubernetes experimentieren, um moderne, Cloud-native Anwendungen zu erstellen und zu verwalten.