Setting Up a Python Web Application on a Linux VPS

Deploying a Python Web Application on a Linux VPS

Deploying a Python Web Application on a Linux VPS

Introduction

In today’s digital landscape, deploying web applications has become a fundamental skill for developers. This tutorial will guide you through the process of deploying a Python web application on a Linux VPS (Virtual Private Server). We will utilize Flask, a popular lightweight web framework, alongside PostgreSQL, a powerful relational database. By the end of this tutorial, you’ll have a fully functional web application that you can customize and expand. Let’s dive in!

Prerequisites

Before we begin, ensure you have the following:

  1. A VPS running Ubuntu 20.04 or later.
  2. SSH access to your VPS.
  3. Basic familiarity with the command line.


Step 1: Connect to Your VPS

First and foremost, establish a connection to your VPS using SSH. Open your terminal and execute the following command:

ssh username@your_server_ip

Make sure to replace username with your actual username and your_server_ip with your VPS’s IP address. Once connected, you are ready to proceed to the next step.

Step 2: Update Your System

To ensure that your server is running the latest software, it is crucial to update your system. Run the following commands:

sudo apt update && sudo apt upgrade -y

Updating your system helps prevent compatibility issues and ensures that you have the latest security patches.

Step 3: Install Python and pip

Now, let’s install Python and pip, which are essential for running your web application. Execute the following command:

sudo apt install python3 python3-pip python3-venv -y

After installation, verify that Python and pip are correctly installed by checking their versions:

python3 --version  
pip3 --version

If the installation is successful, you’ll see the version numbers displayed.

Step 4: Install PostgreSQL

Next, we will install PostgreSQL, a robust relational database management system suitable for handling data in web applications.

  1. Install PostgreSQL by running this command:
sudo apt install postgresql postgresql-contrib -y
  1. After installation, start and enable the PostgreSQL service to ensure it runs on boot:
sudo systemctl start postgresql  
sudo systemctl enable postgresql
  1. Now, switch to the PostgreSQL user to create a database and user:
sudo -i -u postgres
  1. Open the PostgreSQL prompt:
psql
  1. Create a new database and user by executing the following commands:
CREATE DATABASE flaskapp;
CREATE USER flaskuser WITH PASSWORD 'yourpassword';
GRANT ALL PRIVILEGES ON DATABASE flaskapp TO flaskuser;
\q

Make sure to replace 'yourpassword' with a strong password of your choice. This step ensures that your application has a dedicated database and user for secure access.

Step 5: Create a Python Virtual Environment

Creating a virtual environment is essential for managing dependencies effectively. This practice helps avoid conflicts between package versions. Here’s how to create one:

  1. Navigate to your desired project directory. You can create a projects directory if you don’t have one:
mkdir ~/projects && cd ~/projects
  1. Create a virtual environment:
python3 -m venv myenv
  1. Activate the virtual environment:
source myenv/bin/activate

Once activated, you’ll notice your terminal prompt changes, indicating that your virtual environment is active.

Step 6: Install Flask

With your virtual environment activated, you can now install Flask and the PostgreSQL adapter:

pip install Flask psycopg2-binary

Flask serves as the web framework, while psycopg2-binary allows Python to interact with PostgreSQL.

Step 7: Create a Sample Flask Application

Now that you have Flask installed, it’s time to create a sample application.

  1. Create a new directory for your Flask application:
mkdir flaskapp && cd flaskapp
  1. Create a new file called app.py:
nano app.py
  1. Add the following code to app.py:
from flask import Flask, request, jsonify  
import psycopg2

app = Flask(__name__)

# Database connection  
def get_db_connection():
    conn = psycopg2.connect(
        database='flaskapp',
        user='flaskuser',
        password='yourpassword',
        host='localhost',
        port='5432'
    )
    return conn

@app.route('/')
def index():
    return "Welcome to the Flask App!"

@app.route('/add', methods=['POST'])
def add_entry():
    title = request.form['title']
    conn = get_db_connection()
    cur = conn.cursor()
    cur.execute('INSERT INTO entries (title) VALUES (%s)', (title,))
    conn.commit()
    cur.close()
    conn.close()
    return jsonify({"message": "Entry added!"})

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

Important Note:

Before you run this code, you need to create the entries table in your PostgreSQL database.

  1. Switch back to the PostgreSQL user:
sudo -i -u postgres  
psql
  1. Connect to your database:
\c flaskapp
  1. Create the entries table:
