Developing and Deploying Python Applications on DomainIndia.com VPS

A Python web application needs more than python app.py to run in production: something to serve it reliably, something to restart it when it crashes, and a web server in front to handle HTTPS. This guide walks through deploying a Flask, Django or FastAPI application on a Domain India VPS, from a fresh server to a live site with SSL, and shows how to keep it updated afterwards.

1. First, pick the right place to run it

A VPS is the most flexible option, but not the only one. Choose by how much server work you want to do.

On shared hosting, Python apps run through the panel's Setup Python App tool; see deploying a Python app on shared hosting. On the App Platform, only Node.js is detected automatically, so a Python app deploys from your own Dockerfile; see getting started with the App Platform. The rest of this guide covers the VPS route.

2. Get the application ready for production

Before you touch the server, make the app deployable:

• Pin your dependencies. Keep a requirements.txt (or a lock file from your tool of choice) with exact versions, so the server installs what you tested.
• Move settings into environment variables. Database passwords, secret keys and API tokens belong in an environment file on the server, never in your Git repository.
• Turn off debug mode. Set DEBUG = False in Django and never run Flask's debugger in production. Debug pages leak code and settings.
• Know your entry point. Flask usually exposes app in a module such as wsgi.py; Django has project/wsgi.py; FastAPI exposes an ASGI app.
• Add a health check. A simple /health route that returns 200 makes monitoring easy.

3. Prepare the VPS

Start with a current long-term-support release. Ubuntu 24.04 LTS ships Python 3.12; AlmaLinux and Rocky Linux 9 ship an older default Python, with newer versions available as separate packages. Use SSH keys to log in; see how to access your VPS using SSH.

On Ubuntu 24.04:

sudo apt update && sudo apt upgrade -y
sudo apt install -y python3 python3-venv python3-pip nginx git
sudo ufw allow OpenSSH
sudo ufw allow 'Nginx Full'
sudo ufw enable

On AlmaLinux or Rocky Linux 9:

sudo dnf update -y
sudo dnf install -y python3.12 python3.12-pip nginx git
sudo firewall-cmd --permanent --add-service=http --add-service=https
sudo firewall-cmd --reload
sudo setsebool -P httpd_can_network_connect 1   # let nginx proxy to your app under SELinux

Create a dedicated user and folder for the app, so it never runs as root:

sudo useradd --system --create-home --shell /bin/bash myapp
sudo mkdir -p /srv/myapp
sudo chown myapp:myapp /srv/myapp

For the wider hardening checklist, see essential security and optimisation tips for your VPS.

4. Copy the code and install dependencies

Git is the cleanest way to get code onto the server, because updates become a git pull. Use a read-only deploy key for a private repository.

sudo -iu myapp
cd /srv/myapp
git clone https://github.com/you/yourapp.git app
cd app
python3 -m venv .venv            # use python3.12 on AlmaLinux/Rocky
source .venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt gunicorn

For an async framework such as FastAPI, also install uvicorn. Create /srv/myapp/app/.env with your settings and make it readable only by the app user (chmod 600 .env). If you use Django, run python manage.py migrate and python manage.py collectstatic now.

Test the app before going further:

gunicorn --bind 127.0.0.1:8000 wsgi:app

Replace wsgi:app with your module and object, for example myproject.wsgi:application for Django. For FastAPI, add -k uvicorn.workers.UvicornWorker and point it at your ASGI app. Press Ctrl+C once it answers on curl http://127.0.0.1:8000/health.

5. Keep it running with systemd

systemd starts the app at boot and restarts it if it crashes. Create /etc/systemd/system/myapp.service as root:

[Unit]
Description=My Python app
After=network.target

[Service]
User=myapp
Group=myapp
WorkingDirectory=/srv/myapp/app
EnvironmentFile=/srv/myapp/app/.env
ExecStart=/srv/myapp/app/.venv/bin/gunicorn --workers 3 --bind 127.0.0.1:8000 wsgi:app
Restart=on-failure

[Install]
WantedBy=multi-user.target

Then enable and start it:

sudo systemctl daemon-reload
sudo systemctl enable --now myapp
sudo systemctl status myapp

A common starting point is two to four workers per CPU core; watch memory use and adjust. Background jobs (Celery, RQ or a scheduler) get their own service files in the same way.

6. Put nginx in front and add HTTPS

nginx receives visitors on ports 80 and 443, serves static files directly and passes everything else to Gunicorn. Create a site file (on Ubuntu in /etc/nginx/sites-available/myapp, then link it into sites-enabled; on AlmaLinux or Rocky in /etc/nginx/conf.d/myapp.conf):

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

    location /static/ {
        alias /srv/myapp/app/static/;
    }

    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;
    }
}

Test and reload with sudo nginx -t && sudo systemctl reload nginx. Point your domain's A record at the VPS IP address, wait for DNS to update, then get a free certificate:

sudo apt install -y certbot python3-certbot-nginx     # Ubuntu
sudo certbot --nginx -d example.com -d www.example.com

On AlmaLinux or Rocky, install certbot and python3-certbot-nginx from the EPEL repository. Certbot sets up automatic renewal.

7. Update, monitor and back up

For a complete FastAPI example with PostgreSQL and zero-downtime reloads, see FastAPI production deployment. For Django-specific settings, see the Django production deployment checklist.

8. Where Domain India fits

A Domain India VPS gives you root access on KVM virtualisation, and it is self-managed: you install and look after the software yourself. cPanel is not offered on our VPS plans. For start, stop, force restart, reinstall or console access, open a ticket and support will do it; you can reboot a healthy server yourself over SSH. See managing your VPS.

The cards show live Domain India list prices, excluding 18% GST. A small Flask or FastAPI API runs comfortably on an entry plan; add memory if you run background workers, a database and the app on the same server.

Frequently asked questions

Ready to deploy? Compare VPS plans, try the App Platform for a container-based app, or open a support ticket if you are not sure which fits your project.