HTTP използва архитектура клиент-сървър за пренос на информация и данни. Една от характеристиките на езиците за програмиране от страна на сървъра като Rust е разработването на сървъри и клиентски приложения за взаимодействие с базирани на HTTP услуги.

Rust е подходящ за изграждане на HTTP сървъри поради своите характеристики за безопасност, производителност и надеждност. Касите на трети страни на Rust като Actix и Rocket са популярни за изграждане на сложни уеб сървъри, които могат да се справят с голям трафик.

Защо трябва да използвате Rust за разработка на HTTP уеб сървър?

Rust придоби популярност за разработка на уеб сървъри, тъй като някои от функциите на езика са точно изискванията за изграждане на повечето уеб сървъри.

Използването на Rust гарантира, че вашето приложение се мащабира ефективно, което прави езика идеален за изграждане на приложения с висока производителност. Ето конкретни причини да обмислите използването на Rust за вашия уеб сървър и други сървърни приложения.

Висока производителност на Rust

Високата производителност е една от причините Rust да направи отличен избор за изграждане на HTTP уеб сървъри. Rust осигурява достъп на ниско ниво до системните ресурси, включително паметта и процесора, което ви позволява да пишете код, който работи по-бързо с по-малко ресурси в сравнение с други езици от страната на сървъра.

В допълнение, системата за собственост на Rust елиминира необходимостта от събиране на боклук по време на компилиране, което е една от причините някои сървърни езици да са бавни.

Безопасност и сигурност

Системата за собственост на Rust за управление на паметта прави езика сигурен за разработка на уеб сървър. Нямате препратки към нулеви или висящи указатели, които могат да доведат до изтичане на памет и други уязвимости в сигурността.

Системата на собственост на Rust предотвратява тези често срещани грешки, за да запази вашия сървър и приложения защитени. Rust също се фокусира върху предотвратяването на препълване на буфера и други грешки, свързани с паметта.

Паралелност

Паралелността е способността да се изпълняват множество единици от програма по начин извън реда, без да се засяга изходът. Изходът на паралелна програма трябва да бъде същият като изхода на асинхронна програма.

Паралелността може значително да повлияе на производителността на вашето приложение, тъй като сървърите трябва да обработват множество заявки едновременно. Rust осигурява поддръжка за съвместно съществуване с олекотен модел с резби.

Сосът на едновременното програмиране в Rust е, че системата за собственост ви позволява да пишете код, безопасен за нишки, без необходимост от ключалки и други примитиви за синхронизиране.

Стандартната библиотека на Rust и пакети на трети страни в екосистемата Rust предоставят модерни инструменти за ефективно разработка на уеб сървър.

Cargo, пакетният мениджър на Rust, опростява управлението на зависимости и изгражда процеси. Освен това Rust има отлична поддръжка на IDE с инструменти като Rust Analyzer, които осигуряват безпроблемно завършване на код, подчертаване на грешки и други функции.

Преглед на библиотеките Actix и Rocket

Стандартната библиотека на Rust има по-голямата част от помощната програма, която ще ви трябва за изграждане на уеб сървъри. Библиотеки на трети страни като Ракета и Actix опростете изграждането на сървърни приложения с Rust.

Actix и Ракета са популярни уеб рамки на Rust, но библиотеките се различават по дизайн и функции.

Rocket е уеб рамка от високо ниво, която дава приоритет на продуктивността и лекотата на използване. Rocket предоставя много абстракции и синтактична захар за изграждане на уеб приложения в Rust. Rocket също е популярен със силното си писане и интуитивен API дизайн.

Можете да добавите Rocket като зависимост от проекта във вашия Cargo.toml файл, за да започнете да създавате уеб приложения в Rust:

[зависимости]
ракета = "0.4.11"

От друга страна, Actix-web е рамка от ниско ниво, която дава приоритет на производителността и скалируемостта. Actix използва базиран на актьор модел на паралелност и осигурява неблокиращ I/O, което прави пакета идеален за изграждане на производителни уеб приложения.

Добавете Actix като зависимост от проекта в зависимости раздел от вашия Cargo.toml файл:

[зависимости]
actix-web = "4.3.1"

Изборът на библиотека за вашия проект ще зависи от спецификациите на вашия проект, характеристиките на библиотеката и вашия опит с Rust и HTTP.

Изграждане на прост уеб сървър в Rust

След като създадете проект Rust и добавите която и да е от рамките на Rocket или Actix към зависимостите на вашия проект в Cargo.toml файл, вие сте готови да започнете изграждането на уеб сървър в Rust.

Изграждане на прост уеб сървър с Actix

Можете да използвате сериализатор за заявки, когато създавате уеб услуги в Rust.

Serde е популярна библиотека на Rust за сериализиране и десериализиране на данни между типове Rust и формати на данни като JSON, YAML и TOML. Serde предоставя рамка за дефиниране на преобразуване на данни между структури от данни на Rust и съответните представяния в други формати на данни.

