Morioh
Login
Edgar Ssekabira

Edgar Ssekabira

11 months ago

Krustlet: um guia do desenvolvedor do Rust

Aprenda a usar o Krustlet para executar suas cargas de trabalho do Rust WebAssembly no Kubernetes. Este guia é perfeito para desenvolvedores Rust que desejam implantar seus aplicativos no Kubernetes.

À medida que o desenvolvimento nativo da nuvem continua a evoluir, novas ferramentas e tecnologias surgem para atender às demandas em constante mudança dos aplicativos modernos. Uma ferramenta que vem recebendo atenção é o Krustlet, uma implementação de kubelet escrita em Rust. Com seu foco exclusivo nas cargas de trabalho Wasm, o Krustlet oferece uma proposta intrigante para projetos Rust no ecossistema Kubernetes.

Neste artigo, demonstraremos como configurar o Krustlet e configurá-lo para funcionar com um cluster Kubernetes para executar cargas de trabalho do WebAssembly.

Pré-requisitos

Antes de começar a usar o Krustlet, verifique se você possui os seguintes pré-requisitos:

  • Um cluster Kubernetes em execução para implantar e gerenciar o Krustlet; você pode usar ou Kind para criar um cluster de desenvolvimento local para este tutorial
  • Docker instalado e devidamente configurado em sua máquina; o minikube utiliza o Docker como seu tempo de execução de contêiner padrão; O Docker é responsável por criar e executar aplicativos em contêiner dentro do minikube
  • kubectl instalado e configurado no seu dispositivo; kubectl é a ferramenta CLI usada para interagir com clusters Kubernetes, incluindo minikube

Conhecendo o Krustlet

Krustlet, que significa Kubernetes Rust kubelet, é um projeto de código aberto que fornece um Kubernetes kubelet implementado em Rust. Um kubelet é um agente de nó que funciona em segundo plano para garantir que os contêineres sejam executados conforme o esperado.

O Kruslet funciona como um nó no cluster Kubernetes, semelhante à forma como a maioria dos kubelets opera. Ele se comunica com o servidor da API do Kubernetes, recebe instruções de agendamento e executa as cargas de trabalho atribuídas. O recurso diferenciador do Krustlet é que ele pode lidar com cargas de trabalho Wasm, tornando-o ideal para cenários de computação de ponta.

O Krustlet foi projetado para ouvir no fluxo de eventos da API do Kubernetes novas solicitações de pod que correspondam a um conjunto específico de seletores de nó. Ele agenda essas cargas de trabalho para serem executadas usando um tempo de execução baseado em WASI em vez de um tempo de execução baseado em contêiner. Isso permite que as cargas de trabalho sejam escritas em qualquer linguagem que seja compilada para o Wasm e executada no ecossistema do Kubernetes, essencialmente tratando o Wasm como um cidadão de primeira classe.

Entendendo os conceitos básicos

Wasm é um formato de instrução binária projetado como um destino portátil para compilar linguagens de alto nível, como Rust, C e C++. Ele permite que os aplicativos sejam executados em um navegador da Web em velocidade quase nativa, aumentando o desempenho em relação à execução tradicional do JavaScript. No entanto, o escopo do WebAssembly se estende além do navegador.

WASI, a interface do sistema para WebAssembly, visa fornecer um conjunto padronizado de APIs para módulos WebAssembly, permitindo que eles sejam executados em vários ambientes, incluindo Kubernetes por meio do Krustlet. No contexto do Krustlet, o Wasm permite a execução de cargas de trabalho em um cluster Kubernetes sem exigir um tempo de execução de contêiner completo como o Docker. Isso torna as implantações leves e rápidas, permitindo que os desenvolvedores aproveitem o robusto sistema de tipos e os recursos de segurança de memória do Rust.

Configurando o Krustlet

Para configurar o Krustlet, você precisará de um cluster Kubernetes e dos binários do Krustlet. Você pode baixar os binários do Krustlet do repositório Krustlet GitHub ou criá-los você mesmo:

$ curl -O https://krustlet.blob.core.windows.net/releases/krustlet-v1.0.0-alpha.1-macos-amd64.tar.gz

Depois de baixar o binário correto para o seu sistema operacional, você pode prosseguir com o processo de instalação descompactando o arquivo baixado executando o seguinte tarcomando em seu terminal:

$ tar -xzf krustlet-v1.0.0-alpha.1-macos-amd64.tar.gz