CREATE TABLE entries (
    id SERIAL PRIMARY KEY,
    title VARCHAR(255) NOT NULL  
);
\q

By following these steps, you’ve set up the basic structure for your Flask application.

Step 8: Configure PostgreSQL for Flask

At this point, you need to ensure PostgreSQL is configured to accept connections from your Flask application. For local development, the default settings should be sufficient. If you encounter any connection issues, check the pg_hba.conf file for any necessary adjustments.

Step 9: Run Your Flask Application

Now, you’re ready to run your Flask application. Execute the following command:

python app.py

You should see output indicating that the server is running. To access your application, navigate to http://your_server_ip:5000 in your web browser. You will see a welcoming message.

Step 10: Set Up Gunicorn and Nginx

For production deployment, it’s essential to use a WSGI server and a reverse proxy. Here, we will set up Gunicorn and Nginx.

  1. Install Gunicorn:

To install Gunicorn, run:

pip install gunicorn
  1. Test Gunicorn:

Run your application with Gunicorn using the following command:

gunicorn --bind 0.0.0.0:8000 app:app

You can check if it’s working by visiting http://your_server_ip:8000.

  1. Install Nginx:

Now, let’s install Nginx:

sudo apt install nginx -y
  1. Create a new Nginx configuration file for your Flask app:
sudo nano /etc/nginx/sites-available/flaskapp

Add the following configuration:

server {
    listen 80;
    server_name your_domain_or_IP;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Replace your_domain_or_IP with your server’s domain name or IP address.

  1. Enable the Nginx configuration:
sudo ln -s /etc/nginx/sites-available/flaskapp /etc/nginx/sites-enabled
  1. Test the Nginx configuration:
sudo nginx -t
  1. Restart Nginx:
sudo systemctl restart nginx

Now, Nginx serves as a reverse proxy to your Flask application running on Gunicorn.

Step 11: Secure Your Application

Lastly, securing your application is crucial. We will set up HTTPS using Let’s Encrypt.

  1. Install Certbot for SSL:

Install Certbot using the following command:

sudo apt install certbot python3-certbot-nginx -y
  1. Obtain an SSL certificate:

Execute this command to obtain a free SSL certificate:

sudo certbot --nginx -d your_domain

Follow the prompts to complete the SSL setup.

  1. Set up automatic certificate renewal:

To ensure your SSL certificate renews automatically, run:

sudo certbot renew --dry-run

This simulates the renewal process and ensures it works correctly.

Conclusion

You have successfully deployed a Python web application on a Linux VPS using Flask and PostgreSQL. Throughout this tutorial, we covered essential steps such as installing necessary software, creating a sample application, configuring the database, and setting up a production environment with Gunicorn and Nginx.

Next Steps

  • Expand Your Application: Add more routes, implement user authentication, or integrate other services.
  • Monitor Your Application: Use tools like htop or glances to keep an eye on performance metrics.
  • Explore Flask Extensions: Investigate Flask extensions for additional features such as form handling and user authentication.

FAQ

A1: Flask is a lightweight WSGI web application framework in Python. Its popularity stems from its simplicity and flexibility, allowing developers to create web applications quickly without unnecessary complexity.

Q2: Why should I use PostgreSQL over SQLite for a web application?

A2: PostgreSQL is a powerful object-relational database system that excels at handling complex queries and large datasets. Unlike SQLite, which is file-based, PostgreSQL supports concurrent connections and offers advanced features like transactions and foreign keys, making it ideal for production environments.

Q3: How do I deploy my application on cloud platforms like Heroku or AWS?

A3: To deploy on platforms like Heroku, you’ll need to create a requirements.txt file using pip freeze > requirements.txt, define a Procfile, and follow the specific deployment instructions provided by the platform’s documentation.

Q4: What are the best practices for handling errors in Flask?

A4: Flask allows you to use the @app.errorhandler() decorator to handle specific errors and return custom error messages. Additionally, leveraging logging can help you track and resolve issues effectively.

Q5: How can I manage dependencies in my Python projects?

A5: Using a virtual environment with venv is highly recommended for managing project-specific dependencies. You can generate a requirements.txt file to document your dependencies, making it easier to recreate your environment.

Q6: What should I do if I encounter permission issues?

A6: If you experience permission issues, ensure that your web server has the correct permissions to access your application files. Use chown and chmod commands to adjust ownership and permissions appropriately.


This concludes your tutorial on deploying a Python web application on a Linux VPS. If you have any further questions or need assistance, feel free to reach out! Happy coding!

Python Official Website

Index