Le cloud Edge permet aux développeurs de déployer des microservices (c'est-à-dire des services Web à granularité fine) à proximité des utilisateurs, ce qui se traduit par une meilleure expérience utilisateur (c'est-à-dire des temps de réponse très rapides), une excellente sécurité et une haute disponibilité. Le cloud Edge utilise des centres de données locaux ou même privés, des réseaux CDN et des centres de données de télécommunications (tels que 5G MEC) pour fournir des services informatiques. Les exemples de réussite du cloud Edge incluent Cloudflare, Fastly, Akamai, fly.io, Vercel, Netlify, etc.
Cependant, les cloud de périphérie constituent un environnement aux ressources limitées par rapport aux cloud publics plus grands. Si les microservices Edge eux-mêmes sont lents, volumineux ou peu sécurisés, tous les avantages du déploiement sur le cloud Edge seront perdus.
Cet article montrera comment créer un service Web léger et performant, puis le déployer gratuitement sur fly.io, un fournisseur de cloud Edge .
Fly.io est un fournisseur de services cloud VM de pointe avec des centres de données de pointe partout dans le monde. La VM fly.io prend en charge les serveurs d'applications, les bases de données et un environnement d'exécution léger pour les microservices comme le nôtre.
J'utiliserai le runtime WasmEdge comme bac à sable de sécurité pour ces microservices. WasmEdge est un runtime WebAssembly optimisé pour les services cloud natifs. Nous regrouperons les applications de microservices écrites en Rust ou JavaScript dans des images Docker basées sur WasmEdge. Cette approche présente plusieurs avantages considérables.
- WasmEdge exécute des applications en bac à sable à une vitesse quasi native. Selon une étude évaluée par des pairs, WasmEdge peut exécuter des programmes Rust à une vitesse proche de celle de Linux exécutant du code machine natif.
- WasmEdge est un runtime hautement sécurisé. Il protège vos applications des menaces externes et internes.
- La vulnérabilité du runtime WasmEdge aux attaques est considérablement réduite par rapport au runtime du système d'exploitation Linux conventionnel.
- Le risque d'attaques de la chaîne d'approvisionnement logicielle est considérablement réduit car le bac à sable WebAssembly n'autorise que les accès explicitement déclarés.
- WasmEdge fournit un environnement d'exécution d'application portable complet avec une empreinte mémoire qui ne représente que 1/10 de celle d'une image d'exécution de système d'exploitation Linux standard.
- Le runtime WasmEdge est multiplateforme. Cela signifie que les machines de développement et de déploiement ne doivent pas nécessairement être les mêmes. Une fois qu'une application WasmEdge est créée, elle peut être déployée n'importe où prenant en charge WasmEdge, y compris l' infrastructure fly.io.
Pour les applications complexes, cet avantage en termes de performances est encore amplifié. Par exemple, l'application d'inférence WasmEdge AI ne nécessite pas d'installation Python. Les applications WasmEdge node.js ne nécessitent pas non plus l'installation de node.js et v8.
Ensuite, dans cet article, je vais vous montrer comment exécuter
-
Serveur HTTP asynchrone (Rust)
-
Un service web de classification d'images très rapide (sous Rust) et
-
serveur web node.js
-
Microservices avec état avec connexions à des bases de données
Tout cela s'exécute rapidement et en toute sécurité dans WasmEdge tout en consommant seulement 1/10 des ressources requises par les conteneurs Linux classiques.
Préparation
Tout d’abord, assurez-vous que les outils Docker sont installés sur votre système. Sinon, suivez la première section de ce tutoriel pour installer Docker. Ensuite, nous utiliserons le programme d'installation en ligne pour installer les outils WasmEdge , Rust et fly.io.flyctl
Installez WasmEdge. Voir les détails ici.
curl -sSf https://raw.githubusercontent.com/WasmEdge/WasmEdge/master/utils/install.sh | bash -s -- -e all
Installez Rust. Voir les détails ici.
`curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh`
Installez les outils pour fly.io. Voir les détails ici .flyctl
`curl -L `[`https://fly.io/install.sh`](https://fly.io/install.sh)` | sh`
Installé flyctl 之后，Veuillez suivre les instructions pour créer un compte sur fly.io. Le service web est désormais prêt à être déployé sur le cloud edge !
Un simple microservice écrit en Rust
Notre premier exemple est un simple service HTTP écrit en Rust. Il présente une application Web moderne qui peut être étendue pour prendre en charge une logique métier arbitrairement complexe. Basé sur les populaires Tokio et Hyper Crate, ce microservice est très rapide, asynchrone (non bloquant) et très facile à créer pour les développeurs.
Une image WasmEdge entièrement liée statiquement ne fait que 4 Mo (contre 40 Mo pour l'image Linux de base). C'est suffisant pour exécuter des services HTTP asynchrones écrits dans les frameworks tokio et hyper de Rust.
Exécutez les deux commandes CLI suivantes pour créer l'application fly.io à partir de l'image Slim Docker de WasmEdge .
$ flyctl launch --image juntaoyuan/flyio-echo
$ flyctl deploy
Très bien! Vous pouvez utiliser la commande curl pour tester si le service Web déployé a réussi. Il fait écho aux données que vous publiez.
$ curl https://proud-sunset-3795.fly.dev/echo -d "Hello WasmEdge on fly.io!"
Hello WasmEdge on fly.io!
juntaoyuan/flyio-echoLe fichier docker de l'image contient le runtime WasmEdge et le package complet de l'application Web personnalisée WasmEdge_hyper_server.wasm.
FROM WasmEdge/slim-runtime:0.11.0
ADD WasmEdge_hyper_server.wasm /
CMD ["WasmEdge", "--dir", ".:/", "/WasmEdge_hyper_server.wasm"]
Le projet de code source Rust qui crée WasmEdge_hyper_server.wasm l'application est ici. Il démarre un serveur HTTP à l'aide de l'API Tokio. Lorsque le serveur reçoit une requête, il délègue à echo()une fonction le traitement de la requête de manière asynchrone. Cela permet aux microservices d'accepter et de traiter plusieurs requêtes HTTP simultanées.
#[tokio::main(flavor = "current_thread")]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let addr = SocketAddr::from(([0, 0, 0, 0], 8080));
let listener = TcpListener::bind(addr).await?;
println!("Listening on http://{}", addr);
loop {
let (stream, _) = listener.accept().await?;
tokio::task::spawn(async move {
if let Err(err) = Http::new().serve_connection(stream, service_fn(echo)).await {
println!("Error serving connection: {:?}", err);
}
});
}
}
Les fonctions asynchrones echo()sont les suivantes. Il exploite l'API HTTP fournie par hyper pour analyser les demandes et générer des réponses. Ici, la réponse est simplement le « corps de données de la demande ».
async fn echo(req: Request<Body>) -> Result<Response<Body>, hyper::Error> {
match (req.method(), req.uri().path()) {
... ...
(&Method::POST, "/echo") => Ok(Response::new(req.into_body())),
... ...
// Return the 404 Not Found for other routes.
_ => {
let mut not_found = Response::default();
*not_found.status_mut() = StatusCode::NOT_FOUND;
Ok(not_found)
}
}
}
Ajoutons maintenant un peu de piquant à nos microservices de base !
Un microservice d'inférence d'IA écrit en Rust
Dans cet exemple, nous allons créer un service Web pour classer les images. Il traite les images téléchargées via les modèles Tensorflow Lite. Nous utiliserons l'API Rust de WasmEdge pour accéder à Tensorflow, plutôt que de créer un programme Python complexe (et volumineux) qui exécute des tâches d'inférence à la vitesse du code machine natif (par exemple, sur du matériel GPU, si disponible). Grâce à la norme WASI-NN, l'API Rust de WasmEdge peut être utilisée avec des modèles d'IA dans Tensorflow, PyTorch, OpenVINO et d'autres frameworks d'IA.
WasmEdge a une empreinte de moins de 115 Mo pour une application d'inférence d'IA qui inclut toutes les dépendances Tensorflow Lite. En comparaison, l'image Tensorflow Linux standard fait plus de 400 Mo.
À partir de l'image Docker mince de WasmEdge + Tensorflow, exécutez les deux commandes CLI suivantes pour créer et déployer une application fly.io.
$ flyctl launch --image juntaoyuan/flyio-classify
$ flyctl deploy
Très bien! Vous pouvez utiliser la commande curl pour tester si le service Web déployé fonctionne réellement. Il renvoie les résultats de classification d'images avec des classements de vraisemblance.
$ curl https://silent-glade-6853.fly.dev/classify -X POST --data-binary "@grace_hopper.jpg"
military uniform is detected with 206/255 confidence
juntaoyuan/flyio-classifyLe Dockerfile pour l'image Docker contient le package complet du runtime WasmEdge, l'intégralité de la bibliothèque Tensorflow et ses dépendances, ainsi que l'application Web personnalisée WasmEdge_hyper_server_tflite.wasm.
FROM WasmEdge/slim-tf:0.11.0
ADD WasmEdge_hyper_server_tflite.wasm /
CMD ["WasmEdge-tensorflow-lite", "--dir", ".:/", "/WasmEdge_hyper_server_tflite.wasm"]
Le projet de code source Rust utilisé pour créer WasmEdge_hyper_server_tflite.wasml'application est ici . Le serveur HTTP asynchrone basé sur Tokio se trouve à l'intérieur d'une main()fonction asynchrone, comme le montre l'exemple précédent. classify()La fonction traite les données d'image dans la requête, convertit l'image en tenseur, exécute le modèle Tensorflow et convertit la valeur de retour (dans un tenseur) en étiquettes de texte et probabilités pour le contenu reconnu.
async fn classify(req: Request<Body>) -> Result<Response<Body>, hyper::Error> {
let model_data: &[u8] = include_bytes!("models/mobilenet_v1_1.0_224/mobilenet_v1_1.0_224_quant.tflite");
let labels = include_str!("models/mobilenet_v1_1.0_224/labels_mobilenet_quant_v1_224.txt");
match (req.method(), req.uri().path()) {
(&Method::POST, "/classify") => {
let buf = hyper::body::to_bytes(req.into_body()).await?;
let flat_img = WasmEdge_tensorflow_interface::load_jpg_image_to_rgb8(&buf, 224, 224);
let mut session = WasmEdge_tensorflow_interface::Session::new(&model_data, WasmEdge_tensorflow_interface::ModelType::TensorFlowLite);
session.add_input("input", &flat_img, &[1, 224, 224, 3])
.run();
let res_vec: Vec<u8> = session.get_output("MobilenetV1/Predictions/Reshape_1");
... ...
let mut label_lines = labels.lines();
for _i in 0..max_index {
label_lines.next();
}
let class_name = label_lines.next().unwrap().to_string();
Ok(Response::new(Body::from(format!("{} is detected with {}/255 confidence", class_name, max_value))))
}
// Return the 404 Not Found for other routes.
_ => {
let mut not_found = Response::default();
*not_found.status_mut() = StatusCode::NOT_FOUND;
Ok(not_found)
}
}
}
À la fin de cet article, nous verrons comment ajouter plus de fonctionnalités aux microservices Rust, tels que les clients de base de données et les clients de services Web.
Un simple microservice dans Node.js
Bien que les microservices basés sur Rust soient légers et rapides, tout le monde n’est pas (encore) un développeur Rust. Si vous êtes plus familier avec JavaScript, vous pouvez toujours profiter pleinement de la sécurité, des performances, du faible encombrement et de la portabilité de WasmEdge dans le cloud Edge ! Concrètement, il est possible de créer des microservices pour WasmEdge en utilisant l'API node.js !
Pour les applications Node.js, WasmEdge a une empreinte inférieure à 15 Mo. En comparaison, l’image Linux Node.js standard fait plus de 150 Mo.
À partir de l'image Docker mince de WasmEdge + node.js, exécutez les deux commandes CLI suivantes pour créer et déployer une application fly.io.
$ flyctl launch --image juntaoyuan/flyio-nodejs-echo
$ flyctl deploy
Très bien! Vous pouvez utiliser la commande curl pour tester que le service Web déployé fonctionne réellement. Il fera écho à toutes les données que vous y publierez.
$ curl https://solitary-snowflake-1159.fly.dev -d "Hello WasmEdge for Node.js on fly.io!"
Hello WasmEdge for Node.js on fly.io!
juntaoyuan/flyio-nodejs-echoLe Dockerfile de l'image Docker contient le runtime WasmEdge, le runtime QuickJS , un package completWasmEdge_quickjs.wasm de modules node.js et une application de service Web .node_echo.js
FROM WasmEdge/slim-runtime:0.11.0
ADD WasmEdge_quickjs.wasm /
ADD node_echo.js /
ADD modules /modules
CMD ["WasmEdge", "--dir", ".:/", "/WasmEdge_quickjs.wasm", "node_echo.js"]
node_echo.jsLe code source JavaScript complet de l’application se trouve ci-dessous. Évidemment, il utilise simplement l'API standard node.js pour créer un serveur HTTP asynchrone qui fait écho au corps de la requête HTTP.
import { createServer, request, fetch } from 'http';
createServer((req, resp) => {
req.on('data', (body) => {
resp.end(body)
})
}).listen(8080, () => {
print('listen 8080 ...\n');
})
Le moteur QuickJS de WasmEdge fournit non seulement la prise en charge de node.js, mais également la prise en charge de l'inférence Tensorflow. Nous avons intégré Rust TensorFlow et le SDK WASI-NN dans une API JavaScript afin que les développeurs JavaScript puissent facilement créer des applications d'inférence d'IA .
Microservices avec état à la périphérie
Grâce à WasmEdge, il est également possible de créer des microservices avec état soutenus par des bases de données. Ce référentiel GitHub contient un exemple de client de base de données non bloquant basé sur Tokio pour les applications WasmEdge.
- Le client MySQL permet aux applications WasmEdge d'accéder à la plupart des bases de données cloud.
- Les applications WasmEdge peuvent utiliser anna-rs comme cache périphérique ou base de données.
Désormais, utilisez rapidement le SDK et le runtime WasmEdge pour créer divers services Web sur le cloud périphérique. J'ai hâte de voir vos résultats !