Sujit Patel – Site Reliability Engineer

Docker has become a popular tool for modern web development, allowing developers to create and deploy applications consistently across different environments. Dockerizing your Next.js application can provide many benefits, such as consistency, portability, and scalability. In this blog post, we will explore how to dockerize a Next.js application and take advantage of Docker's benefits.

Steps:

Create a Dockerfile for Next js

The first step is to create a Dockerfile, which is a script that contains instructions for building a Docker image. Here's an example Dockerfile for a Next.js application:

FROM node:18-alpine AS base

FROM base AS deps
RUN apk add --no-cache libc6-compat
WORKDIR /app
COPY package.json yarn.lock* package-lock.json* pnpm-lock.yaml* ./
RUN yarn --frozen-lockfile

FROM base AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .
RUN npm run build

FROM base AS runner
WORKDIR /app
ENV NODE_ENV production
ENV NEXT_TELEMETRY_DISABLED 1
RUN addgroup --system --gid 1001 nodejs
RUN adduser --system --uid 1001 nextjs
COPY --from=builder /app/public ./public
COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static
USER nextjs
EXPOSE 3000
ENV PORT 3000
CMD ["node", "server.js"]

Above is an example of multi-stage build Dockerfile. Here's a breakdown of what each section of the Dockerfile does:

FROM node:18-alpine AS base: This sets the base image for the Dockerfile to node:18-alpine, which is the official Node.js 18 Alpine image.
FROM base AS deps: This creates a new stage in the Dockerfile, using the base image as the base image for this stage. In this stage, we install any dependencies required for the Next.js application. We first install libc6-compat package, which provides compatibility for programs that use glibc. Then we set the working directory to /app and copy over the package.json, yarn.lock, package-lock.json, and pnpm-lock.yaml files. Finally, we install the dependencies using yarn.
FROM base AS builder: This creates another stage in the Dockerfile, using the base image as the base image for this stage. In this stage, we copy over the files from the previous stage, including the installed dependencies. We then run the npm run build command to build the Next.js application.
FROM base AS runner: This creates the final stage in the Dockerfile, using the base image as the base image for this stage. In this stage, we set the working directory to /app, set the NODE_ENV environment variable to production, and disable Next.js telemetry. We then create a nodejs group with a GID of 1001 and a nextjs user with a UID of 1001. We copy over the built Next.js application files from the builder stage, set the user to nextjs, expose port 3000, set the PORT environment variable to 3000, and specify the command to run the Next.js server.

Why use multi-stage Dockerfile?

Multi-stage builds in Docker are used to optimize the size of the resulting image and reduce the attack surface. When building a Docker image, each layer added to the image adds size, which can slow down development and deployment processes. Multi-stage builds help to solve this problem by allowing for the creation of multiple stages in the Dockerfile, each of which can have a different base image and set of instructions. Each stage creates a separate layer in the resulting image, but you can choose which layers to keep and which to discard. This approach helps to minimize the size of the resulting image and reduce the attack surface by including only what is necessary to run the application in production. Overall, multi-stage builds are an important tool for optimizing Docker images and making them more efficient and secure.

Build the Docker Image

Once you've created the Dockerfile, you can build the Docker image using the docker build command. Here's an example command:

docker build -t my-next-app .

In this command, we're using the -t flag to specify the name of the Docker image (my-next-app), and the . at the end specifies the location of the Dockerfile (in the current directory).

To check docker images, run below command:

docker images

Run the Docker Container

After building the Docker image, you can run the Docker container using the docker run command. Here's an example command:

docker run -p 3000:3000 -d my-next-app

In this command, we're using the -p flag to map the container's port 3000 to the host machine's port 3000, -d is to run the container in background, and my-next-app specifies the name of the Docker image we want to run.

To check running containers, run the below command:

docker ps

To check logs, run the below command:

docker logs -f 5156a31ad3a5 #replca with your container id/name

In this command, we're using -f to get the running logs, and "5156a31ad3a5" is a container id you can also use container name instead of id.

To access your application, open your browser and go to http://localhost:3000