Deployment - publishing on the internet

Congratulations, @name! Darwin here with the last lesson of Module 5 - deploying a Flask application! 🚀🌐

You've built a functioning Safari Database application with forms, authentication and templates. Now it's time to publish it on the internet so the world can use it! 🌍

Safari Analogy: Deployment is like opening the park to the public - until now the park only operated internally (localhost), now you're opening the gates for tourists from all over the world (internet)! 🦁🌐

Development vs Production

Development (localhost)

✅ `app.run(debug=True)` - development server ✅ Auto-reload after code changes ✅ Detailed errors in the browser ✅ Localhost only - not accessible from the internet ✅ Slow - not optimized

Production (internet)

✅ WSGI server (Gunicorn, uWSGI) ✅ No `debug=True` - security! ✅ Environment variables - SECRET_KEY, DATABASE_URL ✅ Publicly accessible - anyone can visit ✅ Fast - optimized

⚠️ NEVER use `app.run(debug=True)` in production!

WSGI Server - Gunicorn

Gunicorn (Green Unicorn) is a popular WSGI server for Flask/Django applications.

WSGI = Web Server Gateway Interface - a standard for communication between a server and a Python application.

Installation

1pip install gunicorn

Running

1# Basic
2gunicorn app:app
3
4# With port and workers specified
5gunicorn app:app --bind 0.0.0.0:8000 --workers 4
6
7# With reload (dev only)
8gunicorn app:app --reload

Format: `gunicorn <module>:<app_variable>`

• `app` - file name (app.py)
• `app` - Flask variable name (app = Flask(name))

Preparing for deployment

1. requirements.txt file

Save all dependencies:

1pip freeze > requirements.txt

requirements.txt:

1Flask==3.0.0
2Flask-WTF==1.2.1
3Flask-Login==0.6.3
4Werkzeug==3.0.1
5gunicorn==21.2.0

2. Environment variables

NEVER commit SECRET_KEY and sensitive data to git!

Use environment variables:

1# app.py
2import os
3
4app = Flask(__name__)
5
6# Get from environment variables
7app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY') or 'dev-fallback-key'
8app.config['DATABASE_URL'] = os.environ.get('DATABASE_URL') or 'sqlite:///dev.db'
9
10# Debug only in dev
11app.config['DEBUG'] = os.environ.get('FLASK_ENV') == 'development'

3. .gitignore

1# .gitignore
2venv/
3__pycache__/
4*.pyc
5*.pyo
6.env
7instance/
8.DS_Store

4. Procfile (for platforms like Render/Heroku)

1web: gunicorn app:app

Procfile tells the platform how to run your application.

5. runtime.txt (optional)

1python-3.11.0

Specifies the Python version.

Deployment on Render (FREE!)

Render is a modern hosting platform with a free plan. A great alternative to Heroku!

Step 1: Prepare the application

Project structure:

1safari_web/
2├── app.py
3├── models.py
4├── forms.py
5├── requirements.txt
6├── Procfile
7├── .gitignore
8├── templates/
9│   └── ...
10└── static/
11    └── ...

app.py - last lines:

1if __name__ == '__main__':
2    # Only for local development
3    app.run(debug=True)

Render will run via Procfile, so `if name` won't execute!

Step 2: Push to GitHub

1git init
2git add .
3git commit -m "Initial commit - Safari Database"
4git branch -M main
5git remote add origin https://github.com/your-username/safari-web.git
6git push -u origin main

Step 3: Create Web Service on Render

1. Go to https://render.com and register (FREE)

2. Click "New +" → "Web Service"

3. Connect your GitHub repository

4. Select the `safari-web` repository

5. Configuration:

   • Name: safari-database
   • Environment: Python 3
   • Build Command: `pip install -r requirements.txt`
   • Start Command: `gunicorn app:app`
   • Plan: Free

6. Environment Variables - add:

   • `SECRET_KEY` = `your-random-secret-key-here`
   • `FLASK_ENV` = `production`

7. Click "Create Web Service"

Step 4: Deploy!

Render automatically:

• Installs dependencies (`pip install -r requirements.txt`)
• Runs Gunicorn (`gunicorn app:app`)
• Assigns a domain (`https://safari-database.onrender.com`)

Congratulations! Your application is LIVE! 🎉🚀

Deployment on Railway (also FREE!)

Railway is another great platform with a simple setup.

Steps:

1. https://railway.app - register
2. "New Project" → "Deploy from GitHub repo"
3. Select the repository
4. Railway automatically detects Flask!
5. Add Environment Variables:
   • `SECRET_KEY`
   • `FLASK_ENV=production`
6. Railway automatically deploys! ✅

Domain: `https://safari-database.up.railway.app`

Deployment checklist

Before deployment make sure:

Security

• [ ] `DEBUG = False` in production
• [ ] SECRET_KEY as environment variable
• [ ] Passwords hashed (werkzeug.security)
• [ ] CSRF protection enabled (Flask-WTF)
• [ ] .gitignore contains `venv/`, `.env`

Files

• [ ] requirements.txt is up to date
• [ ] Procfile created
• [ ] .gitignore created
• [ ] Static files properly configured

Database

