Вы можете найти Введение в веб -программирование в Rust сюда. Следуй за мной на Twitter Чтобы всегда получать последнюю информацию о веб -разработке в ржавчине. Также зарегистрируйте GitHub Repository к его серии.

Обновление 08.07.2019: прилив 0.2.0

В этой серии 3 гола

1. Покажите препятствия, которые будут столкнуться с новыми разработчиками при программировании в ржавчине, а также с его преимуществами, когда дело доходит до конкретной темы (на этот раз: развертывания).
2. Показать различные варианты для веб -разработки в Rust.
3. Всегда имейте обновленное приложение в сфере производства впоследствии.

Номер три очень важен для меня. Вот почему мы начинаем часть 02/x с несколькими идеями о том, что вы можете построить, и почему этот учебник будет выглядеть так же, как и. Всякий раз, когда вы узнаете что -то новое, возьмите эту ментальную модель:

Никогда не делай ничего ради себя

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

«Так как мне научиться тогда?»

1. Имейте приложение или идею, которую вы хотите увидеть в производстве. Это может быть сервисом для расчета первичных чисел, веб -приложения для отслеживания ваших целей программирования, услуги, которая получает ваши последние лайки на GitHub и отслеживает их деятельность и т. Д. Вы решаете, что хотите построить.
2. Считайте себя ответственным за это. Расскажите своим друзьям, коллегам по работе или своему партнеру, что вы обещаете им, что через 6 месяцев они смогут использовать эту услугу. Каждые несколько дней или недель вы будете держать их в курсе вашего текущего статуса.

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

Я также сделаю свою публичную:

В конце следующих 6 месяцев у меня есть веб -сервис с Frontend для моей встречи «Rust and Tell Berlin», чтобы ораторы могли представить предложения и слайды, и видео можно посмотреть на переговорах, которые проводились предыдущими событиями.

Я буду привлекать к ответственности через эту учебную серию.

Давайте двигаться дальше. В этой части серии мы хотим развернуть наше первое приложение. Если вы приехали из Nodejs, жизненный цикл развертывания выглядит так:

С Nodejs вы можете доставить любой код на производственный сервер. У вас должны быть хорошие тесты, Eslint и другие инструменты, чтобы поймать неопределенные ошибки.

В идеальном мире у нас есть цикл разработки, который выглядит так:

Таким образом, мы хотим сломать вещи как можно раньше и близко к коду (вашей локальной машине). Как только мы выяснили базу рабочего кода, мы хотели бы донести именно это рабочее решение на сервер. Из -за системы типа ржавчины и сильного компилятора мы сможем упаковать работающий бинар и перенести его в производство. Тесты будут покрывать остальные ошибки.

Ржавчина перемещает возможные ошибки ближе к среде кодирования

a) Компилятор ржавчины поймает много проблем, почти все из них.

b) Вы можете поймать остальные с помощью хороших тестов (в нашем случае: обработка ошибок при получении неправильных параметров).

C) После того, как вы сможете скомпилировать свой код ржавчины, у вас есть двоичный файл, который можно отправить по -разному.

Разница между местным и готовым к производству кода

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

• случайным образом назначьте порт на основе среды он работает
• обрабатывать ошибки изящно
• Ответьте на не ожидаемый ввод с помощью надлежащих кодов возврата и сообщений
• Сбой в начале трубопровода развертывания с надлежащей настройкой теста
• События журнала, так что ошибки можно проследить

В этой статье мы рассмотрим первое обязательное (случайное назначение порта). Каждая статья в серии будет охватывать остальные требования.

Четыре различных варианта развертывания

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

• Управляемые развертывания/хостинг (Heroku)
• Самостоятельно управляется через Docker и реестр докеров
• Самостоятельно управляется через Docker и Реестр GIT
• Управляемые функции Lambda без сервера (AWS Lambda, Zeit Now)

Мы рассмотрим каждый из этих вариантов в этой статье и увидим преимущества, недостатки и как подготовить код ржавчины, чтобы его можно было развернуть (наилучшим образом).

Создание первой версии вашего приложения

Как мы говорили вначале, нам нужна идея и то, что мы хотим построить. Даже если мы наметим более широкую картину приложения в следующей статье (03/x), мы можем начать и выбрать структуру, с которой мы хотим построить его:

• ракета
• Аккс
• Готэм
• Прилив (работа в процессе)

Как видно в первой статье, вы можете пойти на более низкий уровень, если хотите:

• гипер
• reqwest
• H2

Мы выберем одну структуру для письменной версии этой статьи. Я выберу Прилив , поскольку я планирую внести свой вклад в это больше в будущем. Я наметаю решения для Rocket и Actix в GitHub Repository для этой серии.

Установите наше приложение

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

$ rustup install nightly-2019-02-25
$ rustup default nightly

Это генерирует нашу первую структуру папок. Голые кости используемого веб -приложения с приливом выглядят так:

Cargo.toml

