Compartir a través de

Implementación de SpinKube en Azure Kubernetes Service (AKS) para ejecutar cargas de trabajo WebAssembly (Wasm) sin servidor

En este artículo se muestra cómo implementar SpinKube en Azure Kubernetes Service (AKS) para ejecutar cargas de trabajo WebAssembly (Wasm) sin servidor.

Información general

WebAssembly (Wasm) es un formato binario optimizado para la descarga rápida y la velocidad de ejecución casi nativa. Se ejecuta en un espacio aislado del equipo host proporcionado por un runtime de Wasm. De forma predeterminada, los módulos WebAssembly no pueden acceder a los recursos, incluidos los sockets y las variables de entorno en el host fuera del espacio aislado, a menos que se permitan explícitamente. El estándar de WebAssembly System Interface (WASI) define un conjunto de interfaces para que los runtime de Wasm proporcionen acceso a los módulos de WebAssembly al entorno y los recursos fuera del host mediante un modelo de seguridad basado en funcionalidades.

SpinKube es un proyecto de código abierto que ejecuta cargas de trabajo Wasm sin servidor (Spin Apps) compiladas con Spin de código abierto en Kubernetes. A diferencia de los runtime anteriores de Wasm para Kubernetes, SpinKube ejecuta Spin Apps de forma nativa en los nodos de Kubernetes subyacentes y no se basa en contenedores. Spin Apps son módulos Wasm normales que se alinean con la especificación del modelo de componentes de WebAssembly.

Al ejecutar Spin Apps en Kubernetes con SpinKube, puede ejecutar las siguientes cargas de trabajo:

  • Ejecute cargas de trabajo de Wasm junto a las aplicaciones en contenedores existentes.
  • Ejecute cargas de trabajo similares mientras consume menos recursos.
  • Ejecute más cargas de trabajo en un conjunto determinado de recursos.
  • Ejecute cargas de trabajo en distintas arquitecturas (como amd64 y arm64) sin compilarlas entre sí.

SpinKube consta de dos componentes de nivel superior:

  • spin-operator: un operador de Kubernetes que permite la implementación y administración de Spin Apps mediante recursos personalizados.
  • Complemento de kube para spin: un complemento de la CLI de spin que permite a los usuarios aplicar scaffolding a los manifiestos de implementación de Kubernetes para Spin Apps.

Requisitos previos

Limitaciones

  • El nodo os-type de Kubernetes debe ser Linux.
  • No puede usar Azure Portal para implementar SpinKube en un clúster de AKS.

Implementación de SpinKube en un clúster existente

Conectarse al clúster AKS

  • Para configurar kubectl para conectarse a su clúster de Kubernetes, use el comando az aks get-credentials.

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

Implementar cert-manager

Si aún no ha implementado cert-manager en el clúster de AKS, puede instalarlo mediante la implementación de sus definiciones de recursos personalizados (CRD) seguidas del gráfico de Helm de cert-manager proporcionado a través del repositorio jetstack.

  1. Implemente los CRD y el gráfico de Helm de cert-manager mediante el comando kubectl apply.

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

  2. Agregue y actualice el repositorio de Jetstack mediante los comandos helm repo add y helm repo update.

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

  3. Instale el gráfico de Helm de cert-manager mediante el comando helm install.

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

Implementación de runtime-class-manager (también conocida como KWasm)

runtime-class-manager (también conocido como KWasm) es responsable de implementar y administrar containerd-shim en los nodos de Kubernetes deseados.

  1. Agregue el repositorio de Helm de KWasm mediante el comando helm repo add.

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

  2. Instale el operador KWasm mediante el comando 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

Aprovisionar containerd-shim-spin en nodos de Kubernetes

Una vez runtime-class-manager está instalado en el clúster de AKS, debe anotar los nodos de Kubernetes que deben poder ejecutar Spin Apps con kwasm.sh/kwasm-node=true. Puede usar kubectl annotate node para anotar todos los nodos o solo nodos específicos del clúster de AKS. En este ejemplo, anotamos todos los nodos del clúster de AKS con la anotación kwasm.sh/kwasm-node=true.

  1. Aprovisione containerd-shim-spin en todos los nodos del clúster de AKS mediante el comando kubectl annotate node --all.

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

  2. Después de anotar los nodos de Kubernetes, runtime-class-manager usa un trabajo de Kubernetes para modificar los nodos deseados. Después de una implementación correcta de containerd-shim-spin, los nodos se etiquetan con una etiqueta kwasm.sh/kwasm-provisioned. Puede comprobar si los nodos deseados tienen asignada la etiqueta kwasm.sh/kwasm-provisioned mediante el comando kubectl get nodes --show-labels.

    kubectl get nodes --show-labels

