Préparer le code du plug-in

C++

Le SDK Proxy-Wasm C++ permet aux développeurs d'utiliser C++ pour implémenter des plug-ins WebAssembly (Wasm) pour les Service Extensions. Le SDK utilise la chaîne d'outils WebAssembly C++ Emscripten, ainsi que d'autres bibliothèques, telles que protobuf et, éventuellement, Abseil.

Étant donné que la création de plug-ins écrits en C++ dépend de versions spécifiques de ces outils et bibliothèques, nous vous recommandons d'utiliser l'image Docker fournie par le SDK Proxy-Wasm C++. Les instructions pour C++ sur cette page utilisent la méthode Docker. Pour créer des plug-ins C++ sans utiliser Docker, consultez la documentation du SDK Proxy-Wasm C++.

1. Installez Docker si ce n'est pas déjà fait. Docker est inclus dans Cloud Shell, l'environnement de shell interactif Google Cloud .

2. Téléchargez une copie du SDK C++ Proxy-Wasm. La façon la plus simple de le faire est de cloner le dépôt Git :

   git clone https://github.com/proxy-wasm/proxy-wasm-cpp-sdk.git
   

3. Créez l'image Docker du SDK Proxy-Wasm C++ à partir du fichier Dockerfile fourni par le SDK :

   cd proxy-wasm-cpp-sdk
   docker build -t wasmsdk:v3 -f Dockerfile-sdk .
   

   Une fois la commande terminée, les bibliothèques et les dépendances du SDK sont créées. L'image Docker résultante est associée au tag spécifié, qui est wasmsdk:v3 dans cet exemple.

Go

Le SDK Go Proxy-Wasm fournit un SDK Go complet. Go offre de bonnes performances et une prise en charge étendue des bibliothèques tierces écrites en Go pur.

Installez la chaîne d'outils Go v1.24.0.

Rust

La fonctionnalité de personnalisation des Service Extensions est fournie par l'utilisation de WebAssembly et de Proxy-Wasm. WebAssembly est compatible avec plusieurs langages de programmation. Google recommande Rust, car il offre une excellente compatibilité avec WebAssembly et Proxy-Wasm fournit un SDK Rust complet. Rust offre également de bonnes performances et une sécurité de type élevée.

1. Installez la chaîne d'outils Rust.

   À la fin du processus d'installation, suivez les instructions imprimées sur la console pour terminer la configuration.

2. Ajoutez la prise en charge de Wasm à la chaîne d'outils Rust :

   rustup target add wasm32-wasip1
   

C++

1. Créez un répertoire distinct de proxy-wasm-cpp-sdk :

   mkdir myproject
   

2. Dans le répertoire, créez un fichier Makefile avec le contenu suivant :

   # Express any dependencies
   PROTOBUF=     # full / lite / none
   WASM_DEPS=    # absl_base re2 ...
   
   # Include the SDK Makefile
   PROXY_WASM_CPP_SDK=/sdk
   include ${PROXY_WASM_CPP_SDK}/Makefile
   

3. Ajoutez un fichier source C++ pour le plug-in dans le même répertoire. Les noms des fichiers sources C++ doivent correspondre aux fichiers Wasm ciblés par le fichier Makefile, avec le suffixe .wasm remplacé par .cc. Dans cet exemple, le fichier source doit être nommé myproject.cc.

4. Ajoutez le code de votre plug-in au fichier source.

   L'exemple de code source suivant est un plug-in qui réécrit l'hôte de la requête et émet un en-tête de réponse :

   #include "proxy_wasm_intrinsics.h"
   
   class MyHttpContext : public Context {
    public:
     explicit MyHttpContext(uint32_t id, RootContext* root) : Context(id, root) {}
   
     FilterHeadersStatus onRequestHeaders(uint32_t headers,
                                          bool end_of_stream) override {
       LOG_INFO("onRequestHeaders: hello from wasm");
   
       // Route Extension example: host rewrite
       if (replaceRequestHeader(":authority", "service-extensions.com") != WasmResult::Ok) {
         LOG_ERROR("Failed to replace :authority header");
       }
       if (replaceRequestHeader(":path", "/") != WasmResult::Ok) {
         LOG_ERROR("Failed to replace :path header");
       }
       return FilterHeadersStatus::Continue;
     }
   
     FilterHeadersStatus onResponseHeaders(uint32_t headers,
                                           bool end_of_stream) override {
       LOG_INFO("onResponseHeaders: hello from wasm");
   
       // Traffic Extension example: add response header
       if (addResponseHeader("hello", "service-extensions") != WasmResult::Ok) {
         LOG_ERROR("Failed to add response header");
       }
       return FilterHeadersStatus::Continue;
     }
   };
   
   static RegisterContextFactory register_StaticContext(
       CONTEXT_FACTORY(MyHttpContext), ROOT_FACTORY(RootContext));

   La méthode onRequestHeaders est un rappel que les extensions de service invoquent.

Go

1. Créez un répertoire pour le plug-in :

   mkdir go-plugin
   

2. Dans le répertoire, créez un fichier go.mod à l'aide de l'outil Go :

   go mod init go-plugin
   

3. Dans le même répertoire, créez un fichier source nommé main.go et ajoutez-y le code de votre plug-in.

   L'exemple de code source suivant est un plug-in qui réécrit l'hôte de la requête et émet un en-tête de réponse :

   package main
   
   import (
   	"fmt"
   
   	"github.com/proxy-wasm/proxy-wasm-go-sdk/proxywasm"
   	"github.com/proxy-wasm/proxy-wasm-go-sdk/proxywasm/types"
   )
   
   func main() {}
   func init() {
   	proxywasm.SetVMContext(&vmContext{})
   }
   
   type vmContext struct {
   	types.DefaultVMContext
   }
   
   type pluginContext struct {
   	types.DefaultPluginContext
   }
   
   type httpContext struct {
   	types.DefaultHttpContext
   }
   
   func (*vmContext) NewPluginContext(contextID uint32) types.PluginContext {
   	return &pluginContext{}
   }
   
   func (*pluginContext) NewHttpContext(uint32) types.HttpContext {
   	return &httpContext{}
   }
   
   func (ctx *httpContext) OnHttpRequestHeaders(numHeaders int, endOfStream bool) types.Action