2.7.4. Proxying traffic to web applications in Python and Go

On the hosting, the ability to proxy HTTP traffic to a local IP address is available, thanks to which you can run applications in Python and Go.

We give you a unique local IP address of the form 127.*.*.*, where * — any number from 0 to 255, and the default port — 3000. You use these values in your application either by specifying them in the run command or directly in the code.

Request processing order:

1. The request goes to the public server on port 80 or 443.
2. Based on the hostname, redirects the application to the local IP address.
3. The application receives the data, processes it, and returns a response.

The real IP address of the visitor is passed in the header X-REAL-IP.

In the presence of dedicated IP you can additionally accept requests for it to any port. This allows one application to receive traffic to the site and at the same time receive another type of traffic on any port of the dedicated IP. You can also run the application without proxying requests to the site - take a port on a dedicated IP and process different connections only on it.

1. V site settings switch «Webserver» on «Traffic proxying» and save the changes:
2. Place your application files on the hosting in the right directory.
3. In chapter «My sites» in the site menu, click «Web application settings».
4. Specify the directory and command to run your application:
   • «Launch directory» — the path to the directory from which your application should be launched. If left blank, it will use site root directory.
   • «Run command» is the command to run your application. In the run command or in the code of the application itself, use the local IP address and port from the block «Proxy HTTP traffic to the application»:
5. Save the changes and test the application:

In the block «Application logs» you can monitor the logs in real time during the launch and operation of the application.

Running Django 4.2 on Python 3.10:

1. In chapter «Linux configuration» install Python version 3.10 and save the changes.
2. Connect to hosting via SSH.
3. Install Django:

   pip install --user Django

4. Change to the subdomain directory where your project files will be located:

   cd example.com/sub

5. Create a new project named project:

   django-admin startproject project .

6. Apply migrations:

   python manage.py migrate

7. Edit your project settings file project/settings.py and in line ALLOWED_HOSTS = [] indicate in square brackets in single quotes your website address 'sub.example.com'.
8. On the web application settings page, specify the launch command:

   python3.10 manage.py runserver 127.*.*.*:3000

   In the team instead of 127.*.*.* and 3000 use the IP address and port from the web application settings page.

9. Save your changes, run the application and test the site.

If successful, the site should display a page with the text «The install worked successfully! Congratulations!».

Running Flask 2.3 on Python 3.10:

1. In chapter «Linux configuration» install Python version 3.10 and save the changes.
2. Connect to hosting via SSH.
3. Change to the subdomain directory where your project files will be located:

   cd example.com/sub

4. Create a Python virtual environment:

   python -m venv .venv

5. Activate the created virtual environment:

   . .venv/bin/activate

6. Install Flask:

   pip install --user Flask

7. Deactivate the virtual environment:

   deactivate

8. Create a file hello.py with content like this (example «A Minimal Application» of official documentation):

   from flask import Flask
    
   app = Flask(__name__)
    
   @app.route("/")
   def hello_world():
       return "<p>Hello, World!</p>"

9. On the web application settings page, specify the launch command:

   python3.10 -m flask --app hello.py run --host 127.*.*.* --port 3000

   In the team instead of 127.*.*.* and 3000 use the IP address and port from the web application settings page.

10. Save your changes, run the application and test the site.

If successful, the site will display the text «Hello, World!».

Running a simple Go 1.20 application:

1. In chapter «Linux configuration» install Go version 1.20 and save the changes.
2. Connect to hosting via SSH.
3. Change to the subdomain directory where your project files will be located:

   cd example.com/sub

4. Create a file simple.go with content like this (example «Introducing the net/http package (an interlude)» of official documentation):

   package main
    
   import (
       "fmt"
       "log"
       "net/http"
   )
    
   func handler(w http.ResponseWriter, r *http.Request) {
       fmt.Fprintf(w, "Hi there, I love %s!", r.URL.Path[1:])
   }
    
   func main() {
       http.HandleFunc("/", handler)
       log.Fatal(http.ListenAndServe("127.*.*.*:3000", nil))
   }

   In line log.Fatal(http.ListenAndServe("127.*.*.*:3000", nil)) insteadof 127.*.*.* and 3000 use the IP address and port from the web application settings page.

5. Compile the generated file:

   go build simple.go

6. Set permissions on the compiled file 750:

   chmod 750 simple

7. On the web application settings page, specify the launch command:

   ./simple

8. Save your changes, run the application and test the site.

If successful, the site should display the text «Hi there, I love!» with the title of the page you are referring to.