Partilhar via

Implantar o SpinKube no Serviço Kubernetes do Azure (AKS) para executar cargas de trabalho WebAssembly (Wasm) sem servidor

Este artigo mostra como implantar o SpinKube no Serviço Kubernetes do Azure (AKS) para executar cargas de trabalho WebAssembly (Wasm) sem servidor.

Descrição geral

WebAssembly (Wasm) é um formato binário otimizado para download rápido e velocidade de execução quase nativa. É executado numa sandbox isolada do computador anfitrião, fornecida por um tempo de execução Wasm. Por padrão, os módulos WebAssembly não podem acessar recursos, incluindo soquetes e variáveis de ambiente, no host fora da área restrita, a menos que sejam explicitamente permitidos. O padrão WebAssembly System Interface (WASI) define um conjunto de interfaces para tempos de execução do Wasm para fornecer acesso aos módulos WebAssembly para o ambiente e recursos fora do host usando um modelo de segurança baseado em recursos.

O SpinKube é um projeto de código aberto que executa tarefas Wasm sem servidor (Spin Apps) construídas com o Spin de código aberto no Kubernetes. Em contraste com os tempos de execução anteriores do Wasm para Kubernetes, o SpinKube executa Spin Apps nativamente nos nós subjacentes do Kubernetes e não depende de contêineres. Spin Apps são módulos Wasm regulares que se alinham com a especificação do Modelo de Componente WebAssembly.

Ao executar Spin Apps no Kubernetes com o SpinKube, você pode executar as seguintes cargas de trabalho:

  • Execute cargas de trabalho do Wasm ao lado de aplicativos em contêineres existentes.
  • Execute cargas de trabalho semelhantes enquanto consome menos recursos.
  • Execute mais cargas de trabalho em um determinado conjunto de recursos.
  • Execute cargas de trabalho em arquiteturas diferentes (como amd64 e arm64) sem compilá-las cruzadamente.

O SpinKube consiste em dois componentes de nível superior:

  • spin-operator: Um operador Kubernetes que permite a implantação e o gerenciamento de Spin Apps usando recursos personalizados.
  • kube plugin para spin: Um spin plugin CLI que permite aos utilizadores estruturar manifestos de implementação para o Kubernetes para as Spin Apps.

Pré-requisitos

  • Versão 2.64.0 do Azure CLI ou posterior. Para instalar ou atualizar, consulte Instalar a CLI do Azure.
  • kubectl versão 1.31.0 ou posterior.
  • helm versão 3.15.4 ou posterior.
  • spin versão 3.0.0 ou posterior.
  • Node.js versão 21.6.2.
  • Um cluster AKS existente. Caso não tenhas um, consulta Criar um cluster AKS.

Limitações

  • O nó os-type Kubernetes deve ser baseado em Linux.
  • Você não pode usar o portal do Azure para implantar o SpinKube em um cluster AKS.

Implantar o SpinKube em um cluster existente

Conecte-se ao cluster AKS

  • Configure kubectl para se conectar ao cluster do Kubernetes usando o az aks get-credentials comando.

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

Implantar cert-manager

Se você ainda não implantou cert-manager no cluster AKS, pode instalá-lo implantando suas Definições de Recursos Personalizados (CRDs) seguidas pelo cert-manager gráfico Helm fornecido pelo jetstack repositório.

  1. Implante os CRDs e o cert-manager gráfico Helm usando o kubectl apply comando.

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

  2. Adicione e atualize o repositório Jetstack usando os comandos helm repo add e helm repo update.

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

  3. Instale o gráfico Helm cert-manager usando o comando helm install.

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

Deploy runtime-class-manager (também conhecido como KWasm)

O runtime-class-manager (também conhecido como KWasm) é responsável por implantar e gerenciar containerd-shim nos nós desejados do Kubernetes.

  1. Adicione o repositório KWasm Helm usando o helm repo add comando.

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

  2. Instale o operador KWasm usando o helm install comando.

    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

Configurar containerd-shim-spin em nós de Kubernetes

Uma vez runtime-class-manager instalado no cluster AKS, você deve anotar os nós do Kubernetes que devem ser capazes de executar Spin Apps com kwasm.sh/kwasm-node=true. Você pode usar kubectl annotate node para anotar todos os nós ou apenas nós específicos em seu cluster AKS. Neste exemplo, anotamos todos os nós no cluster AKS com a anotação kwasm.sh/kwasm-node=true.

  1. Provisionar containerd-shim-spin para todos os nós no cluster AKS usando o comando kubectl annotate node --all.

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

  2. Depois de anotar os nós do Kubernetes, runtime-class-manager utiliza um Job do Kubernetes para modificar os nós desejados. Após a implantação bem-sucedida do containerd-shim-spin, os nós são rotulados com kwasm.sh/kwasm-provisioned. Você pode verificar se os nós desejados têm o kwasm.sh/kwasm-provisioned rótulo atribuído usando o kubectl get nodes --show-labels comando.

    kubectl get nodes --show-labels

