Web Server + Gunicorn

In web development, a 'Web Server' (like Nginx or Apache) and 'Gunicorn' (Green Unicorn) are often used together to efficiently serve Python web applications. This combination leverages the strengths of both technologies.

1. Web Server (e.g., Nginx, Apache):
A web server is a high-performance software application designed to serve static content (HTML, CSS, JavaScript, images) and act as a reverse proxy, load balancer, and SSL/TLS terminator. It's exceptionally good at handling numerous concurrent connections, but it's not designed to directly execute dynamic application code, especially in Python.
- Key Roles: Serving static files, reverse proxying requests, load balancing across multiple application instances, handling SSL/TLS encryption, caching, and basic security measures.

2. Gunicorn (Green Unicorn):
Gunicorn is a Python WSGI HTTP server for UNIX. It's a pre-fork worker model, simple to use, and provides a robust way to run Python web applications. Gunicorn's primary role is to execute your Python web application code (which adheres to the WSGI specification) and translate incoming HTTP requests into WSGI calls for your application to process. It then takes the application's response and converts it back into an HTTP response.
- Key Roles: Running the Python application code, managing worker processes, handling the WSGI interface.

Why use them together?
Using a web server like Nginx in front of Gunicorn creates a powerful and robust deployment architecture:
- Performance & Efficiency: Nginx excels at handling static files and raw TCP connections, offloading this work from Gunicorn. Gunicorn can then focus solely on executing Python code, which is more CPU-intensive.
- Reverse Proxy: Nginx acts as an intermediary, forwarding HTTP requests from clients to Gunicorn. This decouples the client from the application server, allowing for greater flexibility and security.
- Load Balancing: Nginx can distribute incoming requests among multiple Gunicorn instances, improving application scalability, fault tolerance, and availability.
- SSL Termination: Nginx can handle SSL/TLS encryption and decryption, freeing Gunicorn from this computationally intensive task and simplifying application code.
- Static File Serving: Nginx can directly serve static files (e.g., `images/logo.png`) without ever touching Gunicorn, significantly speeding up content delivery.
- Security & Caching: Nginx adds an extra layer of security and can be configured for caching to further improve response times.

Typical Flow:
Client's Web Browser --> (Internet) --> Nginx (Web Server) --> Gunicorn (WSGI Server) --> Python Web Application (e.g., Flask, Django)

 Part 1: A simple Flask application (app.py)
 This application will be run by Gunicorn.
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello from Gunicorn served by Nginx!'

@app.route('/static')
def static_page():
     In a real app, this would be served by Nginx directly
    return 'This is a dynamic page. Static files like images should be served by Nginx.'

if __name__ == '__main__':
    app.run(debug=True)


 Part 2: How to run this application with Gunicorn
 First, install Flask and Gunicorn:
 pip install Flask gunicorn

 Then, run Gunicorn from your terminal in the directory where app.py is located:
 gunicorn --workers 4 --bind 0.0.0.0:8000 app:app

 Explanation of the Gunicorn command:
 --workers 4       : Gunicorn will run 4 worker processes to handle requests.
 --bind 0.0.0.0:8000 : Gunicorn will listen on all network interfaces on port 8000.
 app:app           : This tells Gunicorn to find the WSGI application named 'app'
                     inside the Python module 'app.py'.


 Part 3: Example Nginx configuration to proxy requests to Gunicorn
 This configuration snippet would typically be placed in a file like
 /etc/nginx/sites-available/my_app and symlinked to /etc/nginx/sites-enabled/

 Note: This assumes Gunicorn is running on the same server on port 8000.
 If Gunicorn is on a different server, replace 127.0.0.1 with its IP address.

server {
    listen 80;
    server_name your_domain.com www.your_domain.com;

     Serve static files directly
     In a real Flask app, static files are usually in 'static/' directory
     For this example, let's assume a 'web_root/static' directory for simplicity.
     Make sure this path exists on your server.
    location /static/ {
        root /var/www/my_app/web_root;  Adjust this to your static files directory
        expires 30d;
        add_header Cache-Control "public, no-transform";
    }

     Proxy requests for the Python application to Gunicorn
    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;
        proxy_redirect off;
    }

     You can add SSL configuration here for HTTPS
     listen 443 ssl;
     ssl_certificate /etc/nginx/ssl/your_domain.crt;
     ssl_certificate_key /etc/nginx/ssl/your_domain.key;
}

 After modifying Nginx configuration, you need to test it and reload Nginx:
 sudo nginx -t
 sudo systemctl reload nginx