Skip to main content

CubeJS 配置

  • 环境变量配置
    • CUBEJS_DEV_MODE=true - 开发模式
    • CUBEJS_APP - APP ID
    • CUBEJS_TELEMETRY=false
    • Environment Variables
    • 映射方式 CUBEJS_DB_TYPE -> dbType
  • cube.js 配置
  • dev mode
    • 无 auth
    • 单节点 cubestore
    • background refresh for in-memory cache, cheduled pre-aggregations
    • log level trace
    • playground http://localhost:4000
    • memory as the default cache/queue engine
    • log incorrect/invalid configuration for for externalRefresh /waitForRenew instead of throwing errors
cube.js
module.exports = {
  telemetry: false,
  logger: (msg, params) => {
    console.log(`${msg}: ${JSON.stringify(params)}`);
  },
};

配置说明​

上下文关系

  • 请求 - ExpressRequest
  • appId - RequestContext
  • COMPILE_CONTEXT - RequestContext
  • jwt - securityContext
  • SECURITY_CONTEXT - securityContext
    • 尽量使用 queryRewrite 而不是 SECURITY_CONTEXT
    • 用于 row level security
interface CubejsConfiguration {
  // Schema 文件路径 /schema
  schemaPath: string;
  // REST 接口路径 /cubejs-api
  basePath: string;
  // 默认 /
  webSocketsBasePath: string;
  // 自定义 logger
  // 例如 console.log(`${msg}: ${JSON.stringify(params)}`);
  logger: (msg: string, params: object) => any;

  // 数据库类型 - 每个 appId 请求一次
  dbType: string | ((context: RequestContext) => string);
  // 数据源配置 - 一个数据源请求一次
  driverFactory: (context: DriverContext) => BaseDriver | Promise<BaseDriver>;
  // 外部数据库类型 - 每个 appId 请求一次
  externalDbType: string | ((context: RequestContext) => string);
  // 外部 rollup - 每个 appId 请求一次
  externalDriverFactory: (context: RequestContext) => BaseDriver | Promise<BaseDriver>;

  // AppID - 每次请求
  // 缓存 Key - schema compilation results, connection pool 等
  // 例如 ({ securityContext }) => `CUBEJS_APP_${securityContext.tenantId}_${securityContext.user_id}`
  contextToAppId: (context: RequestContext) => string;
  // 查询编排缓存 Key - 默认为 appId - 每次请求
  // 数据库连接, 执行队列, 预聚合表缓存
  // 例如 ({ securityContext }) => `CUBEJS_APP_${securityContext.tenantId}`
  contextToOrchestratorId: (context: RequestContext) => string;
  // Schema 仓库 - 每 AppID 请求
  // 实现多租户不同 schema
  // 例如 ({ securityContext }) => new FileRepository(`schema/${securityContext.appId}`)
  repositoryFactory: (context: RequestContext) => SchemaFileRepository;
  // REST 和 WebSockets API 鉴权
  // 默认 检查 Authorization JWT，验证后内容设置为 req.securityContext
  // 可禁用 (req, auth) => {}
  checkAuth: (req: ExpressRequest, authorization: string) => any;
  // SQL API 鉴权 - 默认校验 CUBE_SQL_USERNAME, CUBE_SQL_PASSWORD
  checkSqlAuth: (req: SQLRequest, user: string) => any;
  // 查询执行前的额外检查
  queryRewrite: (query: object, context: RequestContext) => object;
  // 预聚合 schema - 推荐生产和开发使用不同 schema - 每个 appId 请求一次
  // 开发模式默认 dev_pre_aggregations
  // 生产模式默认 prod_pre_aggregations
  preAggregationsSchema: string | ((context: RequestContext) => string);
  // schema 版本 - 确定什么时候重新编译
  schemaVersion: (context: RequestContext) => string;

  scheduledRefreshTimer: boolean | number;
  scheduledRefreshTimeZones: string[];
  scheduledRefreshContexts: () => Promise<object[]>;

  // 扩展 RequestContext
  extendContext: (req: ExpressRequest) => any;
  // 默认 250
  compilerCacheSize: number;
  // 单位 ms
  maxCompilerCacheKeepAlive: number;
  updateCompilerCacheKeepAlive: boolean;
  allowUngroupedWithoutPrimaryKey: boolean;
  telemetry: boolean;

  http: {
    cors: {
      methods: string | string[];
      origin: string;
      allowedHeaders: string | string[];
      exposedHeaders: string | string[];
      credentials: boolean;
      maxAge: number;
      preflightContinue: boolean;
      optionsSuccessStatus: number;
    };
  };

  jwt: {
    jwkUrl?: ((payload: any) => string) | string;
    key?: string;
    algorithms?: string[];
    issuer?: string[];
    audience?: string;
    subject?: string;
    claimsNamespace?: string;
  };
  // 推荐生产使用 redis
  cacheAndQueueDriver: 'memory' | 'redis';
  // 推荐保留默认
  orchestratorOptions: OrchestratorOptions | ((context: RequestContext) => OrchestratorOptions);
  allowJsDuplicatePropsInSchema: boolean;
}

interface OrchestratorOptions {
  redisPrefix: string;
  rollupOnlyMode: bool;
  queryCacheOptions: {
    refreshKeyRenewalThreshold: number;
    backgroundRenew: boolean;
    queueOptions: QueueOptions;
  };
  preAggregationsOptions: {
    queueOptions: QueueOptions;
  };
}

interface QueueOptions {
  concurrency: number;
  continueWaitTimeout: number;
  executionTimeout: number;
  orphanedTimeout: number;
  heartBeatInterval: number;
}

interface RequestContext {
  securityContext: object;
  requestId: string;
}

interface DriverContext extends RequestContext {
  dataSource: string;
}

interface SchemaFileRepository {
  dataSchemaFiles(): Promise<FileContent[]>;
}

interface FileContent {
  fileName: string;
  content: string;
}
QueueOptions
{
  "concurrency": 2,
  "continueWaitTimeout": 5,
  "executionTimeout": 600,
  "orphanedTimeout": 120,
  "heartBeatInterval": 30
}

Multitenancy​

  • Multitenancy vs Multiple Data Sources
    • Multitenancy
      • 多用户，不同数据集
    • Multiple Data Sources
      • 相同数据不同数据库
      • cube 关联 dataSource
      • 配置 dbType+driverFactory 生成多数据源
  • Security Context vs Multitenant Compile Context
    • Security Context
      • row-level security within the same database for different users
    • Multitenant Compile Context
      • access different databases
  • Security Context vs queryRewrite
    • Security Context
      • explicit control
cube.js
const PostgresDriver = require('@cubejs-backend/postgres-driver');

module.exports = {
  driverFactory: ({ dataSource }) => new PostgresDriver({ database: dataSource }),
};

数据库​

const MySQLDriver = require('@cubejs-backend/mysql-driver');

new MySQLDriver({
  host: process.env.CUBEJS_EXT_DB_HOST,
  database: process.env.CUBEJS_EXT_DB_NAME,
  port: process.env.CUBEJS_EXT_DB_PORT,
  user: process.env.CUBEJS_EXT_DB_USER,
  password: process.env.CUBEJS_EXT_DB_PASS,
});