Implementación del spin-operator

spin-operator consta de dos definiciones de recursos personalizadas (CRD) que debe implementar en el clúster de AKS: RuntimeClass para spin y SpinAppExecutor.

  1. Implemente los CRD y RuntimeClass para spin mediante el comando 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. Implemente spin-operator mediante el comando helm install.

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

  3. Cree un SpinAppExecutor en el espacio de nombres predeterminado mediante el comando kubectl apply.

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

Ejecución de una aplicación Spin en AKS

En esta sección, comprobará la instalación de SpinKube mediante la creación de una aplicación de Spin simple mediante la CLI de spin y JavaScript.

Creación de una nueva aplicación Spin

  1. Cree una nueva aplicación Spin mediante el comando spin new con la plantilla http-js.

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

  2. Vaya al directorio hello-spinkube mediante el comando cd.

    cd hello-spinkube

  3. Instale las dependencias mediante el comando npm install.

    npm install

  4. Use la CLI de spin para crear una aplicación básica Hello, World.

    spin build

Creación de un registro de contenedor y autenticación de la CLI de spin

  1. Spin Apps se empaqueta como artefactos de OCI y se distribuye a través de un registro compatible con OCI, como Azure Container Registry (ACR). Cree una instancia de ACR mediante el comando az acr create.

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

  2. Obtenga el punto de conexión del servidor de inicio de sesión de ACR y la contraseña de administrador mediante los comandos az acr show y 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. Autentique la CLI de spin mediante el comando spin registry login.

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

Empaquetar, distribuir e implementar la aplicación App

  1. Ahora que la CLI de spin se autentica en la instancia de ACR, puede empaquetar y distribuir la aplicación Spin mediante el comando spin registry push seguido de una referencia de artefacto de OCI (que sigue al esquema de nomenclatura <your acr login server>/<repository-name>:<tag>).

    spin registry push $ACR_LOGIN_SERVER/hello-spinkube:0.0.1

  2. Cree un secreto de Kubernetes de tipo docker-registry para hacer referencia durante la implementación de la aplicación Spin en el clúster de AKS mediante el comando kubectl create secret. En este ejemplo, el secreto se llama 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. Cree los manifiestos de implementación de Kubernetes necesarios mediante el comando spin kube scaffold.

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

    El archivo spinapp.yaml contiene una instancia preconfigurada del CRD SpinApp, que debería tener este aspecto:

    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. Implemente la aplicación Spin en el clúster de AKS mediante el comando kubectl apply.

    kubectl apply -f spinapp.yaml

Exploración de la aplicación Spin en AKS

Recuperar la lista de Spin Apps

  • Recuperar la lista de Spin Apps mediante el comando kubectl get spinapps.

    kubectl get spinapps

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

Recuperación de los primitivos de Kubernetes creados por spin-operator

Tras la implementación, spin-operator crea primitivos de Kubernetes subyacentes, como un servicio, una implementación y los pods correspondientes.

  1. Recupere la lista de servicios mediante el comando 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. Recupere la lista de implementaciones mediante el comando kubectl get deployment.

    kubectl get deployment

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

  3. Recupere la lista de pods mediante el comando 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

Invocación de la aplicación Spin

Para invocar la aplicación Spin, configure el reenvío de puertos al servicio aprovisionado por spin-operator y use curl para enviar solicitudes HTTP.

  1. Establezca el enrutamiento de puertos al servicio hello-spinkube mediante el comando 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. Abra una nueva instancia de terminal y use el comando curl siguiente para enviar una solicitud HTTP a 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

Limpieza de recursos

  1. Quite la aplicación Spin del clúster de AKS mediante el comando kubectl delete.

    kubectl delete spinapp hello-spinkube

  2. Quite el secreto docker-registry (spinkube-on-aks) mediante el comando kubectl delete secret.

    kubectl delete secret spinkube-on-aks

  3. Quite la instancia de ACR que creó como parte de este tutorial mediante el comando az acr delete.

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

  4. Quite los componentes SpinKube del clúster de AKS mediante los siguientes comandos.

    # 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

Pasos siguientes

En este artículo, ha aprendido a implementar SpinKube en Azure Kubernetes Service (AKS) para ejecutar cargas de trabajo WebAssembly (Wasm) sin servidor. Para implementar más cargas de trabajo en AKS, consulte los artículos siguientes:

  • Last updated on