Обзор библиотеки Actix в Rust

Привет, Хабр!

Actix появился на свет благодаря Николаю Киму, также известного в сообществе под ником fafhrd91. Николай создал экосистему, которая позволяет строить масштабируемые, надежные веб-приложения и микросервисы. Actix основан на модели акторов, концепции, которая была впервые предложена в 1973 году для симуляции активных компонентов в распределенных системах.

Actix требует Rust версии 1.39 или выше. Можно легко добавить Actix юзая Cargo. Для этого достаточно добавить зависимости Actix-web в файл Cargo.toml вашего проекта:

[dependencies] actix-web = "4.0"

После добавления юзаем cargo build, и карго автоматом скомпилирует Actix Web вместе с необходимыми зависимостями.

Основные возможности

Основные элементы Actix — это акторы, система и арбитр.

Актор — это объект, который инкапсулирует состояние и поведение. Он взаимодействует с другими акторами исключительно посредством асинхронных сообщений:

use actix::prelude::*;  struct MyActor; impl Actor for MyActor {     type Context = Context<Self>; }  impl MyActor {     fn new() -> Self {         MyActor     } }

Каждый актор в Actix должен реализовать трейт Actor, определяющий контекст, в котором актор исполняется.

System в Actix — это контейнер, который запускает и управляет акторами.

