如何获取并复用GraphQL Schema？AWS Lambda代理实现方案

核心思路 #

通过GraphQL的自省（Introspection）机制从目标Apollo Lambda获取完整Schema，基于该Schema构建代理Apollo Server，对特定查询字段添加自定义Resolver，未自定义的字段默认转发请求到原Lambda，无需手动维护Schema副本。

具体实现步骤 #

1. 确保目标Lambda开启自省功能 #

Apollo Server默认在生产环境关闭自省，需要显式开启，让代理Lambda能获取Schema：

// 目标Lambda的Apollo Server配置
const { ApolloServer } = require('apollo-server-lambda');
const typeDefs = require('./schema');
const resolvers = require('./resolvers');

const server = new ApolloServer({
  typeDefs,
  resolvers,
  // 强制开启自省，生产环境也生效
  introspection: true,
  playground: true // 可选，用于调试原GraphQL服务
});

exports.handler = server.createHandler();

2. 代理Lambda动态获取目标Schema #

通过发送标准自省查询到目标Lambda的API Gateway端点，将返回结果转换为可操作的Schema对象：

const { buildClientSchema, introspectionQuery } = require('graphql');
const fetch = require('node-fetch');

const TARGET_GRAPHQL_ENDPOINT = 'https://xxx.execute-api.xxx.amazonaws.com/prod/graphql';

async function getTargetSchema() {
  const res = await fetch(TARGET_GRAPHQL_ENDPOINT, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ query: introspectionQuery })
  });
  const { data } = await res.json();
  return buildClientSchema(data);
}

3. 添加自定义Resolver并构建代理服务器 #

针对需要自定义的查询字段编写Resolver逻辑，未自定义的字段默认转发到原Lambda：

const { ApolloServer } = require('apollo-server-lambda');

// 自定义Resolver示例：覆盖`getUser`查询
const customResolvers = {
  Query: {
    getUser: async (parent, args, context) => {
      // 这里添加自定义逻辑：比如参数校验、数据加工、缓存等
      console.log('处理自定义getUser请求，参数:', args);

      // 可选：转发请求到原Lambda获取原始数据
      const forwardRes = await fetch(context.targetEndpoint, {
        method: 'POST',
        headers: context.headers,
        body: JSON.stringify({
          query: `query GetUser($id: ID!) { getUser(id: $id) { id name email } }`,
          variables: args
        })
      });
      const { data } = await forwardRes.json();

      // 加工返回数据
      data.getUser.name = `[代理加工]${data.getUser.name}`;
      return data.getUser;
    }
  }
};

// 初始化代理服务器（冷启动时执行一次）
let proxyServer;
async function createProxyServer() {
  const targetSchema = await getTargetSchema();
  
  // 合并自定义Resolver与默认字段映射
  const resolvers = {
    ...customResolvers,
    Query: {
      // 保留原Schema所有查询字段
      ...targetSchema.getQueryType().getFields(),
      // 覆盖需要自定义的字段
      ...customResolvers.Query
    }
  };

  return new ApolloServer({
    schema: targetSchema,
    resolvers,
    context: ({ event, context }) => ({
      headers: event.headers,
      targetEndpoint: TARGET_GRAPHQL_ENDPOINT,
      lambdaContext: context
    })
  });
}

// Lambda处理函数
exports.handler = async (event, context) => {
  if (!proxyServer) {
    proxyServer = await createProxyServer();
  }
  const handler = proxyServer.createHandler();
  return new Promise((resolve, reject) => {
    handler(event, context, (err, result) => {
      err ? reject(err) : resolve(result);
    });
  });
};

关键注意事项 #

• Schema缓存：Lambda冷启动时会触发自省查询，建议将Schema缓存到AWS ElastiCache或Lambda层，避免重复请求，提升性能。
• 权限控制：给代理Lambda配置IAM角色，允许其调用目标Lambda的API Gateway端点（通过execute-api:Invoke权限）。
• Schema变更处理：如果目标Schema更新，可通过定时触发Lambda刷新缓存，或在代理请求时检测Schema版本差异。
• 错误处理：添加重试逻辑处理目标服务不可用的情况，避免单次请求失败导致代理服务异常。
• 请求转发完整性：转发请求时要携带原始headers、variables等信息，确保原服务能正确处理请求。

内容的提问来源于stack exchange，提问作者Nikita Polevoy