Implante o spin-operator

O spin-operator consiste em duas Definições de Recursos Personalizados (CRDs) que você precisa implantar em seu cluster AKS: o RuntimeClass for spin e um SpinAppExecutor.

  1. Implemente os CRDs e o RuntimeClass para spin, utilizando o 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. Implante o spin-operator usando o helm install comando.

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

  3. Crie um SpinAppExecutor no namespace padrão usando o kubectl apply comando.

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

Executar uma aplicação Spin no AKS

Nesta seção, verifica-se a instalação do SpinKube criando um aplicativo Spin simples, utilizando a CLI e o JavaScript spin.

Criar um novo aplicativo Spin

  1. Crie um novo aplicativo Spin usando o spin new comando com o http-js modelo.

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

  2. Mude para o hello-spinkube diretório usando o cd comando.

    cd hello-spinkube

  3. Instale as dependências usando o npm install comando.

    npm install

  4. Use a spin CLI para criar um aplicativo básico Hello, World .

    spin build

Criar registro de contêiner e autenticar a spin CLI

  1. Os Aplicativos Spin são empacotados como artefatos OCI e distribuídos por meio de um registro compatível com OCI, como o Azure Container Registry (ACR). Crie uma nova instância ACR usando o az acr create comando.

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

  2. Obtenha o ponto de extremidade do servidor de login ACR e a senha de administrador usando os comandos az acr show e 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 sua spin CLI usando o spin registry login comando.

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

Empacotar, distribuir e implantar o aplicativo Spin

  1. Agora que a CLI está autenticada spin na instância ACR, você pode empacotar e distribuir o Spin App usando o spin registry push comando seguido por uma referência de artefato OCI (que segue o <your acr login server>/<repository-name>:<tag> esquema de nomenclatura).

    spin registry push $ACR_LOGIN_SERVER/hello-spinkube:0.0.1

  2. Crie um Kubernetes Secret do tipo docker-registry para referência durante a implantação do Spin App no seu cluster AKS usando o kubectl create secret comando. Neste exemplo, o segredo é chamado 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. Crie os manifestos de implantação do Kubernetes necessários usando o spin kube scaffold comando.

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

    O spinapp.yaml arquivo contém uma instância pré-configurada do SpinApp CRD, que deve ter esta aparência:

    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. Implante o Spin App no cluster AKS usando o kubectl apply comando.

    kubectl apply -f spinapp.yaml

Explore a aplicação Spin no AKS

Recuperar a lista de Spin Apps

  • Recupere a lista de Spin Apps usando o kubectl get spinapps comando.

    kubectl get spinapps

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

Recupere as primitivas do Kubernetes criadas pelo spin-operator

Após a implantação, o spin-operator cria primitivas subjacentes do Kubernetes, como um Serviço, uma Implantação e Pods correspondentes.

  1. Recupere a lista de serviços usando o kubectl get service comando.

    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 a lista de implantações usando o kubectl get deployment comando.

    kubectl get deployment

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

  3. Recupere a lista de pods usando o kubectl get pod comando.

    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

Invoque o aplicativo Spin

Para invocar o Spin App, configure o encaminhamento de porta para o serviço provisionado spin-operator pelo e use curl para enviar solicitações HTTP.

  1. Estabeleça o encaminhamento de porta para o serviço hello-spinkube usando o 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 uma nova instância de terminal e use o seguinte curl comando para enviar uma solicitação HTTP para 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

Limpar recursos

  1. Remova o aplicativo Spin do cluster AKS usando o kubectl delete comando.

    kubectl delete spinapp hello-spinkube

  2. Remova o Secret docker-registry (spinkube-on-aks) usando o comando kubectl delete secret.

    kubectl delete secret spinkube-on-aks

  3. Remova a instância ACR que você criou como parte deste tutorial usando o az acr delete comando.

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

  4. Remova os componentes SpinKube do cluster AKS usando os seguintes 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

Próximos passos

Neste artigo, você aprendeu como implantar o SpinKube no Serviço Kubernetes do Azure (AKS) para executar cargas de trabalho WebAssembly (Wasm) sem servidor. Para implantar mais cargas de trabalho no AKS, consulte os seguintes artigos:

  • Last updated on