在 Rust 中使用 Hyper 構建 API 網關
API 網關是現代微服務體系結構中的關鍵組件，因爲它是客戶端和後端服務之間的中介。它有助於根據請求路徑將傳入請求路由到適當的下游服務，還提供了用於管理安全性和身份驗證的集中式機制。
在這篇文章中，我們將使用 Hyper 庫在 Rust 中實現一個 API 網關，我們將使用 Kubernetes 服務作爲我們的下游服務。我們還將實現一個外部授權 API 來處理用戶身份驗證。
建立開發環境
在開始編寫代碼之前，我們需要設置開發環境。我們將使用 Rust 作爲我們的編程語言，使用 Hyper 庫來處理 HTTP 請求，我們還將使用 serde 和 yaml-rust 庫來處理 YAML 文件。下面是設置環境的步驟：
1，創建一個新的 Rust 項目：
cargo new api-gateway2，向 Cargo.toml 文件中添加所需的依賴項，如下所示：
[dependencies]
hyper = "0.14"
serde = { version = "1.0", features = ["derive"] }
yaml-rust = "0.4"3，運行 cargo build 以下載和構建依賴項。
實現 API 網關
既然我們已經建立了開發環境，我們就可以開始實現 API 網關了。爲了更好地理解，我們將把實現分解爲更小的步驟。
解析配置文件
我們將使用 YAML 文件來配置 API 網關，YAML 文件將包含路徑到服務的映射和授權 API 的 URL。下面是一個 YAML 文件示例：
---
auth_api_url: "https://auth.example.com/api/v1/authenticate"
services:
"/users":
target_service: "http://user-service.default.svc.cluster.local"
target_port: "8080"
"/orders":
target_service: "http://order-service.default.svc.cluster.local"
target_port: "8080"我們將使用 serde 和 yaml-rust 庫來解析 YAML 文件。下面是解析配置文件的代碼：
use std::fs::File;
use std::io::prelude::*;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use yaml_rust::YamlLoader;
#[derive(Debug, Deserialize, Serialize)]
struct GatewayConfig {
auth_api_url: String,
services: HashMap<String, ServiceConfig>,
}
#[derive(Debug, Deserialize, Serialize)]
struct ServiceConfig {
target_service: String,
target_port: String,
}
fn load_config(file_path: &str) -> GatewayConfig {
let mut file = File::open(file_path).unwrap();
let mut contents = String::new();
file.read_to_string(&mut contents).unwrap();
let docs = YamlLoader::load_from_str(&contents).unwrap();
serde_yaml::from_str(&docs[0].to_string()).unwrap()
}GatewayConfig 結構體表示解析後的 YAML 文件，它包含兩個字段: auth_api_url 和 services。auth_api_url 字段存儲了授權 API 的 URL，services 字段是一個 HashMap，它將請求路徑映射到 ServiceConfig 結構體，ServiceConfig 結構體包含目標服務 URL 和端口。
路由請求
下一步是根據所請求的路徑將傳入請求路由到適當的下游服務。我們將使用 hyper 庫來處理 HTTP 請求和響應。下面是路由請求的代碼：
use hyper::{
Body, Client, Request, Response, Server, StatusCode,
header::{AUTHORIZATION, CONTENT_TYPE},
service::{make_service_fn, service_fn}
};
use std::convert::Infallible;
use std::net::SocketAddr;
async fn handle_request(req: Request<Body>, gateway_config: &GatewayConfig) -> Result<Response<Body>, Infallible> {
// 檢查用戶是否被授權
let auth_result = authorize_user(req.headers(), &gateway_config.auth_api_url).await;
match auth_result {
Ok(_) => {
// 用戶獲得授權，將請求路由到適當的服務
let target_service = match gateway_config.services.get(req.uri().path()) {
Some(service_config) => format!("{}:{}", service_config.target_service, service_config.target_port),
None => return Ok(Response::builder()
.status(StatusCode::NOT_FOUND)
.body(Body::empty())
.unwrap()),
};
let client = Client::new();
let mut downstream_req = Request::new(req.body());
*downstream_req.uri_mut() = req.uri().clone();
*downstream_req.method_mut() = req.method().clone();
// 將請求轉發到下游服務
let res = client.request(downstream_req).await.unwrap();
Ok(res)
},
Err(_) => {
// 用戶未被授權，返回401 Unauthorized
Ok(Response::builder()
.status(StatusCode::UNAUTHORIZED)
.header(CONTENT_TYPE, "text/plain")
.body(Body::from("Unauthorized"))
.unwrap())
}
}
}
async fn authorize_user(headers: &hyper::HeaderMap, auth_api_url: &str) -> Result<(), hyper::Error> {
let auth_header = match headers.get(AUTHORIZATION) {
Some(header) => header.to_str().unwrap().to_owned(),
None => return Err(hyper::Error::from(std::io::Error::new(std::io::ErrorKind::Other, "Authorization header missing")))
};
let client = Client::new();
let mut auth_req = Request::post(auth_api_url)
.header(AUTHORIZATION, auth_header)
.body(Body::empty())
.unwrap();
// 將請求發送到授權API
let res = client.request(auth_req).await?;
match res.status() {
StatusCode::OK => Ok(()),
_ => Err(hyper::Error::from(std::io::Error::new(std::io::ErrorKind::Other, "Unauthorized")))
}
}
#[tokio::main]
async fn main() {
let gateway_config = load_config("config.yml");
let make_svc = make_service_fn(move |_conn| {
let gateway_config = gateway_config.clone();
async {
Ok::<_, Infallible>(service_fn(move |req| {
handle_request(req, &gateway_config)
}))
}
});
let addr = SocketAddr::from(([0, 0, 0, 0], 8080));
let server = Server::bind(&addr).serve(make_svc);
println!("Listening on http://{}", addr);
if let Err(e) = server.await {
eprintln!("server error: {}", e);
}
}handle_request 函數首先調用 authorize_user 函數來檢查用戶是否被授權。如果用戶獲得授權，該函數將在 GatewayConfig 結構體中查找所請求的路徑以獲得目標服務 URL 和端口。如果沒有找到請求的路徑，該函數返回 404 not found 響應。如果用戶未被授權或授權 API 出現錯誤，該函數將返回 401 Unauthorized 響應。
authorize_user 函數用原始請求的 Authorization 頭向 Authorization API 發送 POST 請求。如果響應狀態爲 200 OK，則用戶已被授權，函數返回 OK(())。否則，用戶沒有授權，函數返回一個錯誤。
最後，main 函數從 config.yml 文件中加載 GatewayConfig 結構體。使用 make_service_fn 設置 Hyper 服務器，並在端口 8080 上偵聽傳入請求。
編寫單元測試
爲了確保我們的 API 網關按預期工作，我們應該編寫一些單元測試。我們可以通過創建一個總是返回 200 OK 的模擬 authorization API 端點和另一個總是返回 401 Unauthorized 的模擬端點來測試授權邏輯。然後，我們可以使用適當的授權頭向 API 網關發送請求，並確保響應是正確的。
#[cfg(test)]
mod tests {
use super::*;
use hyper::Body;
#[tokio::test]
async fn test_authorized_request() {
let gateway_config = GatewayConfig {
auth_api_url: "http://auth.mock".to_owned(),
services: hashmap![
"/service1".to_owned() => ServiceConfig { target_service: "http://service1.mock".to_owned(), target_port: 80 },
"/service2".to_owned() => ServiceConfig { target_service: "http://service2.mock".to_owned(), target_port: 8080 },
]
};
// 模擬授權API，總是返回200 OK
let auth_mock = mockito::mock("POST", "/")
.match_header("authorization", "Bearer test")
.with_status(200)
.create();
// 模擬下游服務，總是返回200 OK
let service1_mock = mockito::mock("GET", "/")
.with_status(200)
.with_body("Service 1")
.create();
let client = Client::new();
let mut req = Request::get("/service1")
.header(AUTHORIZATION, "Bearer test")
.body(Body::empty())
.unwrap();
let res = handle_request(req, &gateway_config).await.unwrap();
assert_eq!(res.status(), StatusCode::OK);
let body = hyper::body::to_bytes(res.into_body()).await.unwrap();
assert_eq!(body, "Service 1");
auth_mock.assert();
service1_mock.assert();
}
#[tokio::test]
async fn test_unauthorized_request() {
let gateway_config = GatewayConfig {
auth_api_url: "http://auth.mock".to_owned(),
services: hashmap![
"/service1".to_owned() => ServiceConfig { target_service: "http://service1.mock".to_owned(), target_port: 80 },
"/service2".to_owned() => ServiceConfig { target_service: "http://service2.mock".to_owned(), target_port: 8080 },
]
};
// 模擬授權API，總是返回401未授權
let auth_mock = mockito::mock("POST", "/")
.match_header("authorization", "Bearer test")
.with_status(401)
.create();
let client = Client::new();
let mut req = Request::get("/service1")
.header(AUTHORIZATION, "Bearer test")
.body(Body::empty())
.unwrap();
let res = handle_request(req, &gateway_config).await.unwrap();
assert_eq!(res.status(), StatusCode::UNAUTHORIZED);
auth_mock.assert();
}
}在這篇文章中，我們使用 Hyper 庫在 Rust 中實現了一個 API 網關。我們使用 YAML 文件自定義下游應用程序路徑和授權 API。我們還編寫了單元測試，以確保 API 網關按預期工作。
Rust 是一種構建高性能網絡應用程序的優秀語言，Hyper 庫提供了一種簡單有效的方式來處理 HTTP 請求和響應。通過在 Rust 中構建 API 網關，我們可以確保我們的應用程序快速可靠，並且可以處理高流量負載。
雖然我們在這篇文章中只實現了一個簡單的 API 網關，但這裏使用的原則和技術可以應用到更復雜的網關架構中，比如微服務或雲原生應用程序中使用的網關架構。
本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/7PDqFhc-iDxBw36wSnNA3Q