Cloud Deployment - Relaciona

Overview

Relaciona supports multiple deployment platforms. This guide covers AWS Elastic Beanstalk, Vercel, Render, and Docker-based deployments.

AWS Elastic Beanstalk

Elastic Beanstalk provides easy deployment with Docker support. The free tier is available for eligible accounts.

Prerequisites

AWS account (aws.amazon.com)
EB CLI installed (optional but recommended)

pip install awsebcli

Deployment Files

Relaciona includes the following EB configuration: Dockerfile:

FROM python:3.11-slim
ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1
WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc libpq-dev python3-dev \
    && apt-get clean && rm -rf /var/lib/apt/lists/*

COPY requirements.txt /app/
RUN pip install --no-cache-dir -r requirements.txt

COPY . /app/
RUN python manage.py collectstatic --no-input

EXPOSE 8000
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "relaciona.wsgi:application"]

Dockerrun.aws.json:

{
    "AWSEBDockerrunVersion": "1",
    "Ports": [
        {
            "ContainerPort": 8000,
            "HostPort": 80
        }
    ]
}

Option 1: Web Console Deployment

Prepare Application

Create a ZIP file containing all project files:

zip -r relaciona.zip . -x "*.git*" -x "*__pycache__*" -x "*.pyc" -x "venv/*" -x ".env"

Create Application

Navigate to Elastic Beanstalk in AWS Console
Click Create Application
Application name: relaciona-app
Platform: Docker
Platform branch: Docker running on 64bit Amazon Linux 2023
Application code: Upload relaciona.zip

Configure Environment

Choose Configuration presets: Single instance (free tier eligible)
Click Next

Set Environment Variables

In Configure service access → Environment properties, add:

SECRET_KEY=your-generated-secret-key
DEBUG=False

# Database (RDS or external)
DB_NAME=postgres
DB_USER=your_db_user
DB_PASSWORD=your_db_password
DB_HOST=your-rds-endpoint.rds.amazonaws.com
DB_PORT=5432

# Cloudinary
CLOUDINARY_CLOUD_NAME=your-cloud-name
CLOUDINARY_API_KEY=your-api-key
CLOUDINARY_API_SECRET=your-api-secret

Launch

Click Create application and wait 5-10 minutes for deployment.Your app will be available at:

http://relaciona-env.eba-xxxxxxx.region.elasticbeanstalk.com

Option 2: EB CLI Deployment

Initialize EB

eb init -p docker relaciona-app --region eu-west-3

Follow prompts to:

Select region
Set up AWS credentials (if not configured)

Create Environment

eb create relaciona-env --single --instance-type t3.micro

This creates a single-instance environment (free tier eligible).

Set Environment Variables

eb setenv \
  SECRET_KEY="your-secret-key" \
  DEBUG="False" \
  DB_NAME="postgres" \
  DB_USER="your_user" \
  DB_PASSWORD="your_password" \
  DB_HOST="your-rds-endpoint.rds.amazonaws.com" \
  DB_PORT="5432" \
  CLOUDINARY_CLOUD_NAME="your-cloud" \
  CLOUDINARY_API_KEY="your-key" \
  CLOUDINARY_API_SECRET="your-secret"

Open Application

eb open

Database Setup with RDS

EB instances have ephemeral storage. Use AWS RDS for persistent database storage.

See the Database Setup guide for creating an RDS PostgreSQL instance. Key points:

Use db.t3.micro for free tier
Enable public access if connecting from outside AWS
Configure security groups to allow EB → RDS connections
Set RDS endpoint as DB_HOST environment variable

Running Migrations on EB

After deployment, SSH into your instance to run migrations:

eb ssh

# Inside the instance
docker exec -it $(docker ps -q) python manage.py migrate
docker exec -it $(docker ps -q) python manage.py createsuperuser

Or add migrations to your Dockerfile:

CMD python manage.py migrate && gunicorn --bind 0.0.0.0:8000 relaciona.wsgi:application

Updates and Redeployment

# Deploy updates
eb deploy

# View logs
eb logs

# Check status
eb status

# Terminate environment (when done)
eb terminate relaciona-env

Vercel Deployment

Vercel provides serverless deployment for Python applications.

Configuration

vercel.json:

{
    "builds": [
        {
            "src": "relaciona/wsgi.py",
            "use": "@vercel/python",
            "config": {
                "maxLambdaSize": "15mb",
                "runtime": "python3.12"
            }
        }
    ],
    "routes": [
        {
            "src": "/(.*)",
            "dest": "relaciona/wsgi.py"
        }
    ]
}

Deployment Steps

Install Vercel CLI

npm install -g vercel

vercel login

Deploy

vercel

Follow prompts:

Link to existing project or create new
Confirm settings

Set Environment Variables

In Vercel dashboard:

Go to Project Settings → Environment Variables
Add all required variables:
- SECRET_KEY
- DEBUG=False
- Database credentials
- Cloudinary credentials
Set scope: Production, Preview, Development

Add CSRF Origins

Update settings.py to include your Vercel domain:

CSRF_TRUSTED_ORIGINS = [
    'https://*.vercel.app',
    'https://your-project.vercel.app',
]

Vercel Limitations

Important Vercel constraints:

Serverless functions have 10-60s timeout
Database connections should use connection pooling
No built-in database (use external PostgreSQL)
Static files must be served from Cloudinary/CDN
Limited to stateless operations

Production Deployment

vercel --prod

Render Deployment

Render provides simple deployment with managed databases.

Configuration

render.yaml:

services:
  - type: web
    name: relaciona-app
    env: python
    buildCommand: ./build.sh
    startCommand: gunicorn relaciona.wsgi:application
    envVars:
      - key: DJANGO_SETTINGS_MODULE
        value: relaciona.settings
      - key: PYTHON_VERSION
        value: 3.11

build.sh:

#!/usr/bin/env bash
set -o errexit

pip install -r requirements.txt
python manage.py collectstatic --no-input
python manage.py migrate

Why build.sh includes migrate

Render automatically runs build.sh on each deployment, making it ideal for running migrations. This ensures your database schema is always up-to-date.

Deployment Steps

Create Render Account

Create PostgreSQL Database

Click New + → PostgreSQL
Name: relaciona-db
Plan: Free
Click Create Database
Note the Internal Database URL

Create Web Service

Click New + → Web Service
Connect your Git repository
Name: relaciona-app
Environment: Python 3
Build Command: ./build.sh
Start Command: gunicorn relaciona.wsgi:application

Set Environment Variables

Add in Environment tab:

SECRET_KEY=your-secret-key
DEBUG=False

# Use Internal Database URL from your Render PostgreSQL
DB_NAME=relaciona_db_xxxx
DB_USER=relaciona_db_xxxx_user
DB_PASSWORD=generated_password
DB_HOST=dpg-xxxx.oregon-postgres.render.com
DB_PORT=5432

# Cloudinary
CLOUDINARY_CLOUD_NAME=your-cloud
CLOUDINARY_API_KEY=your-key
CLOUDINARY_API_SECRET=your-secret

# Python version
PYTHON_VERSION=3.11

Deploy

Click Create Web Service. Render automatically:

Builds your application
Runs migrations (via build.sh)
Starts the server

Render Features

Auto-deploy: Pushes to GitHub automatically trigger deployments
Free SSL: HTTPS enabled by default
Managed PostgreSQL: Automatic backups on paid plans
Zero-downtime deploys: On paid plans

Docker Deployment

Deploy using Docker on any platform that supports containers.

Build Image

docker build -t relaciona:latest .

Run Container

docker run -d \
  -p 8000:8000 \
  -e SECRET_KEY="your-secret-key" \
  -e DEBUG="False" \
  -e DB_NAME="postgres" \
  -e DB_USER="your_user" \
  -e DB_PASSWORD="your_password" \
  -e DB_HOST="your-db-host" \
  -e DB_PORT="5432" \
  -e CLOUDINARY_CLOUD_NAME="your-cloud" \
  -e CLOUDINARY_API_KEY="your-key" \
  -e CLOUDINARY_API_SECRET="your-secret" \
  --name relaciona \
  relaciona:latest

Using docker-compose

Create docker-compose.yml:

version: '3.8'

services:
  web:
    build: .
    ports:
      - "8000:8000"
    environment:
      - SECRET_KEY=${SECRET_KEY}
      - DEBUG=False
      - DB_NAME=postgres
      - DB_USER=postgres
      - DB_PASSWORD=postgres
      - DB_HOST=db
      - DB_PORT=5432
    depends_on:
      - db
    command: >
      sh -c "python manage.py migrate &&
             python manage.py collectstatic --no-input &&
             gunicorn --bind 0.0.0.0:8000 relaciona.wsgi:application"
  
  db:
    image: postgres:15
    environment:
      - POSTGRES_DB=postgres
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

Run with:

docker-compose up -d

Docker Hub Deployment

# Tag image
docker tag relaciona:latest yourusername/relaciona:latest

# Login to Docker Hub
docker login

# Push image
docker push yourusername/relaciona:latest

Deploy on any platform:

docker pull yourusername/relaciona:latest
docker run -d -p 8000:8000 --env-file .env yourusername/relaciona:latest

Static Files Serving

Relaciona uses WhiteNoise for static files, which works out-of-the-box on all platforms:

settings.py

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'whitenoise.middleware.WhiteNoiseMiddleware',  # Serves static files
    # ...
]

STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'

Static files are collected during build:

python manage.py collectstatic --no-input

Media Files with Cloudinary

All user uploads are stored on Cloudinary, ensuring files persist across deployments:

Create Cloudinary Account

Get Credentials

Dashboard → Account Details:

Cloud Name
API Key
API Secret

Set Environment Variables

On your deployment platform:

CLOUDINARY_CLOUD_NAME=your-cloud-name
CLOUDINARY_API_KEY=123456789012345
CLOUDINARY_API_SECRET=your-secret

SSL/HTTPS Configuration

AWS Elastic Beanstalk

Use AWS Certificate Manager (ACM) and Application Load Balancer:

Request SSL certificate in ACM
Configure Load Balancer with HTTPS listener
Update settings.py:

SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
SECURE_SSL_REDIRECT = True

Vercel & Render

Automatic HTTPS - no configuration needed!

Post-Deployment Checklist

Verify Environment Variables

Ensure all required variables are set correctly.

Run Migrations

python manage.py migrate

Create Superuser

python manage.py createsuperuser

Test Application

Access homepage
Test login/registration
Upload media file (test Cloudinary)
Access admin panel

Update CSRF Origins

Add your production domain to CSRF_TRUSTED_ORIGINS in settings.py

Monitor Logs

Check application logs for errors:

AWS EB: eb logs
Vercel: Dashboard → Deployments → View logs
Render: Dashboard → Logs tab
Docker: docker logs relaciona

Troubleshooting

Static files not loading

Solution:

Run python manage.py collectstatic --no-input
Verify WhiteNoise is in MIDDLEWARE (after SecurityMiddleware)
Check STATIC_ROOT and STATICFILES_STORAGE settings
Ensure build process includes collectstatic

Database connection errors

Solution:

Verify all DB_* environment variables are set correctly
Check database host is accessible (security groups, firewall)
Confirm PostgreSQL is running
Test connection: python manage.py dbshell
For cloud databases, ensure IP whitelist includes your platform

500 Internal Server Error

Solution:

Set DEBUG=True temporarily to see detailed error
Check application logs
Verify SECRET_KEY is set
Ensure migrations are up to date
Check ALLOWED_HOSTS includes your domain

Media uploads failing

Solution:

Verify Cloudinary credentials are correct
Check CLOUDINARY_* environment variables

Test Cloudinary connection in Django shell:

from django.core.files.storage import default_storage
print(default_storage.__class__)

Ensure Cloudinary is in INSTALLED_APPS

CSRF verification failed

Solution:

Add your domain to CSRF_TRUSTED_ORIGINS:

CSRF_TRUSTED_ORIGINS = [
    'https://yourdomain.com',
    'https://*.vercel.app',
]

For localhost development, ensure domain includes port:
```
CSRF_TRUSTED_ORIGINS = ['http://localhost:8000']
```

Next Steps

Environment Variables

Reference for all environment variables

Database Setup

PostgreSQL configuration and management

Configuration

Django settings reference

Setup

​Overview

​AWS Elastic Beanstalk

​Prerequisites

​Deployment Files

​Option 1: Web Console Deployment

​Option 2: EB CLI Deployment

​Database Setup with RDS

​Running Migrations on EB

​Updates and Redeployment

​Vercel Deployment

​Configuration

​Deployment Steps

​Vercel Limitations

​Production Deployment

​Render Deployment

​Configuration

​Deployment Steps

​Render Features

​Docker Deployment

​Build Image

​Run Container

​Using docker-compose

​Docker Hub Deployment

​Static Files Serving

​Media Files with Cloudinary

​SSL/HTTPS Configuration

​AWS Elastic Beanstalk

​Vercel & Render

​Post-Deployment Checklist

​Troubleshooting

​Next Steps

Environment Variables

Database Setup

Configuration

Build docs developers (and LLMs) love

Overview

AWS Elastic Beanstalk

Prerequisites

Deployment Files

Option 1: Web Console Deployment

Option 2: EB CLI Deployment

Database Setup with RDS

Running Migrations on EB

Updates and Redeployment

Vercel Deployment

Configuration

Deployment Steps

Vercel Limitations

Production Deployment

Render Deployment

Configuration

Deployment Steps

Render Features

Docker Deployment

Build Image

Run Container

Using docker-compose

Docker Hub Deployment

Static Files Serving

Media Files with Cloudinary

SSL/HTTPS Configuration

AWS Elastic Beanstalk

Vercel & Render

Post-Deployment Checklist

Troubleshooting

Next Steps