Construire une API REST en Rust avec Rhai et Actix Web

Rhai est un langage de script de haut niveau qui vous permet d'écrire la logique d'une application dans des scripts. Ces scripts peuvent ensuite être intégrés et exécutés dans les programmes Rust.

Étant donné que les scripts Rhai sont plus faciles à comprendre que Rust, ils peuvent faciliter la création de programmes plus complexes.

Dans cet article, vous apprendrez à intégrer des scripts Rhai dans Rust et à créer des API RESTful à l'aide de Rhai et du framework Web Actix.

Pour suivre cet article, vous devez être familiarisé avec les API Rust, Rhai et RESTful.

Qu'est-ce que Rhaï ?

Rhai, ou RhaiScript, est un petit langage de script rapide et intégrable qui peut être intégré dans les programmes Rust. Les programmes Rust peuvent exécuter des scripts Rhai pendant leur exécution, ce qui vous permet d'implémenter des algorithmes complexes dans un script facile à comprendre.

Le nom "Rhai" a été inspiré par Chai, un langage de script pour C++. Tout comme Rhai peut être intégré à Rust, Chai peut également être intégré à C++ et vous permet d'abstraire des algorithmes complexes dans un script facile à comprendre.

ChaiScript et RhaiScript utilisent une syntaxe de type JavaScript. Ces langages de script offrent un moyen sécurisé d'ajouter des scripts à leurs langages de programmation respectifs.

Avantages de l'utilisation de Rhai avec Rust

Rhai a un certain nombre d'avantages. Par exemple, les scripts Rhai sont plus rapides que d'autres langages de script pour Rust , y compris des options populaires comme JavaScript, Lua et Python. Ils sont également typés dynamiquement, ce qui permet une flexibilité et réduit la complexité.

De plus, Rhai est un langage de niveau supérieur à Rust, ce qui permet aux développeurs d'implémenter facilement des algorithmes complexes dans les programmes Rust. Les scripts Rhai peuvent facilement être intégrés dans des programmes Rust, interagir avec les variables du programme et fonctionner dans un environnement en bac à sable.

Enfin, les scripts Rhai sont sécurisés en mémoire et ne peuvent pas affecter les programmes Rust. En effet, ils s'exécutent dans un environnement contrôlé et n'ont pas la possibilité de modifier l'environnement en dehors de leur bac à sable.

Guide pour exécuter des scripts Rhai dans Rust

Pour exécuter des scripts Rhai dans votre programme Rust, vous devez suivre les étapes ci-dessous.

Tout d'abord, ajoutez la bibliothèque Rhai à votre Cargo.tomlfichier :

[dependencies]
rhai = "1.6.1"

Ensuite, créez le projet pour télécharger la bibliothèque avec la commande suivante :

cargo build

Vous devez également configurer votre projet Rust. Vous pouvez en créer un vide en utilisant la commande ci-dessous :

cargo init rhai_tutorial --bin

Après avoir construit le projet, vous pouvez commencer à écrire vos scripts Rhai. Dans nos prochaines étapes, nous allons configurer un programme "Hello world" comme exemple simple d'un programme Rust utilisant un script Rhai.

Tout d'abord, copiez ce qui suit dans votre main.rsfichier :

// import the scripting engine
use rhai::{ Engine };

fn main() {
    // Create the scripting engine
    let engine = Engine::new();

    // Run the script at "src/my_script.rhai"
    let result = engine.eval_file::<String>("src/my_script.rhai".into()).unwrap();

    // print the results of the script
    println!("{}", result);
}

Le programme ci-dessus exécute le script que nous allons créer à l'étape suivante, puis imprime la valeur renvoyée par le script.

Ensuite, créez un nouveau fichier nommé my_script.rhaidans le srcdossier et copiez-y ce qui suit. Ce script renvoie "Hello, World!" retour à Rust.

// a simple function that appends "Hello, "
// to the beginning of the argument
fn hello(name) {
    return "Hello, " + name;
}

// Rhai return the value of the last expression
hello("World!");

