Как развернуть приложение Rust?
Уже более 4 лет Rust является самым любимым языком в опросе разработчиков StackOverflow благодаря множеству возможностей, которые он предлагает пользователям.
Mozilla создала Rust, чтобы сделать его надежным, производительным и удобным для разработчиков. Синтаксис Rust схож с синтаксисом таких языков, как C++ и C, на разработчиков которых и ориентирован язык.
Rust также фокусируется на безопасности памяти и параллелизме с моделями, которые позволяют избежать связанных с ними подводных камней, с которыми сталкиваются разработчики, использующие другие языки.
Вы узнаете, как создавать API на Rust, чтобы использовать преимущества этой статьи. Вы научитесь создавать, контейнировать и развертывать приложение на языке Rust на бесплатном сервисе контейнеризации Back4app.
Contents
- 0.1 Преимущества использования Rust
- 0.2 Ограничения использования Rust
- 0.3 Варианты развертывания Rust
- 0.4 Процесс развертывания приложения Rust
- 1 Что такое Back4app?
- 1.1 Создание и развертывание
- 1.2 Функция обработчика POST
- 1.3 Функция обработчика GET
- 1.4 Функция обработчика PUT
- 1.5 Функция обработчика DELETE
- 1.6 Сопоставление функций обработчика с маршрутами
- 1.7 Контейнеризация приложений Rust с помощью Docker
- 1.8 Развертывание контейнера на Back4app
- 1.9 Развертывание с помощью Back4app AI Agent
- 1.10 Заключение
Преимущества использования Rust
Использование Rust в своих проектах дает множество преимуществ. Вот некоторые из них:
Абстракции с нулевыми затратами
Rust предоставляет высокоуровневые абстракции без дополнительных затрат во время выполнения. Это означает, что абстракции, которые вы используете в своем коде (функции, итераторы или дженерики), не делают ваши программы медленнее.
Компилятор Rust оптимизирует абстракции для скомпилированного низкоуровневого кода вручную. Rust преодолевает разрыв между выразительным, низкоуровневым и тонким контролем над производительностью.
Подход Fearless Concurrency для обеспечения безопасности памяти в параллельных программах
Rust использует “бесстрашный подход” к параллелизму, характеризующийся безопасностью и эффективностью. Модель параллелизма Rust использует модель владения и проверку типов для предотвращения гонок данных во время компиляции.
Эта возможность позволяет писать многопоточные приложения без недостатков параллелизма с общим состоянием, таких как тупики и условия гонки.
Усовершенствованная система типов и модель владения
Система типов Rust и ее правила владения – это уникальные особенности, которые помогают обеспечить безопасность памяти.
Модель владения использует проверку заимствований, чтобы убедиться, что каждый фрагмент данных имеет одного владельца, и управляет его жизненным циклом, чтобы предотвратить такие проблемы, как висячие указатели и утечки памяти.
Кросс-платформенная совместимость и интеграция
Rust – отличный выбор, если вы хотите создавать кроссплатформенные приложения. Вы можете написать код один раз и скомпилировать его на нескольких платформах без существенных изменений в существующей кодовой базе.
Rust хорошо интегрируется с другими языками программирования, особенно с C, что делает язык подходящим для сборки веб-узлов и задач встраиваемых систем.
Ограничения использования Rust
При создании приложений производственного уровня на Rust вы наверняка столкнетесь с некоторыми неудачами.
Среди них можно назвать крутую кривую обучения Rust, более длительное время компиляции из-за проверок памяти и других факторов, а также новую, небольшую экосистему.
Есть несколько недостатков, с которыми вы можете столкнуться при создании продуктов производственного уровня с помощью Rust. Вот некоторые из них:
Кривая обучения программированию на Rust очень крутая
По сравнению с другими популярными языками (Go, Python, JavaScript и т.д.), освоение Rust и создание на его основе приложений производственного уровня занимает значительное время.
Это не должно заставить вас отказаться от использования Rust. Освоив Rust, вы станете действительно продуктивно создавать и развертывать приложения, а также получите все преимущества использования Rust.
Программы на языке Rust долго компилируются
Проверка памяти и параллелизма во время компиляции в сочетании с некоторыми другими факторами приводит к длительному времени компиляции программ на Rust.
В зависимости от размера приложения длительное время компиляции может привести к узким местам на этапах разработки или производства.
В Rust меньшая экосистема библиотек
Rust – относительно новый язык по сравнению со многими другими популярными языками, и экосистема библиотек, которые вы можете использовать, ограничена.
Многие библиотеки (крейты) все еще находятся в производстве, и вы можете посмотреть на таких сайтах, как AreWeWebYet, обзор готовых к производству крейтов, которые вы можете использовать для создания веб-приложений на Rust.
Варианты развертывания Rust
Rust уже получил широкое распространение, поэтому существует множество вариантов развертывания приложений, которые вы можете выбрать.
Большинство вариантов развертывания Rust – это платформы на базе IaaS или CaaS. Вы можете выбрать одну из них в зависимости от спецификаций вашего проекта.
Инфраструктура как услуга (IaaS), например AWS
Поставщики инфраструктуры как услуги (IaaS) предоставляют вам инфраструктуру для развертывания и управления приложениями, работающими на виртуальных машинах в облаке.
Вы можете воспользоваться услугами, которые предоставляют платформы IaaS, чтобы развернуть свои приложения Rust на виртуальных машинах под управлением таких операционных систем, как Linux, Windows, macOS и других, поддерживающих Rust.
Вот список популярных платформ IaaS:
- Amazon Web Services
- Digital Ocean
- Google Cloud
- Linode
- Microsoft Azure
Контейнеризация как услуга, как Back4app Containers
Поставщики услуг по контейнеризации (CaaS) помогут вам упростить развертывание приложений с помощью технологий контейнеризации.
Чтобы развернуть свое приложение на платформах, поддерживающих контейнеризацию, вы соберете свое приложение и все его зависимости в изолированный контейнер.
Контейнеры изолированы и переносимы, но вам придется работать в рамках возможностей поставщика CaaS.
Некоторые провайдеры IaaS предоставляют функции CaaS. Кроме того, существуют платформы, которые предоставляют только гибкую функциональность CaaS в отдельности.
Вот список некоторых CaaS-платформ:
- Oracle Container Service
- Back4app
- Mirantix
- Docker Enterprise
Процесс развертывания приложения Rust
В этом разделе вы узнаете, как развернуть свое приложение Rust на платформе CaaS компании Back4app.
Что такое Back4app?
Back4app – это облачная платформа, которую можно использовать для создания и развертывания всех типов бэкэнд-сервисов для мобильных, веб- и других типов приложений.
Back4app предоставляет ИИ-агент, который можно использовать для оптимизации развертывания приложений на платформе. С его помощью можно управлять репозиториями GitHub, легко разворачивать код в облаке и управлять запущенными приложениями.
На внутренних серверах Back4app можно развернуть и запустить пользовательские контейнеры с помощью функции CaaS.
Используя образы контейнеров, вы можете расширять логику своего приложения, не заботясь о поддержании архитектуры сервера.
Создание и развертывание
Чтобы следовать этому руководству, на вашем компьютере должен быть установлен Rust. Вы можете посетить страницу установки Rust для ознакомления с различными доступными вариантами установки.
После установки Rust создайте сеанс терминала и выполните эту команду, чтобы инициализировать новый проект Rust
mkdir back4app-rust-deployment && cd back4app-rust-deployment && cargo init
После выполнения команды вы должны увидеть файл cargo.toml
в новом каталоге, который вы только что создали. Вы будете использовать cargo.toml
для управления зависимостями.
Затем добавьте эти директивы в секцию [dependencies]
вашего файла Cargo.toml
, чтобы установить эти зависимости при сборке приложения.
[dependencies]
actix-web = "4.0"
serde = { version = "1.0", features = ["derive"] }
serde_derive = { version = "1.0" }
serde_json = "1.0"
lazy_static = "1.4"
Критерий actix-web
обеспечивает маршрутизацию и другие функции, связанные с HTTP, критерии serde
, serde_derive
и serde_json
предоставляют функции для различных операций с JSON, а критерий lazy_static
обеспечивает хранение данных in-memory для API во время выполнения.
Добавьте эти импорты в начало вашего файла [main.rs](<http://main
.rs>):
use serde::{Serialize, Deserialize};
use actix_web::{web, App, HttpServer, HttpResponse, Error};
use std::sync::Mutex;
extern crate lazy_static;
use lazy_static::lazy_static;
С помощью struct можно определить структуру данных для API на основе нужных вам полей. Вот структура, которая изображает человека с идентификатором, именем пользователя и электронной почтой.
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Person {
pub id: i32,
pub username: String,
pub email: String,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
являются реализациями крейта serde_derive
для структуры Person
, чтобы получить доступ и использовать ее функции.
Вот как можно использовать крейт lazy_static
для создания хранилища данных in-memory для вашего API на основе структурного типа Person
:
lazy_static! {
static ref DATA_STORE: Mutex<Vec<Person>> = Mutex::new(Vec::new());
}
Вы создали лениво инициализируемое, безопасное для потоков общее хранилище для структуры People. Вы будете использовать его в своих функциях-обработчиках для хранения и получения данных.
Функция обработчика POST
Функция-обработчик запроса POST принимает на вход JSON-представление структуры Person
. Затем она возвращает клиенту HTTP-ответ и ошибку по запросу.
Добавьте этот блок кода в файл [main.rs]()
, чтобы реализовать функциональность обработчика POST-запросов.
async fn create_person(new_person: web::Json<Person>) -> Result<HttpResponse, Error> {
let mut data_store = DATA_STORE.lock().unwrap();
let new_id = data_store.len() as i32 + 1;
let mut person = new_person.into_inner();
person.id = new_id;
data_store.push(person.clone());
Ok(HttpResponse::Ok().json(person))
}
create_person
– это асинхронная функция, которая обращается к общему хранилищу данных, генерирует новый идентификатор для структуры Person
, преобразует JSON-представление Person
в структуру и помещает его в хранилище данных.
После успешного запроса функция предоставляет клиенту данные, которые были введены в базу данных, вместе с кодом состояния 200.
Функция обработчика GET
Здесь функция-обработчик GET демонстрирует чтение всех данных из хранилища и возвращает их клиенту в формате JSON.
Добавьте этот блок кода в свой проект, чтобы реализовать функцию обработчика GET
async fn get_people() -> Result<HttpResponse, Error> {
let data_store = DATA_STORE.lock().unwrap();
let people: Vec<Person> = data_store.clone();
Ok(HttpResponse::Ok().json(people))
}
Функция get_people
– это асинхронная функция, которая обращается к хранилищу данных и записывает содержимое клиенту в качестве ответа.
При успешном запросе функция отвечает клиенту кодом состояния 200
со всеми данными из хранилища данных.
Функция обработчика PUT
Ваша функция-обработчик запроса PUT должна обновить запись в хранилище данных на основе поля объекта.
Вот как можно реализовать функцию-обработчик PUT для вашего API:
async fn update_person(
id: web::Path<i32>,
person_update: web::Json<Person>,
) -> Result<HttpResponse, Error> {
let mut data_store = DATA_STORE.lock().unwrap();
if let Some(person) = data_store.iter_mut().find(|p| p.id == *id) {
*person = person_update.into_inner();
Ok(HttpResponse::Ok().json("Person updated successfully"))
} else {
Ok(HttpResponse::NotFound().json("Person not found"))
}
}
Функция update_person
принимает ID и новую запись из запроса. Затем она обходит хранилище данных и заменяет запись на новую, если она существует.
Функция обработчика DELETE
Функция запроса DELETE принимает один аргумент – поле ID из сделанного запроса. При выполнении функции она удалит запись с указанным ID из хранилища данных.
Добавьте эту реализацию функции-обработчика DELETE в свою программу.
// DELETE
pub async fn delete_person(id: web::Path<i32>) -> Result<HttpResponse, Error> {
let mut data_store = DATA_STORE.lock().unwrap();
if let Some(index) = data_store.iter().position(|p| p.id == *id) {
data_store.remove(index);
Ok(HttpResponse::Ok().json("Deleted successfully"))
} else {
Ok(HttpResponse::NotFound().json("Person not found"))
}
}
Функция delete_person
удаляет запись с указанным идентификатором из хранилища данных. В зависимости от состояния операции функция возвращает клиенту строку и код состояния.
Сопоставление функций обработчика с маршрутами
После определения конечных точек вам нужно будет сопоставить маршруты с функциями-обработчиками, чтобы получить доступ к их функционалу.
Вот как можно назначить маршруты функциям-обработчикам:
#[actix_web::main]
async fn main() -> std::io::Result<()> {
HttpServer::new(|| {
App::new()
.route("/person", web::post().to(create_person))
.route("/people", web::get().to(get_people))
.route("/person/{id}", web::put().to(update_person))
.route("/person/{id}", web::delete().to(delete_person))
})
.bind("0.0.0.0:8000")?
.run()
.await
}
Главная
функция – это асинхронная функция, которая устанавливает сервер после сопоставления маршрутов с функциями-обработчиками.
Функция HttpServer::new
инстанцирует HTTP-сервер, функция App::new()
создает новый экземпляр приложения, а функция route
сопоставляет маршруты с функцией-обработчиком.
Функция bind
указывает адрес нового приложения, а функция run
запускает его.
Контейнеризация приложений Rust с помощью Docker
Docker – самая популярная технология контейнеризации на рынке. Вы можете контейнеризовать свои приложения Rust с помощью Docker для переносимости и развернуть их на Back4app несколькими щелчками мыши.
Выполните эту команду, чтобы создать новый Dockerfile в вашем проекте:
touch Dockerfile
Откройте Dockerfile и добавьте в него эти инструкции по сборке:
# Use Rust Nightly as the base image
FROM rustlang/rust:nightly
# Set the working directory inside the container
WORKDIR /usr/src/myapp
# Copy the current directory contents into the container
COPY . .
# Build the application
RUN cargo build --release
# Expose port 8000
EXPOSE 8000
# Define the command to run the application
CMD ["./target/release/back4app-rust-deployment"]
Эти инструкции определяют базовый образ и инструкции по сборке для контейнеризации вашего приложения Rust с помощью Docker.
Вот описание содержимого Dockerfile:
- Директива
FROM rustlang/rust:nightly
задает базовый образ для Dockerfile. Docker извлекает этот образ из репозитория и собирает на его основе ваши программы. - Директива
WORKDIR /usr/src/myapp
задает рабочий каталог для вашего приложения внутри контейнера. - Директива
COPY . .
копирует все содержимое вашего рабочего каталога в текущий рабочий каталог контейнера. - Директива
RUN cargo build --release
выполняет команду для сборки вашего приложения в контейнере. - Директива
EXPOSE 8000
открывает порт8000
контейнера для входящих запросов. CMD ["./target/release/back4app-rust-deployment"]
запускает программу (исполняемый файл из операции сборки).
После того как вы написали Dockerfile, вы можете приступить к развертыванию контейнера на контейнерном сервисе Back4app.
Развертывание контейнера на Back4app
Для развертывания контейнеров вам необходимо создать учетную запись на Back4app.
Вот шаги по созданию учетной записи Back4app.
- Посетите веб-сайт Back4app
- Нажмите кнопку “Регистрация” в правом верхнем углу страницы.
- Заполните форму регистрации и отправьте ее, чтобы создать учетную запись.
Теперь, когда вы успешно создали учетную запись Back4app, войдите в систему и нажмите кнопку NEW APP
, расположенную в правом верхнем углу целевой страницы.
Вам будет предложено выбрать способ создания приложения. Выберите вариант "Контейнер как сервис"
.
Теперь подключите свой аккаунт Github к аккаунту Back4app и настройте доступ к репозиториям в вашем аккаунте или к конкретному проекту.
Выберите приложение, которое вы хотите развернуть (то, которое было в этом уроке), и нажмите кнопку Выбрать.
При нажатии кнопки select вы перейдете на страницу, где сможете заполнить информацию о своем приложении, включая название ветки, корневой каталог и переменные окружения.
Процесс развертывания начнется автоматически,
Развертывание с помощью Back4app AI Agent
Чтобы ускорить процесс разработки, вы также можете развернуть свое приложение с помощью агента искусственного интеллекта Back4app, как показано на изображении ниже:
Перейдите по этой ссылке , чтобы установить контейнерное приложение Back4app в свой аккаунт на GitHub, и выполните шаги, показанные на изображении выше, чтобы настроить его.
Завершив настройку приложения, вы можете приступить к развертыванию приложения с агентом искусственного интеллекта.
Перейдите по указанной ссылке, чтобы следить за ходом развертывания вашего приложения.
Заключение
Вы узнали, как создать и развернуть приложение Rust в Docker-контейнере на Back4app.
Развертывание приложений на Back4app – отличный способ упростить управление инфраструктурой бэкэнда.
Back4App предоставляет мощные инструменты для управления данными, масштабирования приложения и мониторинга его производительности.
Это отличный выбор для разработчиков, которые хотят создавать отличные приложения, а не управлять серверами.