Freigeben über

Bereitstellen von SpinKube in Azure Kubernetes Service (AKS) zum Ausführen serverloser WebAssembly-Workloads (Wasm)

In diesem Artikel wird gezeigt, wie Sie SpinKube für Azure Kubernetes Service (AKS) bereitstellen, um serverlose WebAssembly-Workloads (Wasm) auszuführen.

Übersicht

WebAssembly (Wasm) ist ein Binärformat, das für schnelles Herunterladen und nahezu native Ausführungsgeschwindigkeit optimiert ist. Sie wird in einer Sandbox isoliert vom Hostcomputer ausgeführt, der von einer Wasm-Runtime bereitgestellt wird. Standardmäßig können WebAssembly-Module nicht auf Ressourcen zugreifen, einschließlich Sockets und Umgebungsvariablen, auf dem Host außerhalb der Sandbox, es sei denn, sie sind explizit zulässig. Der WebAssembly System Interface (WASI)-Standard definiert eine Reihe von Schnittstellen für Wasm-Runtimes, um den Zugriff auf WebAssembly-Module auf die Umgebung und Ressourcen außerhalb des Hosts mithilfe eines funktionsbasierten Sicherheitsmodells bereitzustellen.

SpinKube ist ein Open-Source-Projekt, das serverlose Wasm-Workloads (Spin Apps) ausführt, die mit Open Source Spin in Kubernetes erstellt wurden. Im Gegensatz zu früheren Wasm-Runtimes für Kubernetes führt SpinKube Spin Apps systemintern auf den zugrunde liegenden Kubernetes-Knoten aus und basiert nicht auf Containern. Spin-Apps sind normale Wasm-Module, die an der Spezifikation des WebAssembly-Komponentenmodells ausgerichtet sind.

Indem Sie Spin-Apps auf Kubernetes mit SpinKube ausführen, können Sie die folgenden Workloads ausführen:

  • Führen Sie Wasm-Workloads neben vorhandenen containerisierten Anwendungen aus.
  • Führen Sie ähnliche Workloads aus, während weniger Ressourcen verbraucht werden.
  • Führen Sie weitere Workloads für eine bestimmte Gruppe von Ressourcen aus.
  • Führen Sie Workloads auf verschiedenen Architekturen (z. B. amd64 und arm64) aus, ohne sie zu kompilieren.

SpinKube besteht aus zwei Komponenten der obersten Ebene:

  • spin-operator: Ein Kubernetes-Operator, der die Bereitstellung und Verwaltung von Spin Apps mithilfe von benutzerdefinierten Ressourcen zulässt.
  • kube Plug-In für spin: Ein spin-CLI-Plug-In, mit dem Benutzer Gerüste für Kubernetes-Bereitstellungsmanifeste für Spin-Apps erstellen können.

Voraussetzungen

Begrenzungen

  • Der Kubernetes-Knoten os-type muss Linux sein.
  • Sie können das Azure-Portal nicht verwenden, um SpinKube in einem AKS-Cluster bereitzustellen.

Bereitstellen von SpinKube auf einem vorhandenen Cluster

Herstellen einer Verbindung mit dem AKS-Cluster

  • Mit dem Befehl kubectl können Sie az aks get-credentials für die Verbindungsherstellung mit Ihrem Kubernetes-Cluster konfigurieren.

    az aks get-credentials --name <aks-cluster-name> --resource-group <resource-group-name>

Bereitstellen cert-manager

Wenn Sie cert-manager noch nicht für ihr AKS-Cluster bereitgestellt haben, können Sie es installieren, indem Sie die benutzerdefinierten Ressourcendefinitionen (Custom Resource Definitions, CRDs) bereitstellen, gefolgt von dem cert-manager-Helm-Diagramm, das über das jetstack-Repository bereitgestellt wird.

  1. Stellen Sie die cert-manager-CRDs und das Helm-Diagramm mithilfe des kubectl apply-Befehls bereit.

    kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.14.3/cert-manager.crds.yaml

  2. Fügen Sie das Jetstack-Repository hinzu und aktualisieren Sie es mithilfe der Befehle helm repo add und helm repo update.

    helm repo add jetstack https://charts.jetstack.io
