How to Setup an Nginx Reverse Proxy

using Amazon Lightsail Containers

Amazon Lightsail is an easy-to-use virtual private server. Lightsail recently launched a Containers service. Follow along this tutorial to learn how to setup an Nginx Reverse Proxy using Amazon Lightsail containers. 

In this tutorial, you'll learn how to configure a Flask web server behind an Nginx reverse proxy using Lightsail containers. The Nginx reverse proxy accepts web requests on port 80 and forwards them to the Flask web server on port 5000. The Flask web server fulfills the requests and return the response to Nginx.

A Lightsail container service hosta both the Nginx and the Flask containers. A public endpoint allows external access to the Nginx server.

Get started with Amazon Lightsail for free. 

About this Tutorial
Time 30 minutes   
Cost Free
Use Case Compute
Products Amazon Lightsail
Level 200
Last Updated February 10, 2021

Step 1: Prerequisites

Complete the following prerequisites before you get started with your app.

1.1 — You need an AWS account and must install Docker, Docker compose, the AWS Command Line Interface (CLI) tool and the Lightsail Control (lightsailctl) plugin on your system. Follow the provided links if you don’t have some of those.

Already have an account? Log in to your account

Step 2: Get the source code

2.1 — Clone the GitHub repository locally.

 

git clone https://github.com/awsgeek/lightsail-containers-nginx.git

2.2 — Change to the project directory.

For the remainder of this guide, all commands will be run from the project directory.

cd lightsail-containers-nginx

Step 3: The Flask application

The Flask application contains a single hello_world() function that is triggered when the route / is requested. When run, this application binds to all IPs on the system ("0.0.0.0") and listens on port 5000 (this is the default Flask port).

3.1 — The source for the Flask application, app.py, is shown in the following code block. 

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello_world():
   return "Hello, World!"

if __name__ == "__main__":
   app.run(host="0.0.0.0", port=5000)

3.2 —The Dockerfile for the Flask application uses a Python alpine image to minimize container image size. The command to run when the container starts is the same as if run from the command line: python app.py

# Set base image (host OS)
FROM python:3.8-alpine

# By default, listen on port 5000
EXPOSE 5000/tcp

# Set the working directory in the container
WORKDIR /app

# Copy the dependencies file to the working directory
COPY requirements.txt .

# Install any dependencies
RUN pip install -r requirements.txt

# Copy the content of the local src directory to the working directory
COPY app.py .

# Specify the command to run on container start
CMD ["python", "./app.py"]

Step 4: Build the Flask container

Complete the following steps to build the Flask application container on your local system.

4.1 — Build the container using Docker. Complete the following command from the project directory:

This command builds a container using the Dockerfile in the current directory and tags the container flask-container.

docker build -t flask-container ./flask

4.2 —Once the container build is done, test the Flask application locally by running the container:

docker run -p 5000:5000 flask-container

4.3 — The Flask app will run in the container and will be exposed to your local system on port 5000. 

Browse to http://localhost:5000 or use curl from the command line and you will see Hello, World!

To stop the container, type CTRL-C

curl localhost:5000

Hello, World!

Step 5: The Nginx reverse proxy

5.1 — The Nginx reverse proxy forwards all requests to the Flask application on port 5000. Configure Nginx to forward requests requires with the following simple configuration file, nginx.conf: 

This configuration forwards all requests to the upstream Flask server. The hostname and port of the Flask server are provided as environmental variables when the containers are run.

events {}

http {

   upstream flask {
      server ${FLASK_HOST}:${FLASK_PORT};
   }

   # a simple reverse-proxy
   server {

      listen 80 default_server;

      location / {
            # pass requests to the Flask host
            proxy_pass http://flask;
      }
   }
}

5.2 —The Dockerfile for the Nginx reverse proxy uses the head Nginx alpine image and simply copies the nginx.conf configuration file to the appropriate directory.

This is shown in the following code. 

FROM nginx:1.19-alpine
COPY ./nginx.conf /etc/nginx/templates/nginx.conf.template

Step 6: Build the Nginx container

Complete the following steps to build the Nginx reverse proxy container on your local system.

6.1 —Build the container using Docker. Complete the following command from the project directory:

This command builds a container using the Dockerfile in the current directory and tags the container nginx-container.

docker build -t nginx-container ./nginx

6.2 —After the container build is done, test the Nginx proxy and Flask application locally by running the container:

docker-compose up –-build

6.3 — Both the Flask application and Nginx reverse proxy containers will be run. The Nginx server listens for requests on port 80 and forwards them to the Flask application. Browse to http://localhost or use curl from the command line and you will see Hello, World!

To stop the containers, type CTRL-C

curl localhost

Hello, World!

Step 7: Create a container service

Complete the following steps to create the Lightsail container service and then push your local container images to the new container service.

7.1 — Create a Lightsail container service with the create-container-service command.

