使用 Nestjs 提供公共和私有端口服务

我正在构建一个旨在为移动应用程序提供服务的应用程序。除了为客户提供服务外，它还将具有多种后台功能。

我们正在使用swagger我们确实希望能够访问后台端点的 swagger 文档。但是，我们不想公开暴露我们的所有端点。

假设将所有端点公开是一个糟糕的选择，我们正在考虑的一种解决方案是让我们的服务器服务两个端口，然后只向公众公开一个端口。我们创建了一个小样本库它在两个不同的端口上为客户端模块和后台模块提供服务。

The main.ts看起来像下面这样：

import { NestFactory } from '@nestjs/core';
import { ClientModule } from './modules/client/client.module';
import * as express from 'express';
import * as http from 'http';
import {ExpressAdapter} from '@nestjs/platform-express';
import { BackOfficeModule } from './modules/backoffice/backoffice.module';
import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';

async function bootstrap() {

  const clientServer = express();
  const clientApp = await NestFactory.create(
    ClientModule,
    new ExpressAdapter(clientServer),
  );
  const clientOptions = new DocumentBuilder()
    .setTitle('ClientServer')
    .setDescription('The client server API description')
    .setVersion('1.0')
    .addTag('client')
    .build();
  const clientDocument = SwaggerModule.createDocument(clientApp, clientOptions);
  SwaggerModule.setup('api', clientApp, clientDocument);
  await clientApp.init();

  const backOfficeServer = express();
  const backOfficeApp = await NestFactory.create(
    BackOfficeModule,
    new ExpressAdapter(backOfficeServer),
  );

  const backOfficeOptions = new DocumentBuilder()
    .setTitle('BackOffice')
    .setDescription('The back office API description')
    .setVersion('1.0')
    .addTag('backOffice')
    .build();
  const backOfficeDocument = SwaggerModule.createDocument(backOfficeApp, backOfficeOptions);
  SwaggerModule.setup('api', backOfficeApp, backOfficeDocument);
  await backOfficeApp.init();

  http.createServer(clientServer).listen(3000); // The public port (Load balancer will route traffic to this port)
  http.createServer(backOfficeServer).listen(4000); // The private port (Will be accessed through a bastian host or similar)
}
bootstrap();

另一种选择是对代码库和基础设施进行更大的分离，但由于这是一个非常早期的阶段，我们认为这是不必要的。

我们的问题是Nest社区就是这样，有人这样做过吗？如果是这样，您的经验是什么？像这样分离后端代码有什么缺点？

免责声明：该解决方案适用于express+REST组合。

Routing

即使nestjs不能根据端口分离控制器，它也可以根据主机分离它们。使用它，您可以在应用程序前面添加一个反向代理，该代理根据端口修改主机标头。或者，您可以在快速中间件中执行此操作，以使事情变得更加简单。这就是我所做的：

async function bootstrap() {
  const publicPort = 3000
  const privatePort = 4000

  const server = express()
  server.use((req, res, next) => {
    // act as a proper reverse proxy and set X-Forwarded-Host header if it hasn't been set
    req.headers['x-forwarded-host'] ??= req.headers.host
    switch (req.socket.localPort) {
      case publicPort:
        req.headers.host = 'public'
        break
      case privatePort:
        req.headers.host = 'private'
        break
      default:
        // this shouldn't be possible
        res.sendStatus(500)
        return
    }

    next()
  })

  const app = await NestFactory.create(AppModule, new ExpressAdapter(server))

  http.createServer(server).listen(publicPort)
  http.createServer(server).listen(privatePort)
}

控制器：

@Controller({ path: 'cats', host: 'public' })
export class CatsController {...}


@Controller({ path: 'internal' host: 'private' })
export class InternalController {...}

或者，您可以通过创建自己的 PublicController 和 PrivateController 装饰器来简化：

// decorator for public controllers, also sets guard
export const PublicController = (path?: string): ClassDecorator => {
  return applyDecorators(Controller({ path, host: 'public' }), UseGuards(JwtAuthGuard))
}

// decorator for private controllers
export const PrivateController = (path?: string): ClassDecorator => {
  return applyDecorators(Controller({ path, host: 'private' }))
}


@PublicController('cats')
export class CatsController {...}


@PrivateController('internal')
export class InternalController {...}

Swagger

对于 swagger，SwaggerModule.createDocument 有一个选项“include”，它接受要包含在 swagger 文档中的模块列表。通过一些努力，我们还可以将 swagger 服务部分变成一个快速路由器，这样私有和公共 swagger 都可以在同一路径上为不同的端口提供服务：

async function bootstrap() {
  const publicPort = 3000
  const privatePort = 4000

  const server = express()
  server.use((req, res, next) => {
    // act as a proper reverse proxy and set X-Forwarded-Host header if it hasn't been set
    req.headers['x-forwarded-host'] ??= req.headers.host
    switch (req.socket.localPort) {
      case publicPort:
        req.headers.host = 'public'
        break
      case privatePort:
        req.headers.host = 'private'
        break
      default:
        // this shouldn't be possible
        res.sendStatus(500)
        return
    }

    next()
  })

  const app = await NestFactory.create(AppModule, new ExpressAdapter(server))

  // setup swagger
  let publicSwaggerRouter = await createSwaggerRouter(app, [CatsModule])
  let privateSwaggerRouter: await createSwaggerRouter(app, [InternalModule])
  server.use('/api', (req: Request, res: Response, next: NextFunction) => {
    switch (req.headers.host) {
      case 'public':
        publicSwaggerRouter(req, res, next)
        return
      case 'private':
        privateSwaggerRouter(req, res, next)
        return
      default:
        // this shouldn't be possible
        res.sendStatus(500)
        return
    }
  })

  http.createServer(server).listen(publicPort)
  http.createServer(server).listen(privatePort)
}

async function createSwaggerRouter(app: INestApplication, modules: Function[]): Promise<Router> {
  const swaggerConfig = new DocumentBuilder().setTitle('MyApp').setVersion('1.0').build()

  const document = SwaggerModule.createDocument(app, swaggerConfig, { include: modules })

  const swaggerUi = loadPackage('swagger-ui-express', 'SwaggerModule', () => require('swagger-ui-express'))

  const swaggerHtml = swaggerUi.generateHTML(document)
  const router = Router()
    .use(swaggerUi.serveFiles(document))
    .get('/', (req: Request, res: Response, next: NextFunction) => {
      res.send(swaggerHtml)
    })

  return router
}