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

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

Visão geral

O Wasm (WebAssembly) é um formato binário otimizado para download rápido e velocidade de execução quase nativa. Ele é executado em uma área restrita isolada do computador host fornecido por um runtime do Wasm. Por padrão, os módulos do 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 WASI (WebAssembly System Interface) define um conjunto de interfaces para que os runtimes do Wasm forneçam acesso aos módulos do WebAssembly ao ambiente e aos recursos fora do host usando um modelo de segurança baseado em recursos.

O SpinKube é um projeto de código aberto que executa cargas de trabalho do Wasm sem servidor (aplicativos Spin) criadas com Spin de código aberto no Kubernetes. Em contraste com os runtimes anteriores do Wasm para Kubernetes, o SpinKube executa aplicativos Spin nativamente nos nós subjacentes do Kubernetes e não depende de contêineres. Os aplicativos Spin são módulos do Wasm regulares que se alinham à especificação do modelo de componente WebAssembly.

Ao executar aplicativos Spin no Kubernetes com o SpinKube, você poderá executar as seguintes cargas de trabalho:

• Executar cargas de trabalho do Wasm ao lado de aplicativos em contêineres existentes.
• Executar cargas de trabalho semelhantes ao consumir menos recursos.
• Executar mais cargas de trabalho em um determinado conjunto de recursos.
• Executar cargas de trabalho em arquiteturas diferentes (como amd64 e arm64) sem compilação cruzada.

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

• spin-operator: um operador Kubernetes que permite a implantação e o gerenciamento de aplicativos Spin usando recursos personalizados.
• Plug-in kube para spin: um plug-in de CLI spin que permite aos usuários criar manifestos de implantação do Kubernetes para aplicativos Spin.

Pré-requisitos

• CLI do Azure versão 2.64.0 ou posterior. Para instalar ou atualizar, confira 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 novo ou existente. Se você não tiver um, confira Criar um cluster do AKS.

Limitações

• O nó os-type do Kubernetes deve ser Linux.
• Não é possível usar o portal do Azure para implantar o SpinKube em um cluster do AKS.

Implantar o SpinKube em um cluster existente

Conectar-se ao cluster do AKS

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

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

Implantar cert-manager

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

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

   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 do 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
   

Implantar 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 do Kubernetes desejados.

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

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

2. Instale o operador do KWasm usando o 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
   

Provisionar containerd-shim-spin para nós do Kubernetes

Depois que runtime-class-manager for instalado em seu cluster do AKS, você deverá anotar os nós do Kubernetes que poderão executar aplicativos Spin com kwasm.sh/kwasm-node=true. Você pode usar kubectl annotate node para anotar todos os nós ou apenas nós específicos no cluster do AKS. Nesse exemplo, anotamos todos os nós no cluster do AKS com a anotação kwasm.sh/kwasm-node=true.

1. Provisione containerd-shim-spin para todos os nós no cluster do 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 usa um Trabalho do Kubernetes para modificar os nós desejados. Após a implantação bem-sucedida de containerd-shim-spin, os nós serão rotulados com um rótulo kwasm.sh/kwasm-provisioned. Você pode verificar se os nós desejados têm o rótulo kwasm.sh/kwasm-provisioned atribuído usando o comando kubectl get nodes --show-labels.

   kubectl get nodes --show-labels
   

Implantar o spin-operator

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

1. Implante as CRDs e o RuntimeClass para spin usando 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 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. Crie um SpinAppExecutor no namespace padrão usando o comando kubectl apply.

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

Executar um aplicativo Spin no AKS

Nesta seção, você verificará a instalação do SpinKube criando um aplicativo Spin simples usando a CLI spin e o JavaScript.

Criar um novo aplicativo Spin

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

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

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

   cd hello-spinkube
   

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

   npm install
   

4. Use a CLI spin para criar um aplicativo Olá, Mundo básico.

   spin build
   

Criar registro de contêiner e autenticar a CLI spin

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

   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 logon do 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 CLI spin usando o comando spin registry login.

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

Empacotar, distribuir e implantar o aplicativo Spin

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

   spin registry push $ACR_LOGIN_SERVER/hello-spinkube:0.0.1
   

2. Crie um Segredo do Kubernetes do tipo docker-registry para referenciar durante a implantação do aplicativo Spin no cluster do AKS usando o comando kubectl create secret. 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 comando spin kube scaffold.

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

   O arquivo spinapp.yaml contém uma instância pré-configurada do CRD SpinApp, 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 aplicativo Spin no cluster do AKS usando o comando kubectl apply.

   kubectl apply -f spinapp.yaml
   

Explorar o aplicativo Spin no AKS

Recuperar a lista de aplicativos Spin

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

  kubectl get spinapps
  

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

Recuperar os primitivos do Kubernetes criados pelo spin-operator

Após a implantação, spin-operator cria primitivos subjacentes do Kubernetes, como um serviço, uma implantação e os pods correspondentes.

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

   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 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
   

Invocar o aplicativo Spin

Para invocar o aplicativo Spin, configure o encaminhamento de porta para o serviço provisionado pelo spin-operator 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 comando curl a seguir 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 os recursos

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

   kubectl delete spinapp hello-spinkube
   

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

   kubectl delete secret spinkube-on-aks
   

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

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

4. Remova os componentes do SpinKube do cluster do AKS usando os comandos a seguir.

   # 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óximas etapas

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

• Implantar um cluster do MongoDB no AKS (Serviço de Kubernetes do Azure)
• Implantar um banco de dados PostgreSQL no AKS (Serviço de Kubernetes do Azure)