Как развернуть приложение Rust?

Уже более 4 лет Rust является самым любимым языком в опросе разработчиков StackOverflow благодаря множеству возможностей, которые он предлагает пользователям.

Mozilla создала Rust, чтобы сделать его надежным, производительным и удобным для разработчиков. Синтаксис Rust схож с синтаксисом таких языков, как C++ и C, на разработчиков которых и ориентирован язык.

Rust также фокусируется на безопасности памяти и параллелизме с моделями, которые позволяют избежать связанных с ними подводных камней, с которыми сталкиваются разработчики, использующие другие языки.

Вы узнаете, как создавать API на Rust, чтобы использовать преимущества этой статьи. Вы научитесь создавать, контейнировать и развертывать приложение на языке Rust на бесплатном сервисе контейнеризации Back4app.

Преимущества использования 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:

1. Директива FROM rustlang/rust:nightly задает базовый образ для Dockerfile. Docker извлекает этот образ из репозитория и собирает на его основе ваши программы.
2. Директива WORKDIR /usr/src/myapp задает рабочий каталог для вашего приложения внутри контейнера.
3. Директива COPY . . копирует все содержимое вашего рабочего каталога в текущий рабочий каталог контейнера.
4. Директива RUN cargo build --release выполняет команду для сборки вашего приложения в контейнере.
5. Директива EXPOSE 8000 открывает порт 8000 контейнера для входящих запросов.
6. CMD ["./target/release/back4app-rust-deployment"] запускает программу (исполняемый файл из операции сборки).

После того как вы написали Dockerfile, вы можете приступить к развертыванию контейнера на контейнерном сервисе Back4app.

Развертывание контейнера на Back4app

Для развертывания контейнеров вам необходимо создать учетную запись на Back4app.

Вот шаги по созданию учетной записи Back4app.

1. Посетите веб-сайт Back4app
2. Нажмите кнопку “Регистрация” в правом верхнем углу страницы.
3. Заполните форму регистрации и отправьте ее, чтобы создать учетную запись.

Теперь, когда вы успешно создали учетную запись Back4app, войдите в систему и нажмите кнопку NEW APP, расположенную в правом верхнем углу целевой страницы.

Вам будет предложено выбрать способ создания приложения. Выберите вариант "Контейнер как сервис".

Теперь подключите свой аккаунт Github к аккаунту Back4app и настройте доступ к репозиториям в вашем аккаунте или к конкретному проекту.

Выберите приложение, которое вы хотите развернуть (то, которое было в этом уроке), и нажмите кнопку Выбрать.

При нажатии кнопки select вы перейдете на страницу, где сможете заполнить информацию о своем приложении, включая название ветки, корневой каталог и переменные окружения.

Процесс развертывания начнется автоматически,

Развертывание с помощью Back4app AI Agent

Чтобы ускорить процесс разработки, вы также можете развернуть свое приложение с помощью агента искусственного интеллекта Back4app, как показано на изображении ниже:

Перейдите по этой ссылке , чтобы установить контейнерное приложение Back4app в свой аккаунт на GitHub, и выполните шаги, показанные на изображении выше, чтобы настроить его.

Завершив настройку приложения, вы можете приступить к развертыванию приложения с агентом искусственного интеллекта.

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

Заключение

Вы узнали, как создать и развернуть приложение Rust в Docker-контейнере на Back4app.

Развертывание приложений на Back4app – отличный способ упростить управление инфраструктурой бэкэнда.

Back4App предоставляет мощные инструменты для управления данными, масштабирования приложения и мониторинга его производительности.

Это отличный выбор для разработчиков, которые хотят создавать отличные приложения, а не управлять серверами.