基于GraphQL与PostgreSQL实现多客户端系统集成方案问询

一、优先方案：统一GraphQL网关层 #

用Node.js搭建一个统一的GraphQL网关作为入口，把跨客户的聚合、路由逻辑集中在这里，让各个客户的Hasura只负责单租户业务，彻底避免重复编写合并查询：

核心逻辑 #

• Query操作：网关接收请求后，根据需求并行调用多个客户的Hasura实例，获取结果后统一合并返回；如果是单客户查询，直接路由到对应实例。
• Mutation操作：通过请求中的客户标识（如Header参数、业务参数），直接将请求转发到目标客户的Hasura实例，确保操作定向执行。
• Subscription操作：将订阅请求直接转发到目标客户的Hasura，如需跨客户订阅，可在网关层聚合多个实例的订阅事件（此类场景较少）。

极简实现示例（Node.js + graphql-yoga） #

const { GraphQLServer } = require('graphql-yoga');
const { createHttpLink } = require('apollo-link-http');
const { execute, makePromise } = require('apollo-link');
const fetch = require('node-fetch');

// 维护客户Hasura实例映射表，可从配置中心动态拉取
const clientEndpoints = {
  clientA: 'https://client-a-hasura.example.com/v1/graphql',
  clientB: 'https://client-b-hasura.example.com/v1/graphql',
};

// 网关统一Schema
const typeDefs = `
  type User {
    id: ID!
    name: String!
  }

  type Query {
    # 合并所有客户的用户数据
    getAllUsers: [User!]!
    # 查询指定客户的用户数据
    getClientUsers(clientId: String!): [User!]!
  }

  type Mutation {
    # 定向给指定客户创建用户
    createUser(clientId: String!, name: String!): User!
  }
`;

const resolvers = {
  Query: {
    getAllUsers: async () => {
      // 并行请求所有客户的Hasura实例
      const fetchPromises = Object.values(clientEndpoints).map(endpoint => {
        const link = createHttpLink({ uri: endpoint, fetch });
        return makePromise(execute(link, { query: '{ users { id name } }' }))
          .then(res => res.data.users);
      });
      const results = await Promise.all(fetchPromises);
      return results.flat();
    },
    getClientUsers: async (_, { clientId }) => {
      const endpoint = clientEndpoints[clientId];
      if (!endpoint) throw new Error('无效的客户ID');
      const link = createHttpLink({ uri: endpoint, fetch });
      const res = await makePromise(execute(link, { query: '{ users { id name } }' }));
      return res.data.users;
    }
  },
  Mutation: {
    createUser: async (_, { clientId, name }) => {
      const endpoint = clientEndpoints[clientId];
      if (!endpoint) throw new Error('无效的客户ID');
      const link = createHttpLink({ uri: endpoint, fetch });
      const res = await makePromise(execute(link, {
        query: 'mutation CreateUser($name: String!) { insert_users_one(object: {name: $name}) { id name } }',
        variables: { name }
      }));
      return res.data.insert_users_one;
    }
  }
};

const server = new GraphQLServer({ typeDefs, resolvers });
server.start(() => console.log('网关运行在 http://localhost:4000'));

二、数据库层面跨库合并（PostgreSQL方案） #

如果倾向于从数据库层处理查询合并，可利用PostgreSQL的postgres_fdw（外部数据包装器）实现跨库访问：

操作步骤 #

1. 在一个"中心"数据库中安装postgres_fdw扩展，为每个客户数据库创建外部服务器映射。
2. 为每个客户的业务表创建外部表，再通过视图合并所有外部表的数据。
3. 将中心库的合并视图暴露给Hasura，直接通过Hasura查询合并结果。

示例SQL #

-- 安装外部数据包装器扩展
CREATE EXTENSION IF NOT EXISTS postgres_fdw;

-- 映射客户A的数据库
CREATE SERVER client_a_db FOREIGN DATA WRAPPER postgres_fdw OPTIONS (
  host 'client-a-db-host',
  dbname 'client_a_db',
  port '5432'
);

-- 创建用户映射（中心库访问客户库的权限）
CREATE USER MAPPING FOR current_user SERVER client_a_db OPTIONS (
  user 'db_user',
  password 'db_pass'
);

-- 创建外部表映射客户A的users表
CREATE FOREIGN TABLE client_a_users (
  id UUID PRIMARY KEY,
  name TEXT NOT NULL
) SERVER client_a_db OPTIONS (schema_name 'public', table_name 'users');

-- 同理创建客户B的外部表...

-- 创建合并所有客户数据的视图
CREATE VIEW all_users AS
SELECT 'client_a' AS client_id, id, name FROM client_a_users
UNION ALL
SELECT 'client_b' AS client_id, id, name FROM client_b_users;

局限性 #

• 新增客户需手动更新中心库的外部表和视图，扩展性差；
• 跨库查询性能受网络延迟影响，事务处理复杂；
• Subscription支持薄弱，难以监听所有客户库的数据变化；
• 外部表默认只读，突变操作需单独定向到客户库，无法通过中心库统一处理。

三、Hasura层面优化（远程Schema聚合） #

若不想新增网关，可利用Hasura的远程Schema功能聚合多个客户的Hasura实例：

• 将每个客户的Hasura实例作为远程Schema添加到中心Hasura；
• 在中心Hasura中编写自定义查询，聚合各远程Schema的结果；
• 突变操作通过客户ID判断，调用对应远程Schema的突变接口。

缺点 #

仍需编写重复的聚合逻辑，新增客户时需手动添加远程Schema，维护成本较高，仅适合客户数量较少的场景。

方案选型建议 #

优先选择统一GraphQL网关层方案，原因如下：

• 彻底隔离跨客户逻辑与单租户业务，Hasura无需重复编写合并查询；
• 突变操作天然支持定向执行，Subscription可通过转发实现实时更新；
• 扩展性强，新增客户仅需更新网关配置，无需修改数据库或Hasura；
• 维护成本低，所有跨租户逻辑集中在网关，便于统一迭代。

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