• [ ] In dev: SQLite
• [ ] In prod: PostgreSQL (Render/Railway FREE tier!)
• [ ] DATABASE_URL as environment variable

Testing

• [ ] Application works locally
• [ ] All routes work
• [ ] Forms work
• [ ] Login/registration works

Database in production

SQLite (Development)

1app.config['DATABASE_URL'] = 'sqlite:///safari.db'

Problems: SQLite is not recommended for production (concurrency issues).

PostgreSQL (Production)

Render/Railway offer FREE PostgreSQL!

Render: Add PostgreSQL Database → copy DATABASE_URL

1import os
2
3database_url = os.environ.get('DATABASE_URL')
4
5if database_url and database_url.startswith('postgres://'):
6    # Render uses postgres://, but SQLAlchemy needs postgresql://
7    database_url = database_url.replace('postgres://', 'postgresql://', 1)
8
9app.config['SQLALCHEMY_DATABASE_URI'] = database_url or 'sqlite:///dev.db'

Static files in production

Flask automatically serves files from `static/`, but in production it's better to use a CDN or Nginx.

Basic Flask configuration:

1# app.py
2app = Flask(__name__)
3
4# Flask automatically serves static files from /static/
5# http://yourapp.com/static/css/style.css

In templates:

1<link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
2<script src="{{ url_for('static', filename='js/script.js') }}"></script>

Monitoring and logs

Render Logs

Dashboard → Your Web Service → Logs

Railway Logs

Project → Your Service → Logs

Example logs:

1[2024-01-15 10:23:45] INFO: Starting gunicorn 21.2.0
2[2024-01-15 10:23:45] INFO: Listening at: http://0.0.0.0:10000
3[2024-01-15 10:23:45] INFO: Using worker: sync
4[2024-01-15 10:23:45] INFO: Booting worker with pid: 42

Updating the application

Render/Railway

1. Make code changes locally
2. Commit to git:

   1git add .
   2git commit -m "Update: Add new feature"
   3git push origin main

3. Render/Railway automatically deploys the new version!

Auto-deploy = push to GitHub → automatic deploy! 🚀

Custom domain (optional)

Instead of `safari-database.onrender.com` you can use your own domain:

1. Buy a domain (e.g. `safaridatabase.com`)
2. Render/Railway → Settings → Custom Domain
3. Add a CNAME record at your domain registrar
4. Done! `https://safaridatabase.com` → Your application

Alternative platforms

1. Fly.io

• FREE tier
• Global deployment
• Great documentation

2. PythonAnywhere

• FREE tier for Flask
• Simple setup
• Good for beginners

3. DigitalOcean App Platform

• $5/month
• More control
• Scalable

4. AWS/Google Cloud/Azure

• Advanced
• More expensive
• Full control

Example production-ready app.py

1# app.py
2import os
3from flask import Flask, render_template, redirect, url_for, flash
4from flask_login import LoginManager, login_user, logout_user, login_required, current_user
5from flask_sqlalchemy import SQLAlchemy
6
7app = Flask(__name__)
8
9# Configuration from environment variables
10app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY') or 'dev-key-change-in-production'
11app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL') or 'sqlite:///dev.db'
12app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
13
14# Fix for Render PostgreSQL URL
15if app.config['SQLALCHEMY_DATABASE_URI'].startswith('postgres://'):
16    app.config['SQLALCHEMY_DATABASE_URI'] = app.config['SQLALCHEMY_DATABASE_URI'].replace('postgres://', 'postgresql://', 1)
17
18db = SQLAlchemy(app)
19login_manager = LoginManager(app)
20login_manager.login_view = 'login'
21
22# Models, routes, etc...
23
24if __name__ == '__main__':
25    # Only for local development
26    port = int(os.environ.get('PORT', 5000))
27    app.run(host='0.0.0.0', port=port, debug=os.environ.get('FLASK_ENV') == 'development')

Summary

In this lesson you learned:

• ✅ Difference between development and production
• ✅ WSGI servers (Gunicorn)
• ✅ Preparing applications for deployment
• ✅ Environment variables (SECRET_KEY, DATABASE_URL)
• ✅ Deployment on Render (FREE!)
• ✅ Deployment on Railway (FREE!)
• ✅ Deployment checklist
• ✅ Databases in production (PostgreSQL)
• ✅ Static files in production
• ✅ Monitoring and logs
• ✅ Updating applications (auto-deploy)

Final Safari Analogy: Deployment is like the grand opening of a safari park - you prepared the infrastructure (code), hired staff (WSGI server), secured the park (SECRET_KEY, HTTPS), and opened the gates for tourists from all over the world (internet)! Your Flask application lives and runs 24/7 in the cloud! 🦁🌐🚀

Congratulations on Module 5!

You've built a complete web application with:

• 🎨 Frontend (HTML, CSS, JavaScript)
• 🐍 Backend (Flask)
• 🛤️ Routing and view functions
• 📄 Jinja2 templates
• 📝 Forms with validation (Flask-WTF)
• 🔐 Authentication (Flask-Login)
• 🚀 Deployment on the internet (Render/Railway)

Safari Database is now LIVE and accessible to everyone on the internet! 🎉

Darwin is proud of you! Get ready for the next modules, where you'll learn advanced Python and AI techniques! 🤖🐍