fn main() {     let system = System::new();     system.block_on(async {         let addr = MyActor::new().start();         // отправка сообщений актору и другие операции     }); }

Arbiter — это сущность, управляющая пулом потоков для выполнения асинхронных задач. Каждый Arbiter может запускать несколько акторов, обеспечивая параллельное выполнение их задач:

fn main() {     let system = System::new();     system.block_on(async {         let arbiter = Arbiter::new();         arbiter.spawn(async {             // задачи, выполняемые в контексте нового Arbiter         });     }); }

Как это все взаимодействует:

use actix::prelude::*;  struct Ping; impl Message for Ping {     type Result = String; }  struct PongActor; impl Actor for PongActor {     type Context = Context<Self>; }  impl Handler<Ping> for PongActor {     type Result = String;      fn handle(&mut self, _msg: Ping, _ctx: &mut Context<Self>) -> Self::Result {         "Pong".to_string()     } }  fn main() {     let system = System::new();     system.block_on(async {         let pong_actor_address = PongActor.start();         let result = pong_actor_address.send(Ping).await.unwrap();         println!("Received: {}", result);     }); }

PongActor обрабатывает сообщения типа Ping и отвечает сообщением «Pong». Cоздаем актора, отправляем ему сообщение и асинхронно ожидаем ответа.

Обработчики могут быть простыми, возвращая статические данные, или сложными, выполняя асинхронные операции, такие как запросы к базам данных или внешним API. В Actix Web для объявления обработчика используется макрос #[get("/path")], #[post("/path")] и так далее, в зависимости от HTTP-метода, который обработчик должен обрабатывать:

use actix_web::{web, App, HttpResponse, HttpServer, Responder};  async fn greet(req: web::HttpRequest) -> impl Responder {     let name = req.match_info().get("name").unwrap_or("World");     HttpResponse::Ok().body(format!("Hello, {}!", name)) }

Мидлвари в Actix Web могут модифицировать запросы перед тем, как они достигнут обработчика, или изменять ответы после того, как обработчик их сгенерил, но до того, как они отправлены клиенту:

use actix_web::{middleware, App, HttpServer};  #[actix_web::main] async fn main() -> std::io::Result<()> {     HttpServer::new(|| {         App::new()             .wrap(middleware::Logger::default()) // мидлвари логирования             .service(/* обработчики */)     })     .bind("127.0.0.1:8080")?     .run()     .await }

Асинхронность в Actix

В Actix каждый актор исполняется асинхронно, имея возможность обрабатывать сообщения параллельно с другими акторами. Акторы могут отправлять, получать и обрабатывать сообщения асинхронно, используя async/await Rust:

use actix::prelude::*;  struct MyAsyncActor; impl Actor for MyAsyncActor {     type Context = Context<Self>; }  #[derive(Message)] #[rtype(result = "String")] struct MyMessage;  impl Handler<MyMessage> for MyAsyncActor {     type Result = ResponseFuture<String>;      fn handle(&mut self, _msg: MyMessage, _ctx: &mut Context<Self>) -> Self::Result {         Box::pin(async {             // какая-нибудь длительная асинхронная операция             actix_rt::time::sleep(std::time::Duration::from_secs(1)).await;             "Hello from async actor!".to_string()         })     } }

MyAsyncActor асинхронно обрабатывает сообщение MyMessage, имитируя длительную операцию с использованием sleep. Возвращаемый тип ResponseFuture<String> показывает то что все будет выполнено асинхронно.

С Actix можно асинхронного взаимодействовать между акторами через отправку сообщений. Акторы могут использовать метод .send() для асинхронной отправки сообщений другим акторам и ожидать ответа с помощью await:

#[actix_rt::main] async fn main() {     let addr = MyAsyncActor.start();      let res = addr.send(MyMessage).await;     match res {         Ok(result) => println!("Received response: {}", result),         Err(e) => println!("Encountered an error: {}", e),     } }

Отправляем сообщение MyMessage актору MyAsyncActor и асинхронно ожидаем ответ.

Actix поддерживает асинхронную обработку стримов:

use actix::prelude::*; use futures::stream::{self, StreamExt};  struct StreamActor; impl Actor for StreamActor {     type Context = Context<Self>; }  impl StreamHandler<i32> for StreamActor {     fn handle(&mut self, item: i32, _ctx: &mut Context<Self>) {         println!("Received: {}", item);     } }  #[actix_rt::main] async fn main() {     let addr = StreamActor.start();      // создание простого стрима     let stream = stream::iter(vec![1, 2, 3]);     // отправка стрима актору     addr.add_stream(stream); }

StreamActor подписывается на стрим целые числа и асинхронно обрабатывает каждое поступающее значение.

Прочие возможности

Создадим простейший веб-сервер, который будет отвечать на запросы по корневому пути (/):

use actix_web::{web, App, HttpResponse, HttpServer, Responder};  async fn greet() -> impl Responder {     HttpResponse::Ok().body("Hello, Habr!") }  #[actix_web::main] async fn main() -> std::io::Result<()> {     HttpServer::new(|| {         App::new()             .route("/", web::get().to(greet))     })     .bind("127.0.0.1:8080")?     .run()     .await }

Создаем HTTP-сервер, который слушает на 127.0.0.1:8080 и использует функцию greet для обработки GET-запросов по адресу /. Функция greet возвращает простое приветствие.

Создадим обработчик, который принимает имя пользователя через путь запроса и возвращает персонализированное приветствие:

use actix_web::{web, App, HttpResponse, HttpServer, Responder};  async fn greet_user(name: web::Path<String>) -> impl Responder {     HttpResponse::Ok().body(format!("Zdarova, {}!", name)) }  #[actix_web::main] async fn main() -> std::io::Result<()> {     HttpServer::new(|| {         App::new()             .route("/greet/{name}", web::get().to(greet_user))     })     .bind("127.0.0.1:8080")?     .run()     .await }

Используем web::Path для извлечения параметра name из пути URL и возвращаем пользователю персонализированное сообщение.

Для работы с базами данных в Actix-web часто юзает асинхронные ORM, например, Diesel или sqlx. Используемsqlx для асинхронного взаимодействия с бдшкой PostgreSQL:

use actix_web::{web, App, HttpResponse, HttpServer, Responder}; use sqlx::postgres::PgPoolOptions; use std::env;  async fn get_user(pool: web::Data<sqlx::PgPool>) -> impl Responder {     let row: (String,) = sqlx::query_as("SELECT name FROM users WHERE id = $1")         .bind(1)         .fetch_one(&**pool)         .await         .unwrap();      HttpResponse::Ok().body(format!("Hello, {}!", row.0)) }  #[actix_web::main] async fn main() -> std::io::Result<()> {     let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");     let pool = PgPoolOptions::new()         .connect(&database_url)         .await         .expect("Failed to create pool.");      HttpServer::new(move || {         App::new()             .app_data(web::Data::new(pool.clone()))             .route("/user", web::get().to(get_user))     })     .bind("127.0.0.1:8080")?     .run()     .await }

Создался пул соединений к бд PostgreSQL и он используется для его для асинхронного выполнения запроса к бд в обработчике get_user.

Можно интегрироваться с API. Например с reqwest, можно асинхронно отправлять HTTP-запросы к внешним сервисам:

use actix_web::{web, App, HttpResponse, HttpServer, Responder}; use reqwest::Client;  async fn fetch_data() -> impl Responder {     let client = Client::new();     let res = client.get("https://api.example.com/data")         .send()         .await         .unwrap()         .text()         .await         .unwrap();      HttpResponse::Ok().body(res) }  #[actix_web::main] async fn main() -> std::io::Result<()> {     HttpServer::new(|| {         App::new()             .route("/fetch", web::get().to(fetch_data))     })     .bind("127.0.0.1:8080")?     .run()     .await }

Функция fetch_data использует reqwest для асинхронного получения данных от внешнего API и возвращает полученный ответ клиенту.

---

Для тех, кто желает узнать больше — Actix GitHub.

А про практические инструменты и другие ЯП лучше всего узнавать от практикующих экспертов, например, в рамках онлайн-курсов.