{"draftJsState":{"blocks":[{"data":{"image":{"id":"6494b90a784a7c704bd5e654"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"atomic:image","key":"92nnl"},{"data":{},"depth":0,"entityRanges":[{"key":0,"length":22,"offset":10}],"inlineStyleRanges":[],"text":"Источник: Nuances of Programming","type":"unstyled","key":"4vgcp"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"API-шлюз является важным компонентом современной микросервисной архитектуры, поскольку он выполняет посредническую функцию между клиентами и сервисами бэкенда. Он помогает направлять входящие запросы в соответствующие нисходящие сервисы на основе запрошенного пути, а также обеспечивает централизованный механизм управления безопасностью и аутентификацией.","type":"unstyled","key":"2htsj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В данной статье мы реализуем API-шлюз в Rust посредством библиотеки Hyper. В качестве нисходящих сервисов воспользуемся сервисами Kubernetes. Кроме того, для обработки аутентификации пользователя реализуем сторонний API авторизации.","type":"unstyled","key":"15jlh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Создание среды разработки","type":"header-three","key":"b7l9u"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Прежде чем приступить к написанию кода, необходимо создать среду разработки. Воспользуемся Rust в качестве программного языка и библиотекой Hyper для обработки HTTP-запросов. Кроме того, потребуются библиотеки serde и yaml-rust для работы с YAML-файлами. Перечислим этапы создания среды.","type":"unstyled","key":"cb7e2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Установка Rust и Cargo по инструкциям с официального сайта Rust.","type":"ordered-list-item","key":"brg3n"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Создание нового проекта Rust с использованием cargo new .","type":"ordered-list-item","key":"ae9bt"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Добавление необходимых зависимостей в файл Cargo.toml, как показано ниже.","type":"ordered-list-item","key":"7ctpg"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Выполнение команды cargo build для загрузки и сборки зависимостей.","type":"ordered-list-item","key":"fmkjk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"[dependencies]\nserde = { version = \"1.0.159\", features = [\"derive\"] }\nserde_yaml = \"0.9.19\"\ntokio = { version = \"1.16.1\", features = [\"full\"] }\nhyper = { version = \"0.14.10\", features = [\"full\"] }\nreqwest = { version = \"0.11\", features = [\"json\"] }","type":"blockquote","key":"e17t2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Реализация API-шлюза","type":"header-three","key":"1fvga"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Создав среду разработки, приступаем к реализации API-шлюза. Для лучшего понимания разобьем данный процесс на небольшие этапы.","type":"unstyled","key":"f945u"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":26,"offset":0,"style":"BOLD"}],"text":"Парсинг файла конфигурации","type":"header-three","key":"6r7cb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Воспользуемся YAML-файлом для настройки API-шлюза. Данный файл содержит сопоставления путей с сервисами и URL-адрес API авторизации Authorization. Пример YAML-файла:","type":"unstyled","key":"eo8ca"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"---\nauthorization_api_url: \"https://auth.example.com/api/v1/authorization\"\nservices:\n - path: \"/users\"\n target_service: \"http://user-service.default.svc.cluster.local\"\n target_port: \"8080\"\n - path: \"/orders\"\n target_service: \"http://order-service.default.svc.cluster.local\"\n target_port: \"8080\"","type":"blockquote","key":"csc9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Применяем библиотеки serde и yaml-rust для парсинга YAML-файла. Ниже представлен код для выполнения этой задачи:","type":"unstyled","key":"2gs0f"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"use serde::{Deserialize, Serialize};\nuse std::{fs::File, io::Read};\nuse serde_yaml;\n\n#[derive(Debug, Deserialize, Serialize, Clone)]\npub struct ServiceConfig {\n pub path: String,\n pub target_service: String,\n pub target_port: String,\n}\n\n#[derive(Debug, Deserialize, Serialize, Clone)]\npub struct GatewayConfig {\n pub authorization_api_url: String,\n pub services: Vec,\n}\n\npub fn load_config(path: &str) -> Config {\n let mut file = File::open(path).unwrap();\n let mut contents = String::new();\n file.read_to_string(&mut contents).unwrap();\n serde_yaml::from_str(&contents).unwrap()\n}","type":"blockquote","key":"9r8k1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Структура GatewayConfig представляет собой YAML-файл после парсинга и содержит 2 поля: authorization_api_url и services. Поле authorization_api_url хранит URL-адрес API авторизации. Поле services — это структура данных HashMap, сопоставляющая путь запроса со структурой ServiceConfig. Эта структура содержит URL-адрес целевого сервиса и порт.","type":"unstyled","key":"c57h6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":22,"offset":0,"style":"BOLD"}],"text":"Маршрутизация запросов","type":"header-three","key":"dean7"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Задача данного этапа — направить входящие запросы к соответствующим нисходящим сервисам на основе запрошенного пути. Для обработки HTTP-запросов и ответов применяется библиотека hyper. Рассмотрим код для маршрутизации запросов:","type":"unstyled","key":"3af6e"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"use config::{load_config, GatewayConfig, ServiceConfig};\nuse hyper::header::HeaderValue;\nuse hyper::http::request::Parts;\nuse hyper::service::{make_service_fn, service_fn};\nuse hyper::{Body, Client, Request, Response, Server};\nuse reqwest::header::{HeaderMap, AUTHORIZATION};\nuse std::net::SocketAddr;\n\nmod config;\n\n#[tokio::main]\nasync fn main() {\n let config = load_config(\"config.yaml\");\n\n let addr = SocketAddr::from(([0, 0, 0, 0], 8080));\n\n let make_svc = make_service_fn(move |_conn| {\n let config = config.clone();\n\n async {\n Ok::<_, hyper::Error>(service_fn(move |req| {\n let config = config.clone();\n handle_request(req, config)\n }))\n }\n });\n\n let server = Server::bind(&addr).serve(make_svc);\n if let Err(e) = server.await {\n eprintln!(\"server error: {}\", e);\n }\n}\n\nasync fn handle_request(\n req: Request,\n config: GatewayConfig,\n) -> Result, hyper::Error> {\n let path = req.uri().path();\n let service_config = match get_service_config(path.clone(), &config.services) {\n Some(service_config) => service_config,\n None => {\n return not_found();\n }\n };\n\n let auth_token = match authorize_user(&req.headers(), &config.authorization_api_url).await {\n Ok(header) => header,\n Err(_) => {\n return service_unavailable(\"Failed to connect to Authorization API {}\");\n }\n };\n\n let (parts, body) = req.into_parts();\n let downstream_req = build_downstream_request(parts, body, service_config, auth_token).await?;\n\n match forward_request(downstream_req).await {\n Ok(res) => Ok(res),\n Err(_) => service_unavailable(\"Failed to connect to downstream service\"),\n }\n}\n\nfn get_service_config<'a>(path: &str, services: &'a [ServiceConfig]) -> Option<&'a ServiceConfig> {\n services.iter().find(|c| path.starts_with(&c.path))\n}\n\nasync fn authorize_user(headers: &HeaderMap, auth_api_url: &str) -> Result {\n let auth_header_value = match headers.get(AUTHORIZATION) {\n Some(value) => value.to_str().unwrap_or_default(),\n None => \"\",\n };\n\n let auth_request = reqwest::Client::new()\n .get(auth_api_url)\n .header(AUTHORIZATION, auth_header_value);\n\n match auth_request.send().await {\n Ok(res) if res.status().is_success() => Ok(auth_header_value.to_string()),\n _ => Err(()),\n }\n}\n\nasync fn build_downstream_request(\n parts: Parts,\n body: Body,\n service_config: &ServiceConfig,\n auth_token: String,\n) -> Result, hyper::Error> {\n let req = Request::from_parts(parts, body);\n let uri = format!(\n \"{}:{}{}\",\n service_config.target_service,\n service_config.target_port,\n req.uri().path()\n );\n\n let mut downstream_req_builder = Request::builder()\n .uri(uri)\n .method(req.method())\n .version(req.version());\n\n *downstream_req_builder.headers_mut().unwrap() = req.headers().clone();\n\n downstream_req_builder\n .headers_mut()\n .unwrap()\n .insert(\"Authorization\", HeaderValue::from_str(&auth_token).unwrap());\n\n let body_bytes = hyper::body::to_bytes(req.into_body()).await?;\n\n let downstream_req = downstream_req_builder.body(Body::from(body_bytes));\n\n Ok(downstream_req.unwrap())\n}\n\nasync fn forward_request(req: Request) -> Result, ()> {\n match Client::new().request(req).await {\n Ok(res) => Ok(res),\n Err(_) => Err(()),\n }\n}\n\nfn not_found() -> Result, hyper::Error> {\n let mut response = Response::new(Body::from(\"404 Not Found\"));\n *response.status_mut() = hyper::StatusCode::NOT_FOUND;\n Ok(response)\n}\n\nfn service_unavailable(reason: T) -> Result, hyper::Error>\nwhere\n T: Into,\n{\n let mut response = Response::new(reason.into());\n *response.status_mut() = hyper::StatusCode::SERVICE_UNAVAILABLE;\n Ok(response)\n}","type":"blockquote","key":"fbn3u"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Функция handle_request сначала вызывает функцию authorize_user, чтобы проверить, авторизован ли пользователь. Если он авторизован, функция ищет запрошенный путь в структуре GatewayConfig для получения URL-адреса целевого сервиса и порта. Если запрошенный путь не найден, функция возвращает ошибку 404 Not Found. Если пользователь не авторизован или возникла ошибка с API авторизации, функция возвращает ответ 401 Unauthorized.","type":"unstyled","key":"d9nfk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Функция authorize_user отправляет запрос POST к API авторизации с заголовком Authorization из исходного запроса. Статус ответа 200 OK говорит о том, что пользователь авторизован, и функция возвращает Ok(()). В противном случае пользователь не авторизован, и функция возвращает ошибку.","type":"unstyled","key":"437aa"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Функция main загружает структуру GatewayConfig из файла config.yaml, создает сервер Hyper с помощью make_service_fn и прослушивает входящие запросы на порт 8080.","type":"unstyled","key":"4i5v"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":26,"offset":0,"style":"BOLD"}],"text":"Написание модульных тестов","type":"header-three","key":"9n3mp"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"На этом этапе пишем модульные тесты, чтобы убедиться в корректной работе API-шлюза. Тестируем логику авторизации, создавая 2 имитационные конечные точки API авторизации: одна из них всегда возвращает 200 OK, а другая — 401 Unauthorized. Отправляем запросы на API-шлюз с соответствующими заголовками Authorization и проверяем корректность ответов.","type":"unstyled","key":"28cp1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"#[cfg(test)]\nmod tests {\n use super::*;\n\n #[test]\n fn test_load_config() {\n let path = \"config.yaml\";\n let config = load_config(path);\n\n assert_eq!(\n config.authorization_api_url,\n \"https://auth.example.com/api/v1/authorization\"\n );\n assert_eq!(config.services.len(), 2);\n\n let service1 = &config.services[0];\n assert_eq!(service1.path, \"/users\");\n assert_eq!(service1.target_service, \"http://user-service.default.svc.cluster.local\");\n assert_eq!(service1.target_port, \"8080\");\n\n let service2 = &config.services[1];\n assert_eq!(service2.path, \"/orders\");\n assert_eq!(service2.target_service, \"http://order-service.default.svc.cluster.local\");\n assert_eq!(service2.target_port, \"8080\");\n }\n}","type":"blockquote","key":"fp1a2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"203q4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"#[cfg(test)]\nmod tests {\n use super::*;\n use hyper::{StatusCode, Body};\n\n #[tokio::test]\n async fn test_handle_request_not_found() {\n let req = Request::builder().uri(\"/unknown\").body(Body::empty()).unwrap();\n let config = GatewayConfig {\n authorization_api_url: \"http://auth.example.com\".to_string(),\n services: vec![ServiceConfig {\n path: \"/service\".to_string(),\n target_service: \"http://service.example.com\".to_string(),\n target_port: \"80\".to_string(),\n }],\n };\n let res = handle_request(req, config).await.unwrap();\n assert_eq!(res.status(), StatusCode::NOT_FOUND);\n }\n\n #[tokio::test]\n async fn test_handle_request_authorize_user_error() {\n let req = Request::builder().uri(\"/service\").body(Body::empty()).unwrap();\n let config = GatewayConfig {\n authorization_api_url: \"http://auth.example.com\".to_string(),\n services: vec![ServiceConfig {\n path: \"/service\".to_string(),\n target_service: \"http://service.example.com\".to_string(),\n target_port: \"80\".to_string(),\n }],\n };\n let res = handle_request(req, config).await.unwrap();\n assert_eq!(res.status(), StatusCode::SERVICE_UNAVAILABLE);\n }\n\n #[tokio::test]\n async fn test_handle_request_forward_request_error() {\n let req = Request::builder().uri(\"/service\").body(Body::empty()).unwrap();\n let config = GatewayConfig {\n authorization_api_url: \"http://auth.example.com\".to_string(),\n services: vec![ServiceConfig {\n path: \"/service\".to_string(),\n target_service: \"http://unknown.example.com\".to_string(),\n target_port: \"80\".to_string(),\n }],\n };\n let res = handle_request(req, config).await.unwrap();\n assert_eq!(res.status(), StatusCode::SERVICE_UNAVAILABLE);\n }\n}","type":"blockquote","key":"5d0vf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Заключение","type":"header-three","key":"lpv3"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В статье мы рассмотрели процесс реализации API-шлюза в Rust посредством библиотеки Hyper. В рамках данного проекта использовали YAML-файл для настройки путей приложения к нисходящим сервисам и API авторизации. Кроме того, написали модульные тесты для проверки корректной работы API-шлюза.","type":"unstyled","key":"5ldlu"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Язык программирования Rust отлично подходит для создания высокопроизводительных сетевых приложений, а библиотека Hyper предоставляет простой и эффективный способ обработки HTTP-запросов и ответов. Благодаря применению API-шлюза в Rust приложения становятся быстрыми, надежными и способными справляться с большими нагрузками трафика.","type":"unstyled","key":"92o3p"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Принципы и методы реализации этого простого API-шлюза применимы и для создания более сложных архитектур шлюзов, которые применяются в микросервисах и нативных облачных приложениях.","type":"unstyled","key":"243rd"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Читайте также:","type":"unstyled","key":"fc34o"},{"data":{},"depth":0,"entityRanges":[{"key":1,"length":69,"offset":0}],"inlineStyleRanges":[],"text":"Фича-флаги времени компиляции в Rust: зачем, как и когда используются","type":"unordered-list-item","key":"3506f"},{"data":{},"depth":0,"entityRanges":[{"key":2,"length":45,"offset":0}],"inlineStyleRanges":[],"text":"Спецификация API — основа успешной разработки","type":"unordered-list-item","key":"ff47a"},{"data":{},"depth":0,"entityRanges":[{"key":3,"length":33,"offset":0}],"inlineStyleRanges":[],"text":"Rust: взгляд старого программиста","type":"unordered-list-item","key":"d596i"},{"data":{},"depth":0,"entityRanges":[{"key":4,"length":8,"offset":14},{"key":5,"length":2,"offset":24}],"inlineStyleRanges":[],"text":"Читайте нас в Telegram, VK","type":"unstyled","key":"a9hq3"},{"data":{},"depth":0,"entityRanges":[{"key":6,"length":9,"offset":15},{"key":7,"length":42,"offset":26}],"inlineStyleRanges":[{"length":14,"offset":0,"style":"ITALIC"}],"text":"Перевод статьи Adão Raul: Building an API Gateway in Rust With Hyper","type":"unstyled","key":"bngvj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"marker","key":"Nc2TkmilAhjIjV8IaC1m"}],"entityMap":{"0":{"data":{"url":"https://nuancesprog.ru/p/17851/"},"mutability":"MUTABLE","type":"LINK"},"1":{"data":{"href":"https://nuancesprog.ru/p/17375/","url":"https://nuancesprog.ru/p/17375/"},"mutability":"MUTABLE","type":"LINK"},"2":{"data":{"href":"https://nuancesprog.ru/p/17469/","url":"https://nuancesprog.ru/p/17469/"},"mutability":"MUTABLE","type":"LINK"},"3":{"data":{"href":"https://nuancesprog.ru/p/13683/","url":"https://nuancesprog.ru/p/13683/"},"mutability":"MUTABLE","type":"LINK"},"4":{"data":{"href":"https://t.me/nuancesprog","url":"https://t.me/nuancesprog"},"mutability":"MUTABLE","type":"LINK"},"5":{"data":{"href":"https://vk.com/nuancesprog","url":"https://vk.com/nuancesprog"},"mutability":"MUTABLE","type":"LINK"},"6":{"data":{"href":"https://medium.com/@adaoraul?source=post_page-----c84aaf549443--------------------------------","url":"https://medium.com/@adaoraul?source=post_page-----c84aaf549443--------------------------------"},"mutability":"MUTABLE","type":"LINK"},"7":{"data":{"href":"https://betterprogramming.pub/building-an-api-gateway-in-rust-with-hyper-c84aaf549443","url":"https://betterprogramming.pub/building-an-api-gateway-in-rust-with-hyper-c84aaf549443"},"mutability":"MUTABLE","type":"LINK"}}},"mentions":[]}