Delen via

SpinKube implementeren in Azure Kubernetes Service (AKS) om serverloze WebAssembly-workloads (Wasm) uit te voeren

  • Artikel

In dit artikel leest u hoe u SpinKube implementeert in Azure Kubernetes Service (AKS) om serverloze WebAssembly-workloads (Wasm) uit te voeren.

Overzicht

WebAssembly (Wasm) is een binaire indeling die is geoptimaliseerd voor snelle download- en bijna-systeemeigen uitvoeringssnelheid. Deze wordt uitgevoerd in een sandbox die is geïsoleerd van de hostcomputer die wordt geleverd door een Wasm-runtime. WebAssembly-modules hebben standaard geen toegang tot resources, waaronder sockets en omgevingsvariabelen, op de host buiten de sandbox, tenzij ze expliciet zijn toegestaan. De WASI-standaard (WebAssembly System Interface) definieert een set interfaces voor Wasm-runtimes om toegang te bieden tot WebAssembly-modules voor de omgeving en resources buiten de host met behulp van een op mogelijkheden gebaseerd beveiligingsmodel.

SpinKube is een opensource-project dat serverloze Wasm-workloads (Spin Apps) uitvoert die zijn gebouwd met opensource Spin in Kubernetes. In tegenstelling tot eerdere Wasm-runtimes voor Kubernetes, voert SpinKube systeemeigen Spin-apps uit op de onderliggende Kubernetes-knooppunten en is niet afhankelijk van containers. Spin-apps zijn reguliere Wasm-modules die zijn afgestemd op de specificatie van het WebAssembly-onderdeelmodel .

Door Spin Apps uit te voeren op Kubernetes met SpinKube, kunt u de volgende werkbelastingen uitvoeren:

  • Voer Wasm-workloads uit naast bestaande toepassingen in containers.
  • Vergelijkbare workloads uitvoeren terwijl er minder resources worden verbruikt.
  • Voer meer workloads uit op een bepaalde set resources.
  • Werkbelastingen uitvoeren op verschillende architecturen (zoals amd64 en arm64) zonder ze kruislings te compileren.

SpinKube bestaat uit twee onderdelen op het hoogste niveau:

  • spin-operator: Een Kubernetes-operator die de implementatie en het beheer van Spin Apps toestaat met behulp van aangepaste resources.
  • kube invoegtoepassing voor spin: een spin CLI-invoegtoepassing waarmee gebruikers kubernetes-implementatiemanifesten voor Spin Apps kunnen opzetten.

Vereisten

Beperkingen

  • Het Kubernetes-knooppunt os-type moet Linux zijn.
  • U kunt Azure Portal niet gebruiken om SpinKube te implementeren in een AKS-cluster.

SpinKube implementeren in een bestaand cluster

Verbinding maken met uw AKS-cluster

  • Configureer kubectl deze om verbinding te maken met uw Kubernetes-cluster met behulp van de az aks get-credentials opdracht.

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

Implementeren cert-manager

