Dockerize Your Next.js App: Simplifying Development and Deployment

In recent years, Docker has become an invaluable tool for web developers looking to streamline their development and deployment workflows. With Docker, you can containerize your applications and dependencies, allowing you to easily deploy them to any environment without worrying about compatibility issues or configuration differences. In this tutorial, we’ll show you how to create a simple Next.js app, containerize it using Docker, and streamline your development and deployment process with docker-compose and Kubernetes.

Why Use Docker with Next.js

Next.js is a popular framework for building server-side rendered React applications. While Next.js is relatively easy to set up and get running, the complexity of modern web applications can make development and deployment workflows challenging. Developers need to consider a wide range of factors, from ensuring compatibility with different versions of Node.js and dependencies, to handling complex build processes and deployment strategies.

By containerizing Next.js with Docker, you can simplify many of these processes. Docker allows you to package up all of your application’s dependencies, configuration files, and other assets into a single container, ensuring that your app can be run consistently across different environments. With Docker, you can also easily share your application with other developers, test different configurations, and deploy your app to production with minimal hassle.

Step 1: Set Up Your Next.js App

To get started, you’ll need to set up a basic Next.js app. If you’re new to Next.js, the official documentation offers a helpful tutorial to help you get started. For this tutorial, we’ll assume that you have a basic understanding of Next.js and have already set up a simple app.

Step 2: Create a Dockerfile

Once you have your Next.js app up and running, the next step is to create a Dockerfile. The Dockerfile is a script that tells Docker how to build your app into a container. Here’s an example Dockerfile for a basic Next.js app:

    FROM node:14-alpine
    WORKDIR /app
    COPY package.json yarn.lock ./
    RUN yarn install --frozen-lockfile
    COPY . .
    RUN yarn build
    EXPOSE 3000
    CMD ["yarn", "start"]

Let’s break this down line by line:

  • FROM node:14-alpine: This line tells Docker to use the official Node.js image as the base for our app.
  • WORKDIR /app: This sets the working directory for our app inside the container.
  • COPY package.json yarn.lock ./: This copies the package.json and yarn.lock files to the container, allowing us to install our dependencies.
  • RUN yarn install --frozen-lockfile: This installs our app’s dependencies. Note the --frozen-lockfile flag, which ensures that we always use the same exact versions of our dependencies.
  • COPY . .: This copies our entire app into the container.
  • RUN yarn build: This builds our app for production.
  • EXPOSE 3000: This exposes port 3000 on the container, which is the default port used by Next.js.
  • CMD ["yarn", "start"]: This sets the default command for the container to run our app using the yarn start command.

Step 3: Build and Run Your Container

With your Dockerfile in place, the next step is to build and run your container. Here’s an example command to build your container:

    docker build -t my-next-app .

This command tells Docker to build your container using the Dockerfile in the current directory, and tag it with the name my-next-app.

Once your container is built, you can run it using the following command:

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

This command tells Docker to run your container, map port 3000 on the container to port 3000 on your local machine, and use the image tagged as my-next-app.

If everything worked correctly, you should be able to open your Next.js app in your browser by visiting http://localhost:3000.

Step 4: Streamlining Your Development Workflow with docker-compose

While Docker makes it easy to containerize your app, managing multiple containers and configuring their interactions can be tricky. This is where docker-compose comes in. docker-compose is a tool that allows you to define and run multiple containers together as a single service. With docker-compose, you can define your app’s dependencies, how they interact with each other, and how they should be run during development.

Here’s an example docker-compose.yml file for a Next.js app and a MongoDB database:

    version: '3.7'

        build: .
          - "3000:3000"
          - .:/app
        image: mongo:latest
          - dbdata:/data/db
          - "27017:27017"


Let’s break this down line by line:

  • version: '3.7': This specifies the version of docker-compose to use.
  • services:: This defines the different services that make up our app.
  • web:: This defines the web service, which is our Next.js app.
  • build: .: This tells docker-compose to build our app using the Dockerfile in the current directory.
  • ports:: This maps port 3000 on the container to port 3000 on our local machine.
  • volumes:: This mounts the current directory on our local machine to the /app directory inside the container, allowing us to make changes to our code and instantly see them reflected in the app.
  • db:: This defines the database service, which is an instance of the latest MongoDB image.
  • image: mongo:latest: This specifies the MongoDB image to use.
  • ports:: This maps port 27017 on the container to port 27017 on our local machine.
  • volumes:: This creates a persistent data volume for our database.

With this docker-compose.yml file in place, we can start our app and database with a single command:

    docker-compose up

This command tells docker-compose to start all of the containers defined in the docker-compose.yml file. You can then open your Next.js app in your browser by visiting http://localhost:3000.

Step 5: Deploying to Kubernetes

Finally, let’s look at how you can deploy your Next.js app to a Kubernetes cluster. Kubernetes is a powerful tool for orchestrating containers in production, providing features such as scaling, rolling updates, and self-healing.

To deploy your app to Kubernetes, you’ll need to create a deployment YAML file that defines your app and its dependent resources. Here’s an example deployment YAML file:

    apiVersion: apps/v1
    kind: Deployment
      name: my-next-app
        app: my-next-app
      replicas: 2
          app: my-next-app
            app: my-next-app
          - name: my-next-app
            image: my-next-app
            - containerPort: 3000

Let’s break this down line by line:

  • apiVersion: apps/v1: This specifies the API version to use.
  • kind: Deployment: This specifies that we’re creating a deployment.
  • metadata:: This sets metadata for our deployment, such as the name and labels.
  • spec:: This defines the specification for our deployment, such as the number of replicas to run.
  • replicas: 2: This specifies that we want to run two instances of our app.
  • selector:: This defines the label selector for our deployment.
  • matchLabels:: This specifies the label that our deployment will match against.
  • template:: This defines the pod template for our deployment.
  • containers:: This defines the list of containers to run in each pod.
  • name: my-next-app: This specifies the name of the container.
  • image: my-next-app: This specifies the Docker image to use for the container.
  • ports:: This specifies the ports to expose in the container.
  • containerPort: 3000: This specifies that we want to expose port 3000 in the container.

To deploy your app to Kubernetes, apply the deployment YAML file using the following command:

    kubectl apply -f my-next-app-deployment.yaml

This command tells Kubernetes to apply the deployment YAML file, creating all of the necessary resources to run your app. You can then access your app by visiting the node port for your Kubernetes service.


Containerizing your Next.js app with Docker can help you simplify your development and deployment workflows, allowing you to easily manage dependencies, share your app with other developers, and deploy to production with minimal hassle. By using tools like docker-compose and Kubernetes, you can further streamline your workflow and take full advantage of the power of containerization.