在Rust中使用Hyper构建API网关

coding到灯火阑珊发表于 1年以前 | 总阅读数：804 次

API网关是现代微服务体系结构中的关键组件，因为它是客户端和后端服务之间的中介。它有助于根据请求路径将传入请求路由到适当的下游服务，还提供了用于管理安全性和身份验证的集中式机制。

在这篇文章中，我们将使用Hyper库在Rust中实现一个API网关，我们将使用Kubernetes服务作为我们的下游服务。我们还将实现一个外部授权API来处理用户身份验证。

建立开发环境

在开始编写代码之前，我们需要设置开发环境。我们将使用Rust作为我们的编程语言，使用Hyper库来处理HTTP请求，我们还将使用serde和yaml-rust库来处理YAML文件。下面是设置环境的步骤：

1，创建一个新的Rust项目：

cargo new api-gateway

2，向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();
    }
}