Als u nog niet in uw AKS-cluster hebt geïmplementeerd cert-manager , kunt u het installeren door de aangepaste resourcedefinities (CRD's) te implementeren, gevolgd door de cert-manager Helm-grafiek die via de jetstack opslagplaats is opgegeven.

  1. Implementeer de cert-manager CRD's en Helm-grafiek met behulp van de kubectl apply opdracht.

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

  2. Voeg de Jetstack-opslagplaats toe en werk deze bij met behulp van de helm repo add en helm repo update opdrachten.

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

  3. Installeer de cert-manager Helm-grafiek met behulp van de helm install opdracht.

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

Implementeren runtime-class-manager (ook wel KWasm genoemd)

De runtime-class-manager (ook wel KWasm genoemd) is verantwoordelijk voor het implementeren en beheren containerd-shim van de gewenste Kubernetes-knooppunten.

  1. Voeg de KWasm Helm-opslagplaats toe met behulp van de helm repo add opdracht.

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

  2. Installeer de KWasm-operator met behulp van de helm install opdracht.

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

Containerd-shim-spin inrichten voor Kubernetes-knooppunten

Zodra runtime-class-manager deze is geïnstalleerd op uw AKS-cluster, moet u aantekeningen toevoegen aan de Kubernetes-knooppunten waarmee Spin-apps kwasm.sh/kwasm-node=truekunnen worden uitgevoerd. U kunt alle kubectl annotate node knooppunten of alleen specifieke knooppunten in uw AKS-cluster aantekenen. In dit voorbeeld maken we aantekeningen op alle knooppunten in het AKS-cluster met de kwasm.sh/kwasm-node=true aantekening.

  1. Inrichten containerd-shim-spin voor alle knooppunten in het AKS-cluster met behulp van de kubectl annotate node --all opdracht.

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

  2. Nadat u aantekeningen hebt gemaakt bij de Kubernetes-knooppunten, runtime-class-manager gebruikt u een Kubernetes-taak om de gewenste knooppunten te wijzigen. Na een geslaagde implementatie worden containerd-shim-spinde knooppunten gelabeld met een kwasm.sh/kwasm-provisioned label. U kunt controleren of aan de gewenste knooppunten het kwasm.sh/kwasm-provisioned label is toegewezen met behulp van de kubectl get nodes --show-labels opdracht.

    kubectl get nodes --show-labels

Implementeer de spin-operator

Het spin-operator bestaat uit twee aangepaste resourcedefinities (CRD's) die u moet implementeren in uw AKS-cluster: de RuntimeClass voor spin en een SpinAppExecutor.

  1. Implementeer de CRD's en de RuntimeClass voor spin het gebruik van de kubectl apply opdracht.

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

  2. Implementeer de spin-operator opdracht met behulp van de helm install opdracht.

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

  3. Maak een SpinAppExecutor in de standaardnaamruimte met behulp van de kubectl apply opdracht.

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

Een spin-app uitvoeren op AKS

In deze sectie controleert u de Installatie van SpinKube door een eenvoudige Spin-app te maken met behulp van de spin CLI en JavaScript.

Een nieuwe spin-app maken

  1. Maak een nieuwe Spin-app met behulp van de spin new opdracht met de http-js sjabloon.

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

  2. Ga naar de hello-spinkube map met behulp van de cd opdracht.

    cd hello-spinkube

  3. Installeer de afhankelijkheden met behulp van de npm install opdracht.

    npm install

  4. Gebruik de spin CLI om een eenvoudige Hallo wereld-toepassing te maken.

    spin build

Containerregister maken en de spin CLI verifiëren

  1. Spin-apps worden verpakt als OCI-artefacten en gedistribueerd via een OCI-compatibel register, zoals Azure Container Registry (ACR). Maak een nieuw ACR-exemplaar met behulp van de az acr create opdracht.

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

  2. Haal het eindpunt van de ACR-aanmeldingsserver en het beheerderswachtwoord op met behulp van de az acr show en az acr credential show opdrachten.

    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. Verifieer uw spin CLI met behulp van de spin registry login opdracht.

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

De Spin-app verpakken, distribueren en implementeren

  1. Nu de spin CLI is geverifieerd voor het ACR-exemplaar, kunt u de Spin-app verpakken en distribueren met behulp van de spin registry push opdracht gevolgd door een OCI-artefactverwijzing (die het <your acr login server>/<repository-name>:<tag> naamgevingsschema volgt).

    spin registry push $ACR_LOGIN_SERVER/hello-spinkube:0.0.1

  2. Maak een Kubernetes-geheim van het type docker-registry om te verwijzen tijdens de implementatie van de Spin-app naar uw AKS-cluster met behulp van de kubectl create secret opdracht. In dit voorbeeld heeft het geheim de naam 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. Maak de benodigde Kubernetes-implementatiemanifesten met behulp van de spin kube scaffold opdracht.

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

    Het spinapp.yaml bestand bevat een vooraf geconfigureerd exemplaar van de SpinApp CRD. Dit moet er als volgt uitzien:

    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. Implementeer de Spin-app in het AKS-cluster met behulp van de kubectl apply opdracht.

    kubectl apply -f spinapp.yaml

De spin-app in AKS verkennen

De lijst met spin-apps ophalen

  • Haal de lijst met Spin-apps op met behulp van de kubectl get spinapps opdracht.

    kubectl get spinapps

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

Haal de Kubernetes-primitieven op die zijn gemaakt door de spin-operator

Bij de spin-operator implementatie worden onderliggende Kubernetes-primitieven gemaakt, zoals een service, een implementatie en bijbehorende pods.

  1. Haal de lijst met services op met behulp van de kubectl get service opdracht.

    kubectl get service

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

  2. Haal de lijst met implementaties op met behulp van de kubectl get deployment opdracht.

    kubectl get deployment

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

  3. Haal de lijst met pods op met behulp van de kubectl get pod opdracht.

    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

De spin-app aanroepen

Als u de Spin-app wilt aanroepen, configureert u port-forwarding naar de service die door de spin-operator service is ingericht en gebruikt curl voor het verzenden van HTTP-aanvragen.

  1. Stel port forwarding in naar de hello-spinkube service met behulp van de kubectl port-forward opdracht.

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

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

  2. Open een nieuw terminalexemplaren en gebruik de volgende curl opdracht om een HTTP-aanvraag naar te localhost:8080verzenden.

    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

Resources opschonen

  1. Verwijder de Spin-app uit het AKS-cluster met behulp van de kubectl delete opdracht.

    kubectl delete spinapp hello-spinkube

  2. Verwijder het docker-registry Secret (spinkube-on-aks) met behulp van de kubectl delete secret opdracht.

    kubectl delete secret spinkube-on-aks

  3. Verwijder het ACR-exemplaar dat u hebt gemaakt als onderdeel van deze zelfstudie met behulp van de az acr delete opdracht.

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

  4. Verwijder de SpinKube-onderdelen uit het AKS-cluster met behulp van de volgende opdrachten.

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

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

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

# Remove the SpinKube CRDs
kubectl delete -f https://github.com/spinkube/spin-operator/releases/download/v0.2.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

Volgende stappen

In dit artikel hebt u geleerd hoe u SpinKube implementeert in Azure Kubernetes Service (AKS) om serverloze WebAssembly-workloads (Wasm) uit te voeren. Zie de volgende artikelen voor het implementeren van meer workloads op AKS: