ivorscott
commented
4 years ago I'm migrating a Node backend to Golang sometime this year. This is the main reason I'm blogging about it actually. I recommend you take Bret's Docker for Node.js course. He goes into a lot of detail and has been Dockerizing Node apps since Node first came out. He keeps its content up to date.
My Node app uses Typescript. Here's what the Dockerfile and docker-compose file looks like:
FROM node:10 as base
ENV NODE_ENV=production
EXPOSE 4000
WORKDIR /api
COPY package*.json ./
RUN npm ci \
&& npm cache clean --force
FROM base as dev
ENV NODE_ENV=development
ENV PATH /api/node_modules/.bin:$PATH
EXPOSE 9229
RUN mkdir /api/app && chown -R node:node .
USER node
RUN npm i --only=development \
&& npm cache clean --force
RUN npm config ls -l
WORKDIR /api/app
CMD ["../node_modules/.bin/ts-node-dev","--inspect=0.0.0.0:9229","--respawn","--transpileOnly","./src/app.ts"]
FROM dev as test
COPY --chown=node:node . .
RUN npm audit
FROM test as build-stage
RUN npm run build
FROM base as prod
ARG backend
ARG frontend
ARG api_namespace
ENV REACT_APP_BACKEND=$backend
ENV REACT_APP_FRONTEND=$frontend
ENV API_NAMESPACE=$api_namespace
COPY --from=build-stage /api/app/dist /api/dist
CMD ["node", "./dist/src/app.js"]version: "3.7"
services:
api:
build:
context: ./api
target: dev
secrets:
- jwt_secret_local
- sendgrid_api_key
environment:
MONGODB_URI: $MONGODB_URI
CLIENT_PORT: 3000
API_NAMESPACE: $API_NAMESPACE
REACT_APP_BACKEND: $REACT_APP_LOCAL_BACKEND
REACT_APP_FRONTEND: $REACT_APP_LOCAL_FRONTEND
JWT_SECRET: /run/secrets/jwt_secret_local
SENDGRID_API_KEY: /run/secrets/sendgrid_api_key
restart: always
ports:
- 4000:4000
- 9229:9229
volumes:
- ./api:/api/app
- /api/app/node_modules
mongo:
image: mongo:3.6.13
restart: always
ports:
- 27017:27017
volumes:
- mongodb:/data/db
volumes:
mongodb:
secrets:
jwt_secret_local:
file: ./secrets/jwt_secret_local
sendgrid_api_key:
file: ./secrets/sendgrid_api_keyIt's not perfect. I haven't touched this in over a year but it did the job.
Some Caveats
1) Don't run integration tests in a build stage
I have integration tests where I programmatically create a temporary database using the testcontainers-go library (testcontainers-node also exists).
The issue with running integration tests in a build stage is that you'll get unix socket not found errors. Basically the build stage can't communicate with the docker daemon to run the container. I don't think this is even possible and I just avoided it by not running integration tests or unit tests altogether in my build stage. But if you only have unit tests ( e.i., no containers generated) its fine to run them in a test stage.
2) Sometimes an API cannot connect to a database the first try. I fix this programmatically.
I have a database connection retry function. This saved me in production.
// database.ts
import mongoose from 'mongoose';
const mongoUri = process.env.MONGODB_URI;
const log = (msg: string) => console.log(msg);
mongoose.Promise = global.Promise;
mongoose.set('useFindAndModify', false);
mongoose.connection.on('disconnected', () => log('\nMongo disconnected'.red));
mongoose.connection.on('connected', () => log(`Mongo Connected`.green));
const options = {
autoIndex: false, // Don't build indexes
reconnectTries: 30, // Retry up to 30 times
reconnectInterval: 500, // Reconnect every 500ms
poolSize: 10, // Maintain up to 10 socket connections
bufferMaxEntries: 0, // return errors immediately rather than waiting for reconnect
useCreateIndex: true,
useNewUrlParser: true
};
function connectWithRetry() {
console.log('MongoDB connection with retry');
mongoUri &&
mongoose
.connect(mongoUri, options)
.then(() => {
console.log('MongoDB is connected');
})
.catch(_ => {
console.log('MongoDB connection unsuccessful, retry after 5 seconds.');
setTimeout(connectWithRetry, 5000);
});
}
connectWithRetry();3) Graceful shutdown your backend
You'll want to capture app termination and nodemon restart events to shutdown your database connection gracefully.
...
// on process restart or termination
function gracefulShutdown(msg: string, callback: any) {
mongoose.connection.close(() => {
log(`Mongo disconnected through ${msg}`.red);
callback();
});
}
// on nodemon restarts
process.once('SIGUSR2', () => {
gracefulShutdown('nodemon restart', () => {
process.kill(process.pid, 'SIGUSR2');
});
});
// on app termination
process.on('SIGINT', () => {
gracefulShutdown('App termination (SIGINT)', () => {
process.exit(0);
});
});
// on Heroku app termination
process.on('SIGTERM', () => {
gracefulShutdown('App termination (SIGTERM)', () => {
process.exit(0);
});
});4) Docker secrets
When using Docker Swarm mode, Docker secrets aren't just magically available to your app. You need to find them and add their values to process.env. I used this public docker-secret library on npm but that's pretty dumb. I recommend copying the npm module code and keeping it as a private package. That way is much safer.
// secrets.ts
import path from 'path';
import { getSecret } from 'docker-secret';
function isSecret(key: string) {
const env = process.env[key];
return env && env.includes('/run/secrets') ? true : false;
}
function getSecrets(): NodeJS.ProcessEnv {
return Object.keys(process.env).reduce(
(env: any, key: string): NodeJS.ProcessEnv => {
const envValue = process.env[key];
if (envValue && isSecret(key)) {
env[key] = getSecret(path.basename(envValue));
}
return env;
},
{}
);
}
process.env = { ...process.env, ...getSecrets() };Have fun and experiment!
TurtleWolfe
leggettc18
I like this example and have learned a lot from just reading through your code to see how you've set it up, but I'm unfamiliar with the syntax of GO, would you foresee any snagging points if I replaced the back end with what I know of a Node API? Do you have any other repos that would sample that setup? I'll be reading your blog post next, maybe someone has already asked this on the comments there..