docker-compose-react-node-deployment-troubleshooting

 

 

 

 

Docker Compose, React & Node.js Deployment, and Container Troubleshooting Guide

As applications grow, managing multiple Docker containers manually becomes difficult. Imagine starting separate containers for React, Node.js, MongoDB, Redis, and Nginx every time you want to run your project.

Docker Compose solves this problem by allowing you to define and manage multi-container applications using a single configuration file.

In this guide, you'll learn Docker Compose, deploying React and Node.js applications, and common container troubleshooting techniques.

What is Docker Compose?

Docker Compose is a tool that allows you to define and run multiple Docker containers using a single YAML configuration file.

Instead of running multiple commands manually:

  
docker run ...
docker run ...
docker run ...

  

You can define everything inside a single file:

docker-compose.yml

and start all services with one command. 

 

 

Why Use Docker Compose?

Benefits include:

• Simplified container management
• Easy multi-container deployments
• Better configuration management
• Consistent development environments
• Faster application startup

Docker Compose is commonly used for:

• React Applications
• Node.js APIs
• MongoDB Databases
• Redis Caching
• Nginx Reverse Proxies

 

 

Understanding docker-compose.yml

A basic Docker Compose file looks like this:

In this example:

frontend runs the React application
backend runs the Node.js API
database runs MongoDB

All services are automatically connected through an internal Docker network.

 

version: '3'

services:
  frontend:
    image: react-app

  backend:
    image: node-app

  database:
    image: mongo

 

 

 In this example:

• frontend runs the React application
• backend runs the Node.js API
• database runs MongoDB

All services are automatically connected through an internal Docker network. Learn Docker Compose, deploy React and Node.js applications, and master container troubleshooting with practical examples. A beginner-friendly guide for DevOps and System Engineers.

Starting Docker Compose

Run:

• docker compose up

Docker will:

• Create networks
• Create containers
• Start services
• Connect containers

To run in the background:

• docker compose up -d
• Stopping Docker Compose

Stop all services:

• docker compose down

Docker removes containers and networks created by Compose.

 

 Deploying a React Application

  
FROM node:22

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 3000

CMD ["npm","start"]
  

Suppose you have a React application.

Create a Dockerfile:

Build the image:

• docker build -t react-app .

Run the container:

• docker run -d -p 3000:3000 react-app

Open:

• http://localhost:3000

Your React application should now be accessible.

 

Deploying a Node.js Application

Create a Dockerfile:

Build the image:

  
  FROM node:22

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 5000

CMD ["node","server.js"]
  

• docker build -t node-app .

Run the application:

• docker run -d -p 5000:5000 node-app

Access:

• http://localhost:5000

 

Deploying React, Node.js, and MongoDB Together

A production application often contains:



Docker Compose makes managing these services much easier.

Example:

 

React Frontend
       │
       ▼
Node.js Backend
       │
       ▼
MongoDB Database

 

 
Start everything:

docker compose up -d

Now all services run together.

 

version: '3'

services:
  frontend:
    image: react-app
    ports:
      - "3000:3000"

  backend:
    image: node-app
    ports:
      - "5000:5000"

  mongodb:
    image: mongo
    ports:
      - "27017:27017"

 

 

Container Troubleshooting

Troubleshooting is an essential Docker skill for System Engineers and DevOps Engineers.

Check Running Container

• docker ps

View all containers:

• docker ps -a 

 

 

Check Container Logs

Logs help identify startup issues.

docker logs container_name

Example:

• docker logs backend

Access Container Shell

Enter a running container:

• docker exec -it container_name bash

Example:

• docker exec -it backend bash

This is useful for checking:

• Application files
• Environment variables
• Network connectivity
• Installed packages

 

 

Inspect Container Details

View container configuration:

docker inspect container_name

This displays:

• IP Address
• Volumes
• Networks
• Environment Variables
• Mount Points
• Monitor Resource Usage

Check CPU and Memory:

• docker stats

Useful for identifying performance bottlenecks.

 

 Restart a Container

docker restart container_name

Example:

• docker restart backend

 

Common Docker Issues

Port Already in Use

Error:

• Bind for 0.0.0.0 failed

Solution:

• docker ps

Find the conflicting container and stop it.

 

Container Exits Immediately

Check logs:

• docker logs container_name

Usually caused by:

• Incorrect CMD
• Missing dependencies
• Application errors
• Cannot Access Application

Verify:

• docker ps

Check:

• Port mapping
• Firewall settings
• Container status 

 

Network Communication Issues

Inspect network:

• docker network ls
• Inspect container:
• docker inspect container_name
• Ensure containers are connected to the same Docker network.

Essential Commands

Start Compose:

• docker compose up -d
• Stop Compose:
• docker compose down
• View Containers:
• docker ps
• View Logs:
• docker logs container_name
• Enter Container:
• docker exec -it container_name bash
• Inspect Container:
• docker inspect container_name
• Monitor Resources:
• docker stats

 

Conclusion

Docker Compose simplifies the management of multi-container applications by allowing developers and system administrators to define services in a single configuration file.

Combined with React, Node.js, and MongoDB deployments, Docker Compose enables efficient application management and scalable infrastructure. Understanding container troubleshooting techniques further prepares you for real-world DevOps, Cloud Engineering, and System Administration roles.

Mastering Docker Compose and troubleshooting skills is a significant step toward becoming a proficient System Engineer or DevOps Engineer.