Rust高性能GraphQL路由库apollo-router使用指南

介绍

Apollo Router是一个用Rust编写的高性能GraphQL路由库，专为构建灵活、可扩展的GraphQL网关而设计。它为Rust开发者提供了强大的查询分发和缓存功能，能够高效地处理GraphQL请求。

主要特性：

• 高性能：基于Rust构建，提供极低延迟的GraphQL请求处理
• 可扩展架构：支持自定义插件和中间件
• 智能查询分发：可路由到不同的后端服务
• 内置缓存：减少重复计算和网络请求
• 联邦支持：兼容Apollo Federation规范

安装方法

在Cargo.toml中添加依赖：

[dependencies]
apollo-router = "1.0"
tokio = { version = "1.0", features = ["full"] }

基本使用方法

1. 创建基本路由

use apollo_router::{Router, Schema};
use async_graphql::{EmptyMutation, EmptySubscription, Object, Schema as GraphQLSchema};

struct Query;

#[Object]
impl Query {
    async fn hello(&self) -> String {
        "Hello, Apollo Router!".to_string()
    }
}

#[tokio::main]
async fn main() {
    // 创建GraphQL schema
    let schema = Schema::build(Query, EmptyMutation, EmptySubscription).finish();
    
    // 创建并启动路由器
    let router = Router::builder()
        .schema(schema)
        .build()
        .unwrap();
    
    router.run().await.unwrap();
}

2. 配置路由端点

use apollo_router::{Router, Schema, Endpoint};

// ...之前的Query定义...

#[tokio::main]
async fn main() {
    let schema = Schema::build(Query, EmptyMutation, EmptySubscription).finish();
    
    let router = Router::builder()
        .schema(schema)
        .endpoint(Endpoint::from("/graphql"))
        .endpoint(Endpoint::from("/api").disable_graphql_playground())
        .build()
        .unwrap();
    
    router.run().await.unwrap();
}

3. 添加缓存层

use apollo_router::{Router, Schema, cache::InMemoryCache};

// ...之前的Query定义...

#[tokio::main]
async fn main() {
    let schema = Schema::build(Query, EmptyMutation, EmptySubscription).finish();
    
    let cache = InMemoryCache::new();
    
    let router = Router::builder()
        .schema(schema)
        .cache(cache)
        .build
        .unwrap();
    
    router.run().await.unwrap();
}

高级功能

1. 自定义插件

use apollo_router::{Router, Schema, Plugin, Request, Response};
use std::task::{Context, Poll};
use tower::Service;

struct LoggingPlugin;

impl Plugin for LoggingPlugin {
    fn name(&self) -> &'static str {
        "logging-plugin"
    }
}

impl<S> Service<Request> for LoggingPlugin
where
    S: Service<Request, Response = Response>,
{
    type Response = S::Response;
    type Error = S::Error;
    type Future = S::Future;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    fn call(&mut self, req: Request, next: S) -> Self::Future {
        println!("Received request: {:?}", req);
        next.call(req)
    }
}

#[tokio::main]
async fn main() {
    let schema = Schema::build(Query, EmptyMutation, EmptySubscription).finish();
    
    let router = Router::builder()
        .schema(schema)
        .plugin(LoggingPlugin)
        .build()
        .unwrap();
    
    router.run().await.unwrap();
}

2. 联邦服务支持

use apollo_router::{Router, federated::FederatedRouter};

#[tokio::main]
async fn main() {
    let router = FederatedRouter::builder()
        .subgraph("accounts", "http://localhost:4001/graphql")
        .subgraph("reviews", "http://localhost:4002/graphql")
        .subgraph("products", "http://localhost:4003/graphql")
        .build()
        .unwrap();
    
    router.run().await.unwrap();
}

性能调优

use apollo_router::{Router, Schema, cache::InMemoryCache};

#[tokio::main]
async fn main() {
    let schema = Schema::build(Query, EmptyMutation, EmptySubscription).finish();
    
    let cache = InMemoryCache::with_capacity(1024); // 设置缓存容量
    
    let router = Router::builder()
        .schema(schema)
        .cache(cache)
        .query_plan_cache_size(512) // 查询计划缓存大小
        .worker_threads(4) // 工作线程数
        .build()
        .unwrap();
    
    router.run().await.unwrap();
}

完整示例

下面是一个结合了基本路由、缓存和自定义插件的完整示例：

use apollo_router::{Router, Schema, Plugin, Request, Response, cache::InMemoryCache};
use async_graphql::{EmptyMutation, EmptySubscription, Object};
use std::task::{Context, Poll};
use tower::Service;

// 定义查询结构体
struct Query;

#[Object]
impl Query {
    async fn version(&self) -> String {
        "1.0.0".to_string()
    }

    async fn server_info(&self) -> String {
        "Apollo Router Server".to_string()
    }
}

// 自定义日志插件
struct RequestLogger;

impl Plugin for RequestLogger {
    fn name(&self) -> &'static str {
        "request-logger"
    }
}

impl<S> Service<Request> for RequestLogger
where
    S: Service<Request, Response = Response>,
{
    type Response = S::Response;
    type Error = S::Error;
    type Future = S::Future;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    fn call(&mut self, req: Request, next: S) -> Self::Future {
        println!("[RequestLogger] Incoming request to path: {}", req.uri().path());
        next.call(req)
    }
}

#[tokio::main]
async fn main() {
    // 创建GraphQL schema
    let schema = Schema::build(Query, EmptyMutation, EmptySubscription).finish();
    
    // 创建内存缓存
    let cache = InMemoryCache::with_capacity(512);
    
    // 构建路由器
    let router = Router::builder()
        .schema(schema)
        .cache(cache)
        .plugin(RequestLogger)
        .endpoint("/graphql")
        .worker_threads(2)
        .build()
        .unwrap();
    
    println!("Server running at http://localhost:4000/graphql");
    router.run().await.unwrap();
}

总结

Apollo Router为Rust开发者提供了一个高性能、可扩展的GraphQL路由解决方案。通过简单的API，开发者可以快速构建GraphQL网关，并利用其强大的缓存、插件和联邦功能来优化GraphQL服务的性能和可维护性。