Pour exécuter ce programme, écrivez le programme Rust dans le src/main.rsfichier et le script Rhai dans le src/my_script.rhaifichier.

Après avoir créé l'exemple en suivant les étapes ci-dessus, exécutez-le avec la commande suivante :

$ cargo run
   Compiling rhai_tutorial v0.1.0 (..../rhai_tutorial)
    Finished dev [unoptimized + debuginfo] target(s) in 19.09s
     Running `target/debug/example`
Hello, World!

Dans le script Rhai, la hello();fonction prend une chaîne, l'ajoute "Hello, "au début de la chaîne, puis renvoie le résultat.

Une fois que Rust a exécuté un script Rhai, il reçoit la valeur de la dernière ligne du script. Dans cet exemple, Rust reçoit "Hello, World!" du script Rhai et l'imprime sur le terminal.

Vous pouvez également écrire des fonctions Rust qui peuvent être appelées à partir d'un script Rhai. Ceci est utile pour créer des scripts Rhai qui ont besoin d'accéder à certaines fonctionnalités de Rust. Voyons comment y parvenir dans l'exemple suivant.

Tout d'abord, copiez ce qui suit dans votre main.rsfichier :

// import the scripting engine
use rhai::{Engine};

fn main() {
    // Create scripting engine
    let mut engine = Engine::new();

    // create a hello function using an anonymous function
>   let hello = |name: String| -> String {
>       let mut text = String::from("Hello, ");
>       text.push_str(&name);
>       return text;
>   };

    // register the function in the engine
>   engine.register_fn("hello", hello);

    // Run the script at "my_script.rhai"
    let result = engine.eval_file::<String>("src/my_script.rhai".into()).unwrap();

    // print the results of the script
    println!("{}", result);
}

Ensuite, copiez ce qui suit dans votre my_script.rhaifichier :

// Rhai return the value of the last expression
hello("World!");

Maintenant, si vous exécutez ce programme, vous devriez voir "Hello, World!" comme avant. Cependant, au lieu d'écrire la fonction dans votre script Rhai, nous avons accompli cela en écrivant une fonction Rust qui a été appelée à partir du script Rhai.

Mise en place du framework Actix Web pour Rust

Les API REST (Representational State Transfer) sont conçues pour faciliter la communication entre les clients et les serveurs. Étant donné que les clients fonctionnent indépendamment des serveurs, ils utilisent des API comme interface pour envoyer et recevoir des requêtes.

Le framework Web Actix est un framework couramment utilisé pour créer des API REST. Les frameworks Web Rust fournissent les outils dont vous avez besoin pour créer rapidement des API REST volumineuses, évolutives et efficaces dans Rust.

Pour configurer ce cadre, suivez les étapes ci-dessous.

Tout d'abord, ajoutez la dépendance ci-dessous dans le Cargo.tomlfichier de votre projet :

[dependencies]
actix-web = "4.0.1"

Ensuite, créez le projet pour télécharger la bibliothèque à l'aide de la commande ci-dessous.

cargo build

Après avoir installé la bibliothèque, vous pouvez commencer à créer des API RESTful dans Rust. Pour suivre les exemples ci-dessous, vous devriez travailler dans votre main.rsfichier.

Exemple simple d'API REST Rust utilisant Actix Web

Voici un exemple simple d'API utilisant le framework Web Actix :

// import the the necessary modules from the library
use actix_web::{
  HttpServer,
  App,
  get,
  Responder,
};

// create a "/" route that
// responds with "Hello, World"

#[get("/")]
async fn greet() -> impl Responder {
  "Hello, World!"
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
  // create the server
  HttpServer::new(|| {
    App::new()
      .service(greet)
  })
    .bind(("127.0.0.1", 8080))  // bind the server to localhost:8080
    .unwrap()                // unwrap the result of the bind trait
    .run()                    // run the server
    .await
}

Lorsque vous exécutez le programme ci-dessus et faites une demande à http://localhost:8080/ , il répond par "Hello, World!"