Depois de descompactar, você encontrará o provedor Krustlet no diretório. Para torná-lo facilmente acessível, mova-o para um local dentro do arquivo $PATH. Por exemplo, em sistemas do tipo Unix, você pode usar o seguinte comando para mover o provedor para a /usr/local/bin/pasta:

$ sudo mv krustlet-wasi /usr/local/bin/

Ao mover o provedor Krustlet para um local em seu $PATH, você garantirá que ele possa ser executado de qualquer lugar em seu terminal.

Depois de configurar o Krustlet, você precisará configurá-lo para funcionar com seu cluster Kubernetes para executar cargas de trabalho do WebAssembly. Mas antes de entrarmos nisso, vamos criar um projeto Rust simples e publicá-lo no Docker Hub usando a ferramenta wasi-to-oci .

Construindo um módulo Wasm simples com Rust

Para começar, crie um novo projeto Rust usando o cargo new krustlet_democomando e abra-o com o editor de texto escolhido. Em seguida, abra o ./src/main.rsarquivo e adicione o seguinte código simulando o trabalho que está sendo feito:

// Rust
use std::thread;
use std::time::Duration;
fn main() {
    loop {
        // Perform your recurring task here
        println!("Performing recurring task...");
        // Wait for a specific duration before performing the task again
        thread::sleep(Duration::from_secs(5));
    }
}

O trecho acima contém um loopque executa uma tarefa recorrente a cada 5segundo. A println!instrução representa a tarefa recorrente, mas você pode substituí-la por qualquer lógica ou operação personalizada que precise ser repetida regularmente.

Antes de compilar o projeto, adicione o destino WASI à sua cadeia de ferramentas Rust:

$ rustup target add wasm32-wasi

Isso garante que você terá as ferramentas e dependências para compilar seu código Rust para a plataforma WASI.

Agora que você tem o destino WASI disponível, pode construir seu projeto Rust para gerar o módulo WebAssembly. Execute o seguinte comando no diretório raiz do seu projeto Rust:

$ cargo build --release --target wasm32-wasi

Depois de concluído, o Cargo irá gerar o módulo WebAssembly, com uma .wasmextensão, no target/wasm32-wasi/release/diretório.

Publicando um artefato Wasm no Docker Hub

Em seguida, vamos explorar o processo de publicação do módulo WebAssembly no Docker Hub, permitindo fácil acesso e implantação para outras pessoas interessadas em utilizar seu projeto Rust desenvolvido pelo Wasm. Siga as etapas abaixo para publicar seu artefato Wasm no Docker Hub:

Passo 1: Instale a ferramenta wasm-to-oci

A wasm-to-ociferramenta converte módulos Wasm para o formato OCI compatível com Docker. Visite a página de lançamentos e baixe o binário pré-construído para o seu sistema operacional e adicione-o ao seu caminho usando os seguintes comandos:

$ curl -O https://github.com/engineerd/wasm-to-oci/releases/download/v0.1.2/darwin-amd64-wasm-to-oci
$ mv darwin-amd64-wasm-to-oci wasm-to-oci
$ chmod +x wasm-to-oci
$ sudo cp wasm-to-oci /usr/local/bin

Etapa 2: faça login no registro de contêiner

Para publicar seu artefato WASM em um registro de contêiner, como o Docker Hub, você precisará fazer login no registro usando a CLI do Docker ou outras ferramentas disponíveis fornecidas pelo registro de contêiner específico. A wasm-to-ociferramenta usará as credenciais armazenadas em seu ~/.docker/config.jsonarquivo:

$ docker login

Ao efetuar login em seu registro de contêiner, você garantirá que a wasm-to-ociferramenta possa acessar seu registro e enviar o artefato Wasm sem nenhum problema de autenticação.

Etapa 3: enviar para o Docker Hub

O wasm-to-oci pushcomando converte o módulo Wasm no formato OCI e o envia para o Docker Hub usando o repositório especificado e a tag neste formato: <dockerhub-username>/<repository-name>:<tag>. Execute o seguinte comando:

$ wasm-to-oci push ./target/wasm32-wasi/release/krustlet_demo.wasm docker.io/ikehakinyemi/krustlet-demo:latest

Em seguida, visite a página do repositório do Docker Hub e confirme se o artefato Wasm foi enviado com sucesso e está visível no repositório. Agora, vamos ver como usar o minikube para implantar o Krustlet.

