API Reference: Drain HTTP server plugin

Using the plugin

ⓘ NOTE

In the examples below, we use top-level await calls to start our server asynchronously. If you'd like to see how we set this up, check out the Getting Started guide for details.

This article documents the options for the ApolloServerPluginDrainHttpServer plugin, which you can import from @apollo/server/plugin/drainHttpServer.

This plugin is designed for use with expressMiddleware and other framework integrations built on top of Node http.Servers. We highly recommend using this plugin to ensure your server shuts down gracefully.

You do not need to use this plugin with the startStandaloneServer function; it automatically handles server draining.

When you use this plugin, Apollo Server will drain your HTTP server when you call the stop() method (which is also called for you when the SIGTERM and SIGINT signals are received, unless disabled with the stopOnTerminationSignals constructor option).

Specifically, it will:

Stop listening for new connections
Close idle connections (i.e., connections with no current HTTP request)
Close active connections whenever they become idle
Wait for all connections to be closed
After a grace period, if any connections remain active, forcefully close them.

This plugin is exported from the @apollo/server package. Here's a basic example of how to use it with Express:

index.ts

1
import { ApolloServer } from '@apollo/server';
2
import { expressMiddleware } from '@apollo/server/express4';
3
import { ApolloServerPluginDrainHttpServer } from '@apollo/server/plugin/drainHttpServer';
4
import express from 'express';
5
import http from 'http';
6
import cors from 'cors';
7
import { typeDefs, resolvers } from './schema';
8

9
interface MyContext {
10
  token?: String;
11
}
12

13
const app = express();
14
// Our httpServer handles incoming requests to our Express app.
15
// Below, we tell Apollo Server to "drain" this httpServer,
16
// enabling our servers to shut down gracefully.
17
const httpServer = http.createServer(app);
18

19
const server = new ApolloServer<MyContext>({
20
  typeDefs,
21
  resolvers,
22
  plugins: [ApolloServerPluginDrainHttpServer({ httpServer })],
23
});
24
await server.start();
25

26
app.use(
27
  '/graphql',
28
  cors<cors.CorsRequest>(),
29
  express.json(),
30
  expressMiddleware(server, {
31
    context: async ({ req }) => ({ token: req.headers.token }),
32
  }),
33
);
34

35
await new Promise<void>((resolve) => httpServer.listen({ port: 4000 }, resolve));
36

37
console.log(`🚀 Server ready at http://localhost:4000/graphql`);

index.js

1
import { ApolloServer } from '@apollo/server';
2
import { expressMiddleware } from '@apollo/server/express4';
3
import { ApolloServerPluginDrainHttpServer } from '@apollo/server/plugin/drainHttpServer';
4
import express from 'express';
5
import http from 'http';
6
import cors from 'cors';
7
import { typeDefs, resolvers } from './schema';
8

9
const app = express();
10
// Our httpServer handles incoming requests to our Express app.
11
// Below, we tell Apollo Server to "drain" this httpServer,
12
// enabling our servers to shut down gracefully.
13
const httpServer = http.createServer(app);
14

15
const server = new ApolloServer({
16
  typeDefs,
17
  resolvers,
18
  plugins: [ApolloServerPluginDrainHttpServer({ httpServer })],
19
});
20
await server.start();
21

22
app.use(
23
  '/graphql',
24
  cors(),
25
  express.json(),
26
  expressMiddleware(server, {
27
    context: async ({ req }) => ({ token: req.headers.token }),
28
  }),
29
);
30

31
await new Promise((resolve) => httpServer.listen({ port: 4000 }, resolve));
32

33
console.log(`🚀 Server ready at http://localhost:4000/graphql`);

Options

Name / Type	Description
`httpServer` `http.Server`	The server to drain; required.
`stopGracePeriodMillis` `number`	How long to wait before forcefully closing non-idle connections. Defaults to `10_000` (ten seconds).

Inline trace

Cache control

API Reference: Drain HTTP server plugin

Using the plugin

Options

`httpServer`

`stopGracePeriodMillis`