Partager via

Déployer SpinKube sur Azure Kubernetes Service (AKS) pour exécuter des charges de travail WebAssembly serverless (Wasm)

Cet article explique comment déployer SpinKube sur Azure Kubernetes Service (AKS) pour exécuter des charges de travail WebAssembly (Wasm) serverless.

Vue d’ensemble

WebAssembly (Wasm) est un format binaire optimisé pour un téléchargement rapide et une vitesse d’exécution quasi instantanée. Il s’exécute dans un bac à sable isolé de l’ordinateur hôte fourni par un runtime Wasm. Par défaut, les modules WebAssembly ne peuvent pas accéder aux ressources, y compris les sockets et les variables d’environnement, sur l’hôte, en dehors du bac à sable, sauf si elles sont explicitement autorisées. La norme WebAssembly System Interface (WASI) définit un ensemble d’interfaces pour les runtimes WASM afin de garantir l’accès aux modules WebAssembly à l’environnement et aux ressources en dehors de l’hôte à l’aide d’un modèle de sécurité basé sur la fonctionnalité.

SpinKube est un projet open source qui exécute des charges de travail Wasm serverless (Spin Apps) créées avec Spin open source dans Kubernetes. Contrairement aux runtimes Wasm pour Kubernetes antérieurs, SpinKube exécute Spin Apps de façon native sur les nœuds Kubernetes sous-jacents et ne s’appuie pas sur des conteneurs. Les modules Spin Apps sont des modules Wasm standard qui s’alignent sur la spécification Modèle de composant WebAssembly.

En exécutant Spin Apps sur Kubernetes avec SpinKube, vous pouvez exécuter les charges de travail suivantes :

  • Exécutez des charges de travail Wasm en regard des applications conteneurisées existantes.
  • Exécutez des charges de travail similaires tout en consommant moins de ressources.
  • Exécutez davantage de charges de travail sur un ensemble de ressources donné.
  • Exécutez des charges de travail sur différentes architectures (telles que amd64 et arm64) sans les compiler entre elles.

SpinKube se compose de deux composants de niveau supérieur :

  • spin-operator : Un opérateur Kubernetes permettant le déploiement et la gestion de Spin Apps à l’aide de ressources personnalisées.
  • kube plug-in pour spin : Un plug-in CLI spin permettant aux utilisateurs de générer des manifestes de déploiement Kubernetes pour Spin Apps.

Prérequis

Limites

  • Le nœud Kubernetes os-type doit être Linux.
  • Vous ne pouvez pas utiliser le portail Azure pour déployer SpinKube sur un cluster AKS.

Déployer SpinKube sur un cluster existant

Se connecter à votre cluster AKS

  • Configurez kubectl afin de vous connecter à votre cluster Kubernetes avec la commande az aks get-credentials.

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

Déployer cert-manager

Si vous n’avez pas encore déployé cert-manager sur votre cluster AKS, vous pouvez l’installer en déployant ses définitions de ressources personnalisées (CRD) suivie du graphique Helm cert-manager fourni via le référentiel jetstack.

  1. Déployez les définitions de ressources personnalisées (CRD) et le graphique Helm de cert-manager à l’aide de la commande kubectl apply.

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

  2. Ajoutez et mettez à jour le référentiel Jetstack à l’aide des commandes helm repo add et helm repo update.

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

  3. Installez un graphique Helm cert-manager en utilisant la commande helm install.

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

Déployer runtime-class-manager (également appelé KWasm)

Le runtime-class-manager (également appelé KWasm) est responsable du déploiement et de la gestion des containerd-shim sur les nœuds Kubernetes souhaités.

  1. Ajoutez le référentiel Helm KWasm en utilisant la commande helm repo add.

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

  2. Installez l’opérateur KWasm à l’aide de la commande 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

Provisionner containerd-shim-spin sur les nœuds Kubernetes

Une fois runtime-class-manager installé sur votre cluster AKS, vous devez annoter les nœuds Kubernetes qui doivent être en mesure d’exécuter Spin Apps avec kwasm.sh/kwasm-node=true. Vous pouvez utiliser kubectl annotate node pour annoter tous les nœuds ou uniquement des nœuds spécifiques dans votre cluster AKS. Dans cet exemple, nous annotons tous les nœuds du cluster AKS avec l’annotation kwasm.sh/kwasm-node=true.

  1. Provisionnez containerd-shim-spin à tout les nœuds dans le cluster AKS à l’aide de la commande kubectl annotate node --all.

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

  2. Après avoir annoté les nœuds Kubernetes, runtime-class-manager utilise une tâche Kubernetes pour modifier les nœuds souhaités. Une fois le déploiement de containerd-shim-spin réussi, les nœuds sont étiquetés avec une étiquette kwasm.sh/kwasm-provisioned. Vous pouvez vérifier si les nœuds souhaités possèdent l’étiquette kwasm.sh/kwasm-provisioned affectée à l’aide de la commande kubectl get nodes --show-labels.

    kubectl get nodes --show-labels