helm repo update

  3. Installieren Sie das cert-manager-Helm-Diagramm mithilfe des helm install-Befehls.

    helm install \
  cert-manager jetstack/cert-manager --version v1.14.3 \
  --namespace cert-manager --create-namespace \
  --wait

Bereitstellen runtime-class-manager (auch bekannt als KWasm)

Die runtime-class-manager (auch als KWasm bezeichnet) ist für die Bereitstellung und Verwaltung von containerd-shim auf dem gewünschten Kubernetes-Knoten verantwortlich.

  1. Fügen Sie das KWasm Helm-Repository mit dem Befehl helm repo add hinzu.

    helm repo add kwasm http://kwasm.sh/kwasm-operator/

  2. Installieren Sie den KWasm-Operator mit dem Befehl helm install.

    helm install \
  kwasm-operator kwasm/kwasm-operator \
  --namespace kwasm --create-namespace \
  --version 0.2.3 \
  --set kwasmOperator.installerImage=ghcr.io/spinframework/containerd-shim-spin/node-installer:v0.19.0

Bereitstellen von containerd-shim-spin auf Kubernetes-Knoten

Nachdem runtime-class-manager auf Ihrem AKS-Cluster installiert ist, müssen Sie die Kubernetes-Knoten kommentieren, die Spin Apps mit kwasm.sh/kwasm-node=true ausführen können sollen. Sie können kubectl annotate node verwenden, um alle Knoten oder nur bestimmte Knoten in Ihrem AKS-Cluster zu kommentieren. In diesem Beispiel kommentieren wir alle Knoten im AKS-Cluster mit der kwasm.sh/kwasm-node=true-Anmerkung.

  1. Stellen Sie containerd-shim-spin mithilfe des Befehls kubectl annotate node --all für alle Knoten im AKS-Cluster bereit.

    kubectl annotate node --all kwasm.sh/kwasm-node=true

  2. Nachdem Sie die Kubernetes-Knoten kommentiert haben, verwendet runtime-class-manager einen Kubernetes Auftrag, um die gewünschten Knoten zu ändern. Nach erfolgreicher Bereitstellung von containerd-shim-spin werden die Knoten mit einer kwasm.sh/kwasm-provisioned-Bezeichnung versehen. Sie können überprüfen, ob die gewünschten Knoten die kwasm.sh/kwasm-provisioned-Bezeichnung mit dem kubectl get nodes --show-labels-Befehl zugewiesen haben.

    kubectl get nodes --show-labels

Bereitstellen von spin-operator

Das spin-operator besteht aus zwei benutzerdefinierten Ressourcendefinitionen (Custom Resource Definitions, CRDs), die Sie für Ihr AKS-Cluster bereitstellen müssen: Die RuntimeClass für spin und eine SpinAppExecutor.

  1. Stellen Sie die CRDs und die RuntimeClass für spin mithilfe des Befehls kubectl apply bereit.

    kubectl apply -f https://github.com/spinframework/spin-operator/releases/download/v0.5.0/spin-operator.crds.yaml
kubectl apply -f https://github.com/spinframework/spin-operator/releases/download/v0.5.0/spin-operator.runtime-class.yaml

  2. Stellen Sie die spin-operator mithilfe des Befehls helm install bereit.

    helm install spin-operator --version 0.5.0 \
  --namespace spin-operator --create-namespace \
  --wait oci://ghcr.io/spinframework/charts/spin-operator

  3. Erstellen Sie einen SpinAppExecutor im Standardnamespace mithilfe des kubectl apply-Befehls.

    kubectl apply -f https://github.com/spinframework/spin-operator/releases/download/v0.5.0/spin-operator.shim-executor.yaml

Ausführen einer Spin-App auf AKS

In diesem Abschnitt überprüfen Sie die SpinKube-Installation, indem Sie eine einfache Spin-App mit der spin-CLI und JavaScript erstellen.

