Freelancer Client

How to Create an Nginx Proxy Docker Container? - OpsNexa

  • Home
  • How to Create an Nginx Proxy Docker Container?

How to Create an Nginx Proxy Docker Container: A Step-by-Step Guide by OpsNexa

Nginx is a popular web server and reverse proxy server used to handle HTTP requests and distribute traffic across different backend services. When working with Docker, it’s often useful to set up Nginx as a reverse proxy to route traffic between multiple containers, providing enhanced scalability, security, and performance.

In this guide by OpsNexa, we’ll walk you through the process of creating an Nginx proxy Docker container. Whether you are deploying multiple services or need to optimize traffic handling, setting up Nginx as a proxy for your Dockerized applications is a powerful solution.

What is a Reverse Proxy?

A reverse proxy is a server that sits between client requests and backend servers, forwarding client requests to the appropriate server. In the case of Docker, the reverse proxy can route incoming traffic to various Docker containers based on the request URL, improving load distribution and offering enhanced security and flexibility.

Nginx is a commonly used reverse proxy because of its high performance, scalability, and ease of configuration. By using Nginx as a proxy in front of your Docker containers, you can manage multiple services under one domain name, improve routing, and handle SSL termination.

Why Use Nginx as a Proxy for Docker Containers?

There are several reasons why using Nginx as a reverse proxy for Docker containers is beneficial:

  • Traffic Distribution: Nginx can distribute traffic to different containers based on routing rules. For instance, it can direct requests for different domains or paths to separate services running in individual Docker containers.

  • Load Balancing: With Nginx, you can load balance traffic between multiple instances of the same service, helping to scale applications horizontally.

  • Security: Nginx allows you to implement HTTPS for secure communication by handling SSL/TLS termination. This protects sensitive data and improves the security of your applications.

  • Improved Performance: Nginx’s asynchronous event-driven model can handle a large number of concurrent connections efficiently, ensuring optimal performance even under heavy traffic.

Prerequisites for Setting Up an Nginx Proxy in Docker

Before diving into the steps, ensure that the following prerequisites are in place:

  1. Docker and Docker Compose Installed: Ensure you have Docker and Docker Compose installed on your server or local machine. You can install Docker by following the official installation guide on the Docker website.

  2. A Few Docker Containers Running: For the proxy to work, you need at least one Docker container running a web service (e.g., a Node.js app, PHP app, or a simple HTML service).

  3. Basic Knowledge of Nginx and Docker: Familiarity with basic Nginx configuration and Docker commands is helpful.

Step-by-Step Guide to Create an Nginx Proxy Docker Container

Let’s break down the steps to set up an Nginx reverse proxy using Docker.

Step 1: Create a Docker Network for Your Containers

First, you’ll want to create a Docker network so that your containers can communicate with each other. This network allows Docker containers to find each other using container names as hostnames.

Run the following command to create a network:

bash
docker network create nginx-proxy

This network will allow the Nginx container to communicate with the backend services you want to proxy.

Step 2: Create the Docker Containers for Your Applications

Let’s say you have two Docker containers for different applications. You can create simple applications like a web service running on Nginx and another app running on Node.js.

Create a Simple Web Application Container

For demonstration purposes, let’s create a simple web server container using the official Nginx image.

bash
docker run -d --name web-app --network nginx-proxy -p 8080:80 nginx

This command runs the Nginx container named web-app on port 8080, connected to the nginx-proxy network.

Create Another Web Application (Node.js Example)

Now, let’s create another simple container, this time for a Node.js app.

Create a Dockerfile for your Node.js application:

Dockerfile
# Dockerfile for Node.js app
FROM node:14

WORKDIR /app

COPY . .

RUN npm install

EXPOSE 3000

CMD ["npm", "start"]

Build the Docker image:

bash
docker build -t node-app .

Now run the Node.js app in a container:

bash
docker run -d --name node-app --network nginx-proxy -p 3000:3000 node-app

You now have two running containers, one for Nginx and the other for Node.js.

Step 3: Set Up the Nginx Configuration

Now, let’s configure Nginx to proxy traffic to these containers. Create a custom nginx.conf file with the reverse proxy settings. You can create this file on your local machine or server.

Here’s a sample nginx.conf file:

nginx
http {
upstream webapp {
server web-app:80;
}

upstream nodeapp {
server node-app:3000;
}

server {
listen 80;

server_name example.com;

location /webapp {
proxy_pass http://webapp;
}

location /nodeapp {
proxy_pass http://nodeapp;
}
}
}

In this configuration:

  • We define two upstream blocks: webapp and nodeapp, pointing to the respective containers (web-app and node-app).

  • Requests for /webapp are forwarded to the web-app container, and requests for /nodeapp are forwarded to the node-app container.

Step 4: Build the Nginx Proxy Container

Now, we need to create an Nginx container with this configuration. Create a Dockerfile for the Nginx proxy:

Dockerfile
# Dockerfile for Nginx Proxy
FROM nginx:latest

# Copy the custom nginx.conf to the container
COPY nginx.conf /etc/nginx/nginx.conf

Build the Nginx proxy image:

bash
docker build -t nginx-proxy .

Step 5: Run the Nginx Proxy Container

Once the Docker image is built, run the Nginx proxy container:

bash
docker run -d --name nginx-proxy --network nginx-proxy -p 80:80 nginx-proxy

This command runs the Nginx proxy container, which listens on port 80 and routes traffic based on the configuration in nginx.conf.

Step 6: Test the Proxy Setup

You should now be able to access your applications through the proxy. Test the following URLs:

  • http://<EC2-public-ip>/webapp to access the Nginx web application.

  • http://<EC2-public-ip>/nodeapp to access the Node.js application.

If everything is set up correctly, Nginx will proxy the requests to the appropriate containers.

Step 7: (Optional) Use Docker Compose for Simplification

If you have multiple containers, managing them with Docker Compose can simplify the process. Here’s a docker-compose.yml file that ties everything together:

yaml
version: '3'

services:
nginx-proxy:
build: ./nginx-proxy
ports:
- "80:80"
networks:
- nginx-proxy

web-app:
image: nginx
networks:
- nginx-proxy
expose:
- "80"

node-app:
build: ./node-app
networks:
- nginx-proxy
expose:
- "3000"

networks:
nginx-proxy:
driver: bridge

This docker-compose.yml file defines three services:

  • nginx-proxy: The Nginx reverse proxy container.

  • web-app: The Nginx web server container.

  • node-app: The Node.js application container.

Step 8: Launch Containers Using Docker Compose

Run the following command to bring up all the services:

bash
docker-compose up -d

Now, you can access both applications through Nginx, just as before.

Conclusion

Setting up an Nginx proxy for your Docker containers on EC2 is an excellent way to handle incoming traffic, improve performance, and scale your applications. By following this step-by-step guide from OpsNexa, you can create a robust and flexible Dockerized architecture with Nginx acting as a reverse proxy.

Whether you’re deploying a single service or multiple microservices, Nginx simplifies the routing of traffic, improves security, and optimizes performance. With tools like Docker Compose, you can further streamline the management of multiple containers, ensuring that your applications run smoothly.

Start building your own Nginx reverse proxy for Docker today and enhance your cloud infrastructure with OpsNexa!