Déployez le spin-operator

Le spin-operator se compose de deux définitions de ressources personnalisées (CRD) que vous devez déployer sur votre cluster AKS : RuntimeClass pour spin et un SpinAppExecutor.

  1. Déployez les CRD et le RuntimeClass pour spin à l’aide de la commande kubectl apply.

    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. Déployez le spin-operator à l’aide de la commande helm install.

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

  3. Créez un SpinAppExecutor dans l’espace de nom par défaut à l’aide de la commande kubectl apply.

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

Exécuter une Application Spin sur AKS

Dans cette section, vous vérifiez l’installation de SpinKube en créant une Application Spin simple à l’aide de l’interface CLI spin et JavaScript.

Créer une nouvelle Application Spin

  1. Créez une nouvelle Application Spin à l’aide de la commande spin new avec le modèle http-js.

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

  2. Changez pour le répertoire hello-spinkube en utilisant la commande cd.

    cd hello-spinkube

  3. Installez les dépendances en utilisant la commande npm install.

    npm install

  4. Utilisez l’interface CLI spin créer une application de base Hello, World.

    spin build

Créer un registre de conteneurs et authentifier l’interface CLI spin

  1. Les Applications Spin sont empaquetées en tant qu’artefacts OCI et distribuées via un registre conforme à OCI comme Azure Container Registry (ACR). Créez une nouvelle instance ACR à l’aide de la commande az acr create.

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

  2. Obtenez le point de terminaison du serveur de connexion ACR et le mot de passe administrateur à l’aide des commandes az acr show et az acr credential show.

    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. Authentifier votre CLI spin à l’aide de la commande spin registry login.

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

Empaqueter, distribuer et déployer l’Application Spin

  1. Maintenant que l’interface CLI spin est authentifiée sur l’instance ACR, vous pouvez empaqueter et distribuer l’Application Spin à l’aide de la commande spin registry push suivie d’une référence d’artefact OCI (qui suit le schéma d’affectation de noms <your acr login server>/<repository-name>:<tag>).

    spin registry push $ACR_LOGIN_SERVER/hello-spinkube:0.0.1

  2. Créez un secret Kubernetes de type docker-registry qui servira de point de référence pendant le déploiement de l’Application Spin sur votre cluster AKS à l’aide de la commande kubectl create secret. Dans cet exemple, le secret est nommé 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. Créez les manifestes de déploiement Kubernetes nécessaires à l’aide de la commande spin kube scaffold.

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

    Le fichier spinapp.yaml contient une instance préconfigurée du CRD SpinApp qui doit ressembler à ceci :

    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. Déployez l’Application Spin au cluster AKS à l’aide de la commande kubectl apply.

    kubectl apply -f spinapp.yaml

Explorer l’Application Spin dans AKS

Récupérez la liste des Applications Spin

  • Récupérez la liste des Applications Spin à l’aide de la commande kubectl get spinapps.

    kubectl get spinapps

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

Récupérez les primitives Kubernetes créées par le spin-operator

Lors du déploiement, le spin-operator crée des primitives Kubernetes sous-jacentes telles qu’un service, un Deployment et des pods correspondants.

  1. Récupérez la liste des services utilisant la commande kubectl get service.

    kubectl get service

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

  2. Récupérez la liste des déploiements à l’aide de la commande kubectl get deployment.

    kubectl get deployment

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

  3. Récupérez la liste des pods à l’aide de la commande kubectl get pod.

    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

Appeler l’application Spin

Pour appeler l’application Spin, vous configurez le transfert de port vers le service approvisionné par le spin-operator et utilisez curl pour envoyer des requêtes HTTP.

  1. Établissez le transfert de port vers le service hello-spinkube à l’aide de la commande kubectl port-forward.

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

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

  2. Ouvrez une nouvelle instance de terminal et utilisez la commande suivante curl pour envoyer une requête HTTP à localhost:8080.

    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

Nettoyer les ressources

  1. Supprimer l’Application Spin du cluster AKS à l’aide de la commande kubectl delete.

    kubectl delete spinapp hello-spinkube

  2. Supprimez le docker-registry secret (spinkube-on-aks) à l’aide de la commande kubectl delete secret.

    kubectl delete secret spinkube-on-aks

  3. Supprimez l’instance ACR que vous avez créée dans le cadre de ce didacticiel à l’aide de la commande az acr delete.

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

  4. Supprimez les composants SpinKube du cluster AKS à l’aide des commandes suivantes.

    # 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

Étapes suivantes

Dans cet article, vous avez appris comment déployer SpinKube sur Azure Kubernetes Service (AKS) pour exécuter des charges de travail WebAssembly (Wasm) serverless. Pour déployer davantage de charges de travail sur AKS, consultez les articles suivants :

  • Last updated on