[package]
name = "my-cool-web-app"
version = "0.1.0"
authors = ["YOUR NAME + EMAIL"]
edition = "2018"

[dependencies]
tide = "0.2.0"

main.rs

#![feature(async_await)]

fn main() {
    let mut app = tide::App::new(());
    app.at("/").get(async move |_| "Hello, world!");

    app.serve();
}

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

Наш main.rs должен сопровождать эти требования:

#![feature(async_await)]

extern crate tide;

use tide::App;
use std::{env, net::SocketAddr};


fn main() {
    let mut app = App::new(());
    let address = SocketAddr::from(([127, 0, 0, 1], get_server_port()));

    app.at("/").get(async move |_| "hello world");
    app.serve(address).expect("Start server");
}

fn get_server_port() -> u16 {
    env::var("PORT")
        .ok()
        .and_then(|port| port.parse().ok())
        .unwrap_or_else(|| 8186)
}

С помощью этой настройки мы можем пройти каждый вариант развертывания.

Управляемые развертывания через Heroku

Управляемые среды по большей части просто абстракция. Внутренне они делают то же самое, что и с вашим собственным трубопроводом: подтолкнуть код в репозиторий GIT. «Крюк» — это наблюдение за этим репозиторием, и на изменениях начнут собирать последнюю версию и запускать его. Для вас, однако, это просто git push heroku Master Анкет

Чтобы начать, вам нужен Аккаун Heroku (свободно). Войдите в систему с новой учетной записью и создайте новое приложение:

Нажав «Создать приложение», Хероку объясняет под вкладкой «Развертывание», как подтолкнуть код на свои серверы:

Подготовьте свой код

Во -первых, мы должны быть в состоянии подтолкнуть нашу кодовую базу в удаленное местоположение (Heroku). Поэтому, пожалуйста, установите Цепочка инструментов Heroku Анкет После этого мы можем добавить удаленное место в нашем репозитории GIT:

$ cd my-cool-web-app
$ heroku login
$ heroku git:remote -a my-cool-web-app

Затем нам нужно рассказать Хероку, как запустить наше приложение после его построения. Heroku ожидает файла с именем Procfile , у которого есть команда начала:

$ touch Procfile

И поместите следующую строку это:

web ./target/release/my-cool-web-app

Мы также должны сказать Heroku, какую версию Rust мы используем. Поскольку мы хотим использовать ночь, мы создаем файл с именем Rustconfig В корневом каталоге:

$ touch RustConfig

С следующей строкой:

VERSION=nightly

Предостережение

Руста настолько новичок, что Хероку не поддерживает его из коробки. Нам нужно установить и активировать «пакет» для ржавчины. Итак, внутри корневого каталога вашего приложения выполните следующие команды:

$ heroku create --buildpack emk/rust
$ heroku buildbpacks:set emk/rust

Это активирует языковую поддержку ржавчины.

Теперь мы можем:

$ git add .
$ git commit -m "Init"
$ git push heroku master

Когда мы преуспели, мы возвращаемся к приборной панели Heroku в браузере и нажимаем на сгенерированный домен (в разделе «Настройки»). Браузер Windiw должен открыть и отображать «Привет, мир!».

Резюме

• Heroku облегчает развертывание вашего приложения
• Менее чем за 5 минут у вас есть работающая версия вашего приложения в прямом эфире
• Вы можете назначить свой собственный домен и активировать HTTPS (если вы заплатите)
• Heroku — лучший вариант, когда дело доходит до этого учебника и начальных боковых проектов: дешевые, простые в использовании и удаляет накладные расходы на отдельные расходы, особенно в начале

Докер

Использование Docker имеет огромное преимущество в том, что вы выбираете ваши трубопроводы и среды. Вы можете построить изображение локально и подтолкнуть его как есть в реестр Docker. Оттуда сервер может взять (скачать) и выполнить ( docker run ) IT. Или вы создаете план (dockerfile), который другой сервис может использовать для строительства на своих серверах.

Если вы используете Docker для развертывания, у вас есть два варианта. Первым является то, что ваш код (с помощью DockerFile) в реестр GIT (например, GitHub или BitBucket), а затем у вас есть настроенный сервер развертывания, который слушает изменения, SSHS в реестр GIT, берет код, развертывает и запускает его.

Ваш второй вариант — использовать реестр Docker. Там у вас есть преимущество, чтобы предварительно построить контейнер и отправить его как. Это иногда запускает развертывание, и вы должны отправлять меньше кода (особенно в случае ржавчины).

Мы можем использовать функцию ржавчиков, чтобы быть способным быть скомпилированным в двоичный файл. Мы можем даже пойти на шаг вперед и собрать статический двоичный бакаринг без внешних зависимостей. Что нам нужно для этого, так это:

• Построить ржаво -двоичный
• Статически связал необходимые библиотеки C с ним, чтобы он мог работать самостоятельно

Результатом будет иметь двоичный файл, который даже не нуждается в ржавчине. Благодаря сообществу с открытым исходным кодом и Эрику Кидду, уже есть решение, которое помогает нам в этом.