Exemple d'API REST Rust avec une route dynamique

Vous trouverez ci-dessous un autre exemple d'API que vous pouvez créer à l'aide de ce framework. Dans cet exemple, le programme crée une route dynamique qui indique "Bonjour" à la valeur du paramètre dans le dernier segment d'une URL :

use actix_web::{
  HttpServer,
  App,
  get,
  Responder,
  web,
};

// if you send a request to /users, you get "Hello, users".

#[get("/{name}")]
async fn greet(path: web::Path<(String, )>) -> impl Responder {
  // assign the first of the path's parameter to "name"
  let name = path.into_inner().0;

  // Append "Hello, " to the beginning of the string, 
  // and return it
  format!("Hello, {name}!")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
  HttpServer::new(|| {
    App::new()
      .service(greet)
  })
    .bind(("127.0.0.1", 8080))   // bind the server to localhost:8080
    .unwrap()                // unwrap the result of the bind trait
    .run()                    // run the server
    .await
}

Les routes dynamiques sont des routes qui ont un ou plusieurs segments d'URL flexibles. Dans Rust, vous référencez les segments flexibles par leur position par rapport aux autres segments flexibles. Dans Actix Web, cette position utilise un index nul : le premier apparaît à zéro et le second à un.

Les segments d'URL font partie de l'itinéraire entre les barres obliques. Par exemple, dans l'URL http://example.com/path/to/resource , les segments sont « path », « to » et « resource ».

Supposons que vous ayez envoyé une requête à cet exemple d'URL : http://localhost:8080/humans

À la suite du programme que nous venons de créer, vous obtiendriez un "Hello, humans!" réponse. En effet, le dernier segment d'URL spécifie "humains", qui est ensuite attribué namedans le programme.

Exemples de `greet`fonction avec plusieurs paramètres

Prenons notre exemple précédent un peu plus loin. Voici un exemple de greetfonction avec un, deux ou trois paramètres.

Commençons par un seul paramètre, comme nous l'avons fait auparavant. Copiez le code ci-dessous dans votre fichier :

#[get("/{name}")]
async fn greet(path: web::Path<(String, )>) -> impl Responder {
  let name = path.into_inner().0;
  format!("Hello, {name}")
}

Utilisons maintenant deux paramètres : nameet age. Remplacez le contenu de votre fichier par le code ci-dessous :

#[get("/{name}/{age}")]
async fn greet(path: web::Path<(String, i32)>) -> impl Responder {
  let name: String = path.into_inner().0;
  let age: i32 = path.into_inner().1;
  format!("Hello, {name} you are {age} years")
}

Nous allons maintenant ajouter un troisième paramètre : hair_color. Pour ces trois paramètres, utilisez le code ci-dessous :

#[get("/{name}/{age}/{hair_color}")]
async fn greet(path: web::Path<(String, i32, String)>) -> impl Responder {
  let name: String = path.into_inner().0;
  let age: i32 = path.into_inner().1;
  let hair_color: String = path.into_inner().2;
  format!("Hello, {name} you are {age} with {hair_color} hair")
}

Vous pouvez avoir n'importe quel nombre de segments flexibles sur une seule URL. De cette façon, vous pouvez ajouter une logique pour gérer le routage qui n'est pas connu avant l'exécution de l'API.

Utilisation des API REST pour étendre les fonctionnalités complexes de Rust afin qu'elles s'exécutent dans Rhai

Rhai est un moteur d'évaluation, ce qui signifie que vous ne pouvez pas exécuter de fonctionnalités complexes, telles que des opérations de base de données. Pour utiliser ces fonctionnalités complexes, vous devez les étendre à partir de Rust.

Dans le projet d'API REST suivant, l'API et le routage sont créés à l'aide de Rust tandis que Rhai gère la logique.

Les bibliothèques utilisées pour créer ce type d'API sont actix-webet rhai. Suivez les étapes ci-dessous pour installer ces bibliothèques.