Ето директивата за добавяне на Serde като пакет на трета страна за вашия проект.

[зависимости]
сърде = { версия = "1.0.159", характеристики = ["извличам"] }

След като добавите Serde и Actix като зависимости на проекта, можете да създадете основен уеб сървър с Rust. Ето как можете да настроите прост Здравей свят! уеб сървър, който записва низ на клиента с Actix:

Първо импортирайте необходимите модули и типове от actix_web и сърде каси:

използване actix_web::{get, web, App, HttpResponse, HttpServer, Responder};
използване serde::{Десериализиране, Сериализиране};

Ще използвате сърде за сериализиране на съобщение до клиента със структура. Serde ще преобразува структурата в JSON за клиента. Ето структурата на съобщението:

#[производство (отстраняване на грешки, сериализиране, десериализиране)]
структураСъобщение {
 съобщение: низ,
}

Вече можете да дефинирате функцията манипулатор за крайната точка. В горната част на вашата манипулаторна функция можете да добавите декоратори за персонализирани поведения:

#[получи("/")]
асинхроненfnЗдравейте() -> импл Отговарящ {
 HttpResponse::Добре().json (Съобщение {
 съобщение: "Здравей свят!".to_owned(),
 })
}

The Здравейте функцията за обработка обработва GET заявки. Функцията връща тип, който имплементира Отговарящ черта от Actix пакет.

The json метод на HttpResponse:: Добре() type приема инстанция на структура, която Серде дръжки под капака и връща отговора на клиента.

След като дефинирате крайната точка, можете да стартирате сървърно копие и да монтирате крайната точка на маршрут.

#[actix_web:: main]
асинхроненfnосновен() -> std:: io::Резултат {
 HttpServer:: нов(|| Приложение:: нов().service (здравей))
 .bind("127.0.0.1:8080")?
 .run()
 .изчакайте
}

The HttpServer:: нов функция е нов сървърен екземпляр. The основен функцията стартира и сървърът монтира Здравейте манипулатор с новото приложение. The обвързвам метод свързва сървъра с посочения URL адрес и тичам функция управлява сървъра.

Изграждане на прост уеб сървър с Rocket

Rocket е минималистичен, така че можете да настроите прост уеб сървър без никакви зависимости, различни от Ракета щайга.

Ето как да настроите прост сървър с a Здравей свят! крайна точка с помощта на Rocket:

Първо, импортирайте необходимите зависимости за вашия сървър.

#![функция (proc_macro_hygiene, decl_macro)]
#[macro_use]
външенщайга ракета;
// импортира от сандъка Rocket
използване ракета:: отговор:: съдържание;
използване ракета:: Държава;

The #![функция (proc_macro_hygiene, decl_macro)] атрибут позволява експериментални функции на Rust за рамката на Rocket. The #[macro_use] атрибут импортира макроси от ракета модул.

Ето функция за обработка, която обслужва HTML при поискване:

#[получи("/")]
fnЗдравей свят() -> съдържание:: Html'статиченул> {
 съдържание:: Html("
Здравей свят!
")
}

The Здравей свят функцията връща HTML статичен низ с съдържание:: Html функция.

Ето декларация на конфигурационна структура за сървъра (рамкова конвенция на Rocket):

структураКонфиг {
 порт: u16,
}
#[получи("/порт")]
fnпорт(конфигурация: състояние) -> низ {
формат!(„Сървърът работи на порт {}“, config.port)
}

Когато стартирате сървъра, можете да правите заявки към /port крайна точка за състоянието на порта.

И накрая, ще създадете екземпляр на сървър с запалвам функция. Добавете конфигурациите, монтирайте маршрутите и стартирайте сървъра:

fnосновен() {
позволявам config = Config { порт: 8000 };
 ракета:: запали()
 .manage (конфигурация)
 .mount("/", маршрути![hello_world, порт])
 .launch();
}

The конфиг променливата е екземпляр на Конфиг структура The запалвам функция стартира сървърен екземпляр, the управлявам методът добавя конфигурацията към сървъра и монтиране метод монтира функцията манипулатор на базовите маршрути. И накрая, на стартиране метод стартира сървъра да слуша на посочения порт.

Можете да създавате мощни уеб приложения в Rust с WASM

WebAssembly (WASM) е двоичен формат на инструкции, предназначен за изпълнение в браузъри и други устройства. WASM предоставя формат на байт код от ниско ниво, който езиците за програмиране от по-високо ниво като Rust могат да използват като цел за компилация.

С WASM можете да компилирате своя Rust код в двоичен формат, който повечето популярни браузъри могат да изпълняват. WASM отваря свят от възможности за изграждане на стабилни уеб приложения в Rust, включително уеб приложения с пълен стек.