Como implantar com minikube

Primeiro, vamos inicializar o Krustlet usando algumas configurações existentes da equipe do Krustlet. Inicie um cluster Kubernetes local usando o minikube com o seguinte comando:

$ minikube start

Em seguida, verifique se o cluster está em execução ativamente:

$ kubectl get nodes -o wide

Para ingressar no cluster com as permissões apropriadas, o Krustlet requer configurações válidas com um token válido. Para esta configuração, você usará o script bash existente para gerar o kubeconfigarquivo e o token necessário:

$ curl https://raw.githubusercontent.com/krustlet/krustlet/main/scripts/bootstrap.sh | /bin/bash

Isso cria um arquivo de configuração dentro do ${HOME}/.krustlet/config/bootstrap.confarquivo. Depois de instalar e executar o script, você pode executar o provedor WASI do Krustlet com o seguinte comando:

$ KUBECONFIG=~/.krustlet/config/kubeconfig \
  krustlet-wasi \
  --node-ip <GATEWAY> \
  --node-name=krustlet \
  --bootstrap-file=${HOME}/.krustlet/config/bootstrap.conf

Use o minikube ipcomando para verificar o gateway padrão ao iniciar o minikube; substitua o valor pelo espaço reservado <GATEWAY>.

Depois de iniciar o Krustlet, você pode encontrar um prompt para aprovar manualmente os certificados TLS. Isso ocorre porque os certificados de serviço usados ​​pelo Krustlet exigem aprovação manual. Para prosseguir, abra um novo terminal e execute o seguinte comando:

$ kubectl certificate approve <hostname>-tls

O nome do host será exibido no prompt gerado pelo servidor Krustlet. Mantenha o servidor Krustlet em execução, apesar de quaisquer erros registrados, pois o Krustlet está atualmente em versão beta e pode ter algumas arestas que podem ser ignoradas por enquanto. Esta etapa é necessária apenas na primeira vez que você iniciar o Krustlet.

Agora, vamos verificar a funcionalidade do Krustlet escrevendo e aplicando o seguinte manifesto de carga de trabalho Wasm. Crie um workload.yamlarquivo e atualize-o, assim:

apiVersion: v1
kind: Pod
metadata:
  name: krustlet-demo
spec:
  containers:
    - name: krustlet-demo
      image: docker.io/ikehakinyemi/krustlet-demo:latest
  tolerations:
    - key: "kubernetes.io/arch"
      operator: "Equal"
      value: "wasm32-wasi"
      effect: "NoExecute"
    - key: "kubernetes.io/arch"
      operator: "Equal"
      value: "wasm32-wasi"
      effect: "NoSchedule"

Aqui especificamos tolerationspara garantir que o Kruslet não seja agendado em nós regulares, bem como para substituir o valor da imagem para apontar para o repositório onde você publica seu artefato. Agora, aplique o manifesto usando o kubectlcomando abaixo:

$ kubectl apply -f workload.yaml

Em seguida, confirme o status do pod:

$ kubectl get pods
NAME                READY   STATUS    RESTARTS   AGE
krustlet-demo       1/1     Running   0          24s

Agora você pode inspecionar os logs. Você deve observar que o Krustlet começa a gerar logs em sua janela de terminal, fornecendo atualizações sobre a carga de trabalho agendada:

$ kubectl logs krustlet-demo
Performing recurring task...
Performing recurring task...
Performing recurring task...

Com os logs acima, sua carga de trabalho está funcionando conforme o esperado. Como parte do processo de desenvolvimento local, você pode limpar os recursos usados ​​destruindo o cluster com o minikube deletecomando.

Conclusão

O Krustlet fornece uma maneira atraente para os desenvolvedores Rust executarem cargas de trabalho WebAssembly em um ambiente Kubernetes. Ele estende a versatilidade do Kubernetes, permitindo lidar com mais do que apenas aplicativos baseados em contêiner.

Para desenvolvedores que investem em Rust e WebAssembly, o Krustlet fornece uma maneira intuitiva e eficiente de integrar essas tecnologias ao ecossistema Kubernetes. Para obter mais informações e explorar mais, consulte a documentação oficial do Krustlet e a documentação do Rust e do WebAssembly .

Fonte: https://blog.logrocket.com

#rust #kubernetes #krustlet #webassembly #wasm

1.00 GEEK