Tout d'abord, ajoutez les dépendances suivantes au Cargo.tomlfichier de votre projet.

[dependencies]
actix-web = "4.0.1"
rhai = "1.6.1"

Ensuite, construisons le projet. Installez les bibliothèques dans le projet avec la commande ci-dessous :

cargo build

Nous sommes maintenant prêts à commencer.

Enregistrer les points de terminaison du projet avec Rust

L'exemple de projet de cette section comporte deux points de terminaison.

Le point final /multiply/{num1}/{num2}est utilisé pour multiplier deux nombres. Par exemple, si vous envoyez une requête GET à http://localhost:8080/multiply/5/10 , vous obtiendrez « 50 » comme réponse.

Pendant ce temps, /add/{num1}/{num2}est utilisé pour additionner deux nombres. Si vous envoyez une requête GET à http://localhost:8080/add/5/10 , vous obtiendrez « 15 » comme réponse.

Le programme ci-dessous sera écrit dans notre main.rsfichier :

use actix_web::{
    HttpServer,
    get,
    App,
    web::Path,
    Responder,
};
use rhai::Engine;

#[get("/multiply/{num1}/{num2}")]
async fn multiply(path: Path<(i64, i64)>) -> impl Responder {
    // get the numbers from the url path
    let (num1, num2) = path.into_inner();

    // create an instance of the rhai engine
    let mut engine = Engine::new();

    // register an API that exposes the numbers to Rhai
    engine.register_fn("num1", move || num1);
    engine.register_fn("num2", move || num2);

    // run the script
    let result = engine.eval_file::<i64>("src/multiply.rhai".into()).unwrap();

    // return the result
    format!("{result}")
}

#[get("/add/{num1}/{num2}")]
async fn add(path: Path<(i64, i64)>) -> impl Responder {
    // get the numbers from the url path
    let (num1, num2) = path.into_inner();

    // create an instance of the rhai engine
    let mut engine = Engine::new();

    // register an API that exposes the numbers to Rhai
    engine.register_fn("num1", move || num1);
    engine.register_fn("num2", move || num2);

    // run the script
    let result = engine.eval_file::<i64>("src/add.rhai".into()).unwrap();

    // return the result
    format!("{result}")
}

// When Rust executes the Rhai script, Rhai returns the result of the last expression

#[actix_web::main]
async fn main() -> std::io::Result<()> {

    HttpServer::new(|| {
        App::new()
            .service(multiply)
            .service(add)
    })
        .bind(("127.0.0.1", 8080))
        .unwrap()
        .run()
        .await
}

Après avoir copié le code ci-dessus, vous pouvez maintenant utiliser les fonctions multiplyet adddans le moteur Rhai. Créez deux fichiers dans le srcdossier :

multiply.rhai, qui exécute la logique de la /multiplyroute.
add.rhai, qui exécute la logique du point de /addterminaison

Copiez le script suivant dans le multiply.rhaifichier :

fn multiply(num1, num2) {
  return num1 * num2;
}

let num1 = num1();
let num2 = num2();

multiply(num1, num2);

Copiez le script suivant dans le add.rhaifichier :

fn add(num1, num2) {
  return num1 + num2;
}

let num1 = num1();
let num2 = num2();

add(num1, num2);

Après avoir compilé et exécuté le programme Rust, testez les résultats en ouvrant un exemple tel que http://localhost:8080/add/5/15 dans votre navigateur. Cet exemple devrait donner quelque chose comme ci-dessous :
Résultat de l'exécution du programme Rust avec fonction d'ajout de cinq plus quinze montrant le résultat de vingt sur la page Web à Localhost8080

Conclusion

Dans cet article, nous avons couvert la création de scripts Rhai, la création d'API backend à l'aide d'Actix Web et l'utilisation de scripts Rhai dans les API backend.

Rhai est un outil très utile pour créer des programmes Rust, qui aide les développeurs à écrire du code complexe dans un script plus facile à comprendre, et peut ensuite être intégré dans les programmes Rust.