Результатом является очень маленькое изображение Docker без внешних зависимостей. Встретиться Rust-Musl-Builder Анкет Это изображение Docker, которое помогает вам построить статические двоичные файлы ржавчины. Он загрузит все изображение сразу после первого исполнения.

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

$ cd my-cool-web-app

Прежде чем создать наш Dockerfile, давайте посмотрим, что мы на самом деле пытаемся сделать. Мы используем Rust-Musl-Builder, чтобы статически связать библиотеку Musl-LIBC в наш двоичный файл.

$ docker run --rm -it -v "$(pwd)":/home/rust/src ekidd/rust-musl-builder cargo build --release

Это создаст наш супер маленький бинар. Вы можете проверить это так:

$ ls -lh target/x86_64-unknown-linux-musl/release/my-cool-web-app

Это всего лишь несколько МБ маленького (в моем примере: 4,4MB). Чтобы иметь возможность воссоздать эту процедуру снова и снова, а не только на нашей местной машине, но и в конвейере развертывания на разных серверах, мы создаем многоступенчатый DockerFile.

FROM ekidd/rust-musl-builder:nightly AS build
COPY . ./
RUN sudo chown -R rust:rust .
RUN cargo build --release

FROM scratch
COPY --from=build /home/rust/src/target/x86_64-unknown-linux-musl/release/my-cool-web-app /
ENV PORT 8181
EXPOSE ${PORT}
CMD ["/my-cool-web-app"]

Вы можете построить изображение сейчас через:

$ docker build -t my-cool-web-app:latest .

И запустите это с:

$ docker run -d --rm -P --name heroku heroku:latest

Теперь вы можете открыть браузер (в macOS) через:

$ open http://$(docker container port my-cool-web-app 8181)

Мы только что создали супер минимальное изображение Docker, которое содержит наш бинар без внешних зависимостей. Вы можете осмотреть свое только что созданное изображение через:

$ docker image ls my-cool-web-app

Резюме

• Docker — это зверь, но при использовании мудрого может быть довольно полезным
• Особенно с Rust: вы можете создать статически связанные двоичные файлы, которые очень маленькие и даже не нуждаются в среде ржавчины для работы
• У вас также есть гораздо больше вариантов размещения и запуска вашего приложения при выборе Docker
• Тем не менее, среды управляемого хостинга, такие как Heroku, не позволяют выдвигать изображения Docker в их среду

Без сервера время выполнения — Zeit/СЕЙЧАС

Serverless — это другое мышление, чем первые два варианта. Serverless также означает без сохранности, поэтому вы создаете не веб -приложения, а функции. Вместо того, чтобы встроить конечные точки API в ваше приложение, у вас просто есть эти конечные точки API (без серверов: обработчики). Наши веб -фреймворки, такие как Rocket и Actix, могут быть здесь излишним. Прямо сейчас Zeit не поддерживает Rust Nightly Builds в своей новой без серверной среде Анкет

Таким образом, вместо создания двоичного (с новым грузом, новым веб—приложением ), мы создаем библиотеку:

$ cargo new now-service --lib
$ cd now-service

Здесь мы должны создать файл с именем Теперь

{
  "name": "now-service",
  "version": 2,
  "builds": [
    {
      "src": "src/index.rs",
      "use": "@now/rust"
    }
  ]
}

И наш src/lib.rs Пример выглядит так:

use http::{Request, Response, StatusCode, header};

fn handler(request: Request<()>) -> http::Result> {
    let response = Response::builder()
        .status(StatusCode::OK)
        .header(header::CONTENT_TYPE, "text/html")
        .body("
Welcome to Rust on Now
".to_string())
        .expect("failed to render response");

    Ok(response)
}

Как и в случае с Heroku, вам нужно установить Zeit Toolchain , который называется «сейчас». Есть несколько вариантов. Если вы находитесь в MacOS, вы можете сделать это через:

$ brew cask install now

Который устанавливает приложение Now. Найдите его в папке/приложениях и откройте его. Вы можете закончить установку, набрав свой адрес электронной почты. Это также установит цепочку инструментов командной строки.

Это в основном. Вы можете напечатать:

$ now

и нажмите Enter. Это начнет загрузку вашего приложения. Войдите на ваш Zeit Dashboard и нажмите на предоставленную ссылку.

Резюме

• Serverless позволяет сэкономить затраты: служба просто работает при запросе
• Это заканчивается в более высокое время загрузки, которое необходимо учитывать
• Мышление без сервера позволяет вам переосмыслить состояние, и если вам действительно нужно полностью сбежное веб -приложение для некоторых вариантов использования
• Развертывание может занять немного больше времени при использовании AWS Lambda или Zeits сейчас

Следуй за мной на Twitter Чтобы всегда получать последнюю информацию о веб -разработке в ржавчине. Также зарегистрируйте GitHub Repository к его серии.

Оригинал: «https://dev.to/gruberb/web-programming-in-rust-02x-deploy-your-first-app-1k05»