The power and scale parameters specify the capacity of the container service. For the purposes of this guide, little capacity is required.

The output of the create-container-service command indicates the state of the new service is PENDING (as seen in second code block).

aws lightsail create-container-service --service-name sample-service \
--power small \
--scale 1
{
    "containerService": {
        "containerServiceName": "sample-service",
        ...
        "state": "PENDING",

7.2 —Use the get-container-services command to monitor the state of the container as it is being created.

Wait until the container service state changes to ACTIVE before continuing to the next step. Your container service should become active after a few minutes.

aws lightsail get-container-services --service-name sample-service

7.3 — Push the Flask application container to Lightsail with the push-container-image command.

Note: the X in sample-service.flask-container.X will be a numeric value. If this is the first time you’ve pushed an image to your container service, this number will be 1. You will need this number in the next step.

aws lightsail push-container-image --service-name sample-service \
--label flask-container \
--image flask-container

...

Refer to this image as ":sample-service.flask-container.X" in deployments.

7.4 —Push the Nginx reverse proxy container to Lightsail with the push-container-image command.

Note: the Y in :sample-service.nginx-container.Y will be a numeric value. If this is the first time you’ve pushed an image to your container service, this number will be 1. You will need this number in the next step.

aws lightsail push-container-image --service-name sample-service \
--label nginx-container \
--image nginx-container

...

Refer to this image as ":sample-service.nginx-container.Y" in deployments.

Step 8: Deploy the containers

Complete the following steps to create deployment and public endpoint configuration JSON files, and then deploy your container images to your container service.

8.1 — Create a new file, containers.json.

Edit the file and add the following code block. 

Replace the X in :sample-service.flask-container.X and the Y in :sample-service.nginx-container.Y with the numeric values from the previous step. 

Save the file.

The containers.json file describes the settings of the containers that will be launched on the container service. In this instance, the containers.json file describes both the Nginx and Flask containers, the images the containers will use and the ports the containers will expose. In addition, environmental variables that specify the Flask host and port are provided. At runtime Nginx will replace the placeholder values in the nginx.conf file with the actual values provided here.

{
   "sample-nginx": {
      "image": ":sample-service.nginx-container.Y",
      "command": [],
      "ports": {
            "80": "HTTP"
      },
      "environment": {
            "NGINX_ENVSUBST_OUTPUT_DIR": "/etc/nginx",
            "FLASK_HOST": "localhost",
            "FLASK_PORT": "5000"
      }
   },
   "sample-flask": {
      "image": ":sample-service.flask-container.X",
      "ports": {
            "5000": "HTTP"
      }
   }

8.2 —Create a new file, public-endpoint.json

Edit the file and add the following code. 

Save the file.

The public-endpoint.json file describes the settings of the public endpoint for the container service. In this instance, the public-endpoint.json file indicates the Nginx container will expose port 80. Public endpoint settings are only required for services that require public access.

{
    "containerName": "sample-nginx",
    "containerPort": 80
}

8.3 — Deploy the containers to the container service with the AWS CLI using the create-container-service-deployment command.

The output of the create-container-service-deployment command indicates that the state of the container service is now DEPLOYING (as shown in the second code block). 

aws lightsail create-container-service-deployment --service-name sample-service \
--containers file://containers.json \
--public-endpoint file://public-endpoint.json
{
    "containerServices": [{
        "containerServiceName": "sample-service",
        ...
        "state": "DEPLOYING",

8.4 — Use the get-container-services command to monitor the state of the container until it changes to RUNNING before continuing to the next step.

The get-container-service command also returns the endpoint URL for container service.

After the container service state changes to RUNNING, navigate to this URL in your browser to verify your container service is running properly. Your browser output should show "Hello, World!" as before.

Congratulations. You have successfully deployed a containerized Nginx reverse proxy and Flask application using Amazon Lightsail containers.

aws lightsail get-container-services --service-name sample-service
{
    "containerServices": [{
        "containerServiceName": "sample-service",
        ...
        "state": "RUNNING",
        ...
        "url": "https://sample-service...

Step 9: Cleanup

Complete the following steps to the Lightsail container service that you created as part of this tutorial.

9.1 — To cleanup and delete Lightsail resources, use the delete-container-service command.

The delete-container-service removes the container service, any associated container deployments, and container images.

aws lightsail delete-container-service --service-name sample-service
{
    "containerService": {
        "containerServiceName": "sample-service",
        ...
        "state": "PENDING",

Congratulations

Congratulations. You have successfully deployed a containerized Nginx reverse proxy and Flask application.

Amazon Lightsail is a great choice to develop, build, and deploy a variety of applications like WordPress, websites, and blog platforms.

Was this tutorial helpful?

View your container logs

View the logs of containers on your container service. Read more here

Monitor utilization metrics

Monitor the utilization metrics of your container service. Read more here

View source code

The source code for this guide and this documentation is in this Github repository