Jetez un œil au dépôt Github du projet final dans cet article pour vérifier ou comparer votre travail.

Source : https://blog.logrocket.com/building-rest-api-rust-rhai-actix-web/

#rust #restapi #rhai #actix

What is GEEK

Buddha Community

Construire une API REST en Rust avec Rhai et Actix Web

Wilford Pagac

1594289280

What is REST API? An Overview | Liquid Web

What is REST?

The REST acronym is defined as a “REpresentational State Transfer” and is designed to take advantage of existing HTTP protocols when used for Web APIs. It is very flexible in that it is not tied to resources or methods and has the ability to handle different calls and data formats. Because REST API is not constrained to an XML format like SOAP, it can return multiple other formats depending on what is needed. If a service adheres to this style, it is considered a “RESTful” application. REST allows components to access and manage functions within another application.

REST was initially defined in a dissertation by Roy Fielding’s twenty years ago. He proposed these standards as an alternative to SOAP (The Simple Object Access Protocol is a simple standard for accessing objects and exchanging structured messages within a distributed computing environment). REST (or RESTful) defines the general rules used to regulate the interactions between web apps utilizing the HTTP protocol for CRUD (create, retrieve, update, delete) operations.

What is an API?

An API (or Application Programming Interface) provides a method of interaction between two systems.

What is a RESTful API?

A RESTful API (or application program interface) uses HTTP requests to GET, PUT, POST, and DELETE data following the REST standards. This allows two pieces of software to communicate with each other. In essence, REST API is a set of remote calls using standard methods to return data in a specific format.

The systems that interact in this manner can be very different. Each app may use a unique programming language, operating system, database, etc. So, how do we create a system that can easily communicate and understand other apps?? This is where the Rest API is used as an interaction system.

When using a RESTful API, we should determine in advance what resources we want to expose to the outside world. Typically, the RESTful API service is implemented, keeping the following ideas in mind:

Format: There should be no restrictions on the data exchange format
Implementation: REST is based entirely on HTTP
Service Definition: Because REST is very flexible, API can be modified to ensure the application understands the request/response format.
The RESTful API focuses on resources and how efficiently you perform operations with it using HTTP.

The features of the REST API design style state:

Each entity must have a unique identifier.
Standard methods should be used to read and modify data.
It should provide support for different types of resources.
The interactions should be stateless.

For REST to fit this model, we must adhere to the following rules:

Client-Server Architecture: The interface is separate from the server-side data repository. This affords flexibility and the development of components independently of each other.
Detachment: The client connections are not stored on the server between requests.
Cacheability: It must be explicitly stated whether the client can store responses.
Multi-level: The API should work whether it interacts directly with a server or through an additional layer, like a load balancer.

#tutorials #api #application #application programming interface #crud #http #json #programming #protocols #representational state transfer #rest #rest api #rest api graphql #rest api json #rest api xml #restful #soap #xml #yaml

‎Andres Gallo‎

1604399880

An API-First Approach For Designing Restful APIs | Hacker Noon

I’ve been working with Restful APIs for some time now and one thing that I love to do is to talk about APIs.

So, today I will show you how to build an API using the API-First approach and Design First with OpenAPI Specification.

First thing first, if you don’t know what’s an API-First approach means, it would be nice you stop reading this and check the blog post that I wrote to the Farfetchs blog where I explain everything that you need to know to start an API using API-First.

Preparing the ground

Before you get your hands dirty, let’s prepare the ground and understand the use case that will be developed.

Tools

If you desire to reproduce the examples that will be shown here, you will need some of those items below.

NodeJS
OpenAPI Specification
Text Editor (I’ll use VSCode)
Command Line

Use Case

To keep easy to understand, let’s use the Todo List App, it is a very common concept beyond the software development community.

#api #rest-api #openai #api-first-development #api-design #apis #restful-apis #restful-api

Lets Cms

1652251528

Opencart REST API extensions - V3.x | Rest API Integration, Affiliate