Erstellen einer neuen Spin-App

  1. Erstellen Sie eine neue Spin-App mit dem spin new-Befehl mit der http-js-Vorlage.

    spin new -t http-js --accept-defaults hello-spinkube

  2. Wechseln Sie mit dem hello-spinkube-Befehl zum cd-Verzeichnis.

    cd hello-spinkube

  3. Installieren Sie die Abhängigkeiten mithilfe des npm install-Befehls.

    npm install

  4. Verwenden Sie die spin-CLI, um eine einfache Hello, World-Anwendung zu erstellen.

    spin build

Erstellen der Containerregistrierung und Authentifizieren der spin-CLI

  1. Spin-Apps werden als OCI-Artefakte verpackt und über eine OCI-kompatible Registrierung wie Azure Container Registry (ACR) verteilt. Erstellen Sie mithilfe des Befehls az acr create eine neue ACR-Instanz.

    az acr create --name <acr-name> --resource-group <resource-group-name> --location <location> --sku Basic --admin-enabled true

  2. Rufen Sie den ACR-Anmeldeserverendpunkt und das Administratorkennwort mithilfe der Befehle az acr show und az acr credential show ab.

    ACR_LOGIN_SERVER=$(az acr show -n <acr-name> -g <resource-group-name> --query 'loginServer' -otsv)
ACR_PASSWORD=$(az acr credential show -n <acr-name> -g <resource-group-name> --query 'passwords[0].value' -otsv)

  3. Authentifizieren Sie Ihre spin-CLI mit dem spin registry login-Befehl.

    spin registry login -u $ACR_NAME -p $ACR_PASSWORD $ACR_LOGIN_SERVER

Packen, Verteilen und Bereitstellen der Spin-App

  1. Nachdem die spin-CLI nun für die ACR-Instanz authentifiziert wurde, können Sie die Spin-App mithilfe des spin registry push-Befehls packen und verteilen, gefolgt von einem OCI-Artefaktverweis (der dem <your acr login server>/<repository-name>:<tag>-Benennungsschema folgt).

    spin registry push $ACR_LOGIN_SERVER/hello-spinkube:0.0.1

  2. Erstellen Sie einen Kubernetes-Geheimschlüssel vom Typ docker-registry für den Verweis während der Bereitstellung der Spin-App auf Ihrem AKS-Cluster mithilfe des kubectl create secret-Befehls. In diesem Beispiel heißt das Geheimnis spinkube-on-aks.

    kubectl create secret docker-registry spinkube-on-aks \
  --docker-server=$ACR_LOGIN_SERVER \
  --docker-username=$ACR_NAME\
  --docker-password $ACR_PASSWORD

  3. Erstellen Sie mithilfe des spin kube scaffold-Befehls die erforderlichen Kubernetes-Bereitstellungsmanifeste.

    spin kube scaffold --from $ACR_LOGIN_SERVER/hello-spinkube:0.0.1 -s spinkube-on-aks > spinapp.yaml

    Die spinapp.yaml-Datei enthält eine vorkonfigurierte Instanz der SpinApp-CRD, die wie folgt aussehen soll:

    apiVersion: core.spinoperator.dev/v1alpha1
kind: SpinApp
metadata:
  name: hello-spinkube
spec:
  image: "<your acr name>.azurecr.io/hello-spinkube:0.0.1"
  executor: containerd-shim-spin
  replicas: 2
  imagePullSecrets:
    - name: spinkube-on-aks

  4. Stellen Sie die Spin-App mithilfe des kubectl apply-Befehls auf dem AKS-Cluster bereit.

    kubectl apply -f spinapp.yaml

Erkunden der Spin-App in AKS

Abrufen der Liste der Spin-Apps

  • Rufen Sie die Liste der Spin-Apps mithilfe des kubectl get spinapps-Befehls ab.

    kubectl get spinapps

    NAME             READY   DESIRED   EXECUTOR
hello-spinkube   2       2         containerd-shim-spin

Abrufen der Kubernetes-Grundtypen, die von der spin-operator erstellt werden