Opencart REST API extensions - V3.x | Rest API Integration : OpenCart APIs is fully integrated with the OpenCart REST API. This is interact with your OpenCart site by sending and receiving data as JSON (JavaScript Object Notation) objects. Using the OpenCart REST API you can register the customers and purchasing the products and it provides data access to the content of OpenCart users like which is publicly accessible via the REST API. This APIs also provide the E-commerce Mobile Apps.

Opencart REST API
OCRESTAPI Module allows the customer purchasing product from the website it just like E-commerce APIs its also available mobile version APIs.

Opencart Rest APIs List
Customer Registration GET APIs.
Customer Registration POST APIs.
Customer Login GET APIs.
Customer Login POST APIs.
Checkout Confirm GET APIs.
Checkout Confirm POST APIs.

If you want to know Opencart REST API Any information, you can contact us at -
Skype: jks0586,
Email: letscmsdev@gmail.com,
Website: www.letscms.com, www.mlmtrees.com
Call/WhatsApp/WeChat: +91–9717478599.

Download : https://www.opencart.com/index.php?route=marketplace/extension/info&extension_id=43174&filter_search=ocrest%20api
View Documentation : https://www.letscms.com/documents/api/opencart-rest-api.html
More Information : https://www.letscms.com/blog/Rest-API-Opencart
VEDIO : https://vimeo.com/682154292

#opencart_api_for_android #Opencart_rest_admin_api #opencart_rest_api #Rest_API_Integration #oc_rest_api #rest_api_ecommerce #rest_api_mobile #rest_api_opencart #rest_api_github #rest_api_documentation #opencart_rest_admin_api #rest_api_for_opencart_mobile_app #opencart_shopping_cart_rest_api #opencart_json_api

Lets Cms

1652251629

Unilevel MLM Wordpress Rest API FrontEnd | UMW Rest API Woocommerce

Unilevel MLM Wordpress Rest API FrontEnd | UMW Rest API Woocommerce Price USA, Philippines : Our API’s handle the Unilevel MLM woo-commerce end user all functionalities like customer login/register. You can request any type of information which is listed below, our API will provide you managed results for your all frontend needs, which will be useful for your applications like Mobile App etc.
Business to Customer REST API for Unilevel MLM Woo-Commerce will empower your Woo-commerce site with the most powerful Unilevel MLM Woo-Commerce REST API, you will be able to get and send data to your marketplace from other mobile apps or websites using HTTP Rest API request.
Our plugin is used JWT authentication for the authorization process.

REST API Unilevel MLM Woo-commerce plugin contains following APIs.
User Login Rest API
User Register Rest API
User Join Rest API
Get User info Rest API
Get Affiliate URL Rest API
Get Downlines list Rest API
Get Bank Details Rest API
Save Bank Details Rest API
Get Genealogy JSON Rest API
Get Total Earning Rest API
Get Current Balance Rest API
Get Payout Details Rest API
Get Payout List Rest API
Get Commissions List Rest API
Withdrawal Request Rest API
Get Withdrawal List Rest API

If you want to know more information and any queries regarding Unilevel MLM Rest API Woocommerce WordPress Plugin, you can contact our experts through
Skype: jks0586,
Mail: letscmsdev@gmail.com,
Website: www.letscms.com, www.mlmtrees.com,
Call/WhatsApp/WeChat: +91-9717478599.

more information : https://www.mlmtrees.com/product/unilevel-mlm-woocommerce-rest-api-addon

Visit Documentation : https://letscms.com/documents/umw_apis/umw-apis-addon-documentation.html

#Unilevel_MLM_WooCommerce_Rest_API's_Addon #umw_mlm_rest_api #rest_api_woocommerce_unilevel #rest_api_in_woocommerce #rest_api_woocommerce #rest_api_woocommerce_documentation #rest_api_woocommerce_php #api_rest_de_woocommerce #woocommerce_rest_api_in_android #woocommerce_rest_api_in_wordpress #Rest_API_Woocommerce_unilevel_mlm #wp_rest_api_woocommerce

Léon Peltier

1656515100