Bei der Bereitstellung erstellt der spin-operator zugrunde liegende Kubernetes-Grundtypen wie ein Service, eine Bereitstellung und entsprechende Pods.

  1. Rufen Sie die Liste der Dienste mithilfe des kubectl get service-Befehls ab.

    kubectl get service

    NAME             TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)   AGE
hello-spinkube   ClusterIP   10.43.35.78   <none>        80/TCP    24s

  2. Rufen Sie die Liste der Bereitstellungen mithilfe des kubectl get deployment-Befehls ab.

    kubectl get deployment

    NAME             READY   UP-TO-DATE   AVAILABLE   AGE
hello-spinkube   2/2     2            2           38s

  3. Rufen Sie die Liste der Pods mithilfe des kubectl get pod-Befehls ab.

    kubectl get pod

    NAME                              READY   STATUS    RESTARTS   AGE
hello-spinkube-5b8579448d-zmc6x   1/1     Running   0          51s
hello-spinkube-5b8579448d-bhkp9   1/1     Running   0          51s

Aufrufen der Spin-App

Um die Spin-App aufzurufen, konfigurieren Sie die Portweiterleitung an den Dienst, der von der spin-operator bereitgestellt wird und curl zum Senden von HTTP-Anforderungen verwendet.

  1. Richten Sie die Portweiterleitung mithilfe des Befehls hello-spinkube an den kubectl port-forward-Dienst ein.

    kubectl port-forward svc/hello-spinkube 8080:80

    Forwarding from 127.0.0.1:8080 -> 80
Forwarding from [::1]:8080 -> 80

  2. Öffnen Sie eine neue Terminalinstanz und verwenden Sie den folgenden curl-Befehl, um eine HTTP-Anforderung an localhost:8080 zu senden.

    curl -iX GET localhost:8080

    HTTP/1.1 200 OK
content-type: text/plain
content-length: 17
date: Tue, 28 May 2024 08:55:50 GMT
Hello from JS-SDK

Bereinigen von Ressourcen

  1. Entfernen Sie die Spin-App mithilfe des kubectl delete-Befehls aus dem AKS-Cluster.

    kubectl delete spinapp hello-spinkube

  2. Entfernen Sie das docker-registry-Geheimnis (spinkube-on-aks) mithilfe des kubectl delete secret-Befehls.

    kubectl delete secret spinkube-on-aks

  3. Entfernen Sie die ACR-Instanz, die Sie als Teil dieses Tutorial mithilfe des az acr delete-Befehls erstellt haben.

    az acr delete --name <acr-name> --resource-group <resource-group-name> --yes

  4. Entfernen Sie die SpinKube-Komponenten aus dem AKS-Cluster mithilfe der folgenden Befehle.

    # Remove the spin-operator
helm delete spin-operator --namespace spin-operator

# Remove the SpinAppExecutor
kubectl delete -f https://github.com/spinframework/spin-operator/releases/download/v0.5.0/spin-operator.shim-executor.yaml

# Remove the RuntimeClass for Spin
kubectl delete -f https://github.com/spinframework/spin-operator/releases/download/v0.5.0/spin-operator.runtime-class.yaml

# Remove the SpinKube CRDs
kubectl delete -f https://github.com/spinframework/spin-operator/releases/download/v0.5.0/spin-operator.crds.yaml

# Remove runtime-class-manager (also known as KWasm)
helm delete kwasm-operator --namespace kwasm

# Remove cert-manager Helm Release
helm delete cert-manager --namespace cert-manager

# Remove cert-manager CRDs
kubectl delete -f https://github.com/cert-manager/cert-manager/releases/download/v1.14.3/cert-manager.crds.yaml

Nächste Schritte

In diesem Artikel haben Sie erfahren, wie Sie SpinKube für Azure Kubernetes Service (AKS) bereitstellen, um serverlose WebAssembly-Workloads (Wasm) auszuführen. Weitere Arbeitsauslastungen auf AKS finden Sie in den folgenden Artikeln: