How to Setting Up Django on Render & Storages on AWS S3

Deploying a Django application to the cloud can be a significant step towards scalability and reliability. This guide will walk you through a comprehensive process of deploying your Django application to Render, a cloud platform designed to simplify the deployment process. We'll also integrate Amazon S3 for secure and efficient storage of your application's media files, such as images and documents.

Setting the Stage: Preparing Your Django Project

Before we embark on the deployment journey, let's ensure your Django project is properly configured for a seamless transition to the cloud.

1.1: A Comprehensive Dependency List

First, we need to create a requirements.txt file that meticulously lists every dependency your project relies upon. This file acts as a blueprint for installing all necessary packages on the Render platform. We'll also need to include two crucial packages:

• boto3: This is the AWS SDK for Python, enabling interaction with Amazon S3.

• django-storages: This package facilitates seamless integration between Django and AWS S3.

To create your requirements.txt file and install these packages, run these commands in your project's root directory:

pip freeze > requirements.txt
pip install boto3 django-storages
    

1.2: The Procfile - Defining Your Application's Execution

Next, create a Procfile in your project's root directory. This file tells Render how to run your Django application.

      web: gunicorn myproject.wsgi:application
    

Replace myproject with the actual name of your Django project.

1.3: Configuring Django for S3 Media Storage

The core of our S3 integration lies in the settings.py file. Here, we'll modify the settings to ensure media files are stored directly on Amazon S3.

# settings.py

INSTALLED_APPS += ['storages']

# AWS S3 Configuration
AWS_ACCESS_KEY_ID = os.getenv('AWS_ACCESS_KEY_ID')
AWS_SECRET_ACCESS_KEY = os.getenv('AWS_SECRET_ACCESS_KEY')
AWS_STORAGE_BUCKET_NAME = os.getenv('AWS_STORAGE_BUCKET_NAME')
AWS_S3_REGION_NAME = os.getenv('AWS_S3_REGION_NAME')
AWS_S3_CUSTOM_DOMAIN = f'{AWS_STORAGE_BUCKET_NAME}.s3.amazonaws.com'

# Media files will be stored on S3
DEFAULT_FILE_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'
MEDIA_URL = f'https://{AWS_S3_CUSTOM_DOMAIN}/media/'

# Optional: Configure static files to be served from S3
STATICFILES_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'
STATIC_URL = f'https://{AWS_S3_CUSTOM_DOMAIN}/static/'
    

This configuration ensures that any media files uploaded through your Django application (like profile pictures or product images) will be directly stored in your designated Amazon S3 bucket.

1.4: Access Control - Defining Allowed Hosts

In your settings.py, locate the ALLOWED_HOSTS setting and add the URL of your Render service to this list. This is crucial for security and ensures that your application can only be accessed through the appropriate channels.

      ALLOWED_HOSTS = ['your-django-backend-url.onrender.com']
    

Replace your-django-backend-url.onrender.com with the actual URL assigned to your Django application on Render.

1.5: Database Configuration - Connecting to PostgreSQL on Render

If your Django application uses a PostgreSQL database, we need to configure it to connect to the PostgreSQL database provided by Render.

import dj_database_url

DATABASES = {
'default': dj_database_url.config(conn_max_age=600)
}
    

Make sure to include dj-database-url in your requirements.txt file.

1.6: Security in Production - Hardening Your Settings

To ensure the security of your production environment, we need to take these steps:

• Disable Debug Mode: Set DEBUG = False in your settings.py.

• Secure Settings: Enable and configure settings like SECURE_SSL_REDIRECT, CSRF_COOKIE_SECURE, and SESSION_COOKIE_SECURE in your settings.py.

• Environment Variables for Secrets: Use environment variables to store sensitive information like your DJANGO_SECRET_KEY and other potentially sensitive values.

Render: Your Deployment Platform

With your Django project meticulously prepared, let's move on to the deployment process using Render, a cloud platform that simplifies the deployment process.

Step 2: The Render Configuration File - render.yaml

Create a file named render.yaml in your project's root directory. This file serves as a configuration file for Render, defining the essential settings for your application's deployment.

services:
  - type: web
    name: my-django-app
    env: python
    buildCommand: pip install -r requirements.txt
    startCommand: gunicorn myproject.wsgi:application
    envVars:
      - key: DATABASE_URL
        fromDatabase:
          name: my-database
      - key: AWS_ACCESS_KEY_ID
        sync: false
      - key: AWS_SECRET_ACCESS_KEY
        sync: false
      - key: AWS_STORAGE_BUCKET_NAME
        sync: false
      - key: AWS_S3_REGION_NAME
        sync: false
      - key: DJANGO_SECRET_KEY
        sync: false
      - key: ALLOWED_HOSTS
        value: 'your-django-backend-url.onrender.com'
    

Explanation:

• type: web: Indicates that this service is a web application.

• name: my-django-app: Defines the name of your service (customize this to your preference).

• env: python: Specifies that your application uses Python.

• buildCommand: pip install -r requirements.txt: This command instructs Render to install the packages listed in your requirements.txt file.

• startCommand: gunicorn myproject.wsgi:application: This command tells Render how to run your Django application using Gunicorn.

• envVars: This section defines your environment variables, crucial for configuring sensitive information like your database credentials and AWS access keys.

  • DATABASE_URL: This variable will be automatically generated by Render if you created a PostgreSQL database.

  • AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_STORAGE_BUCKET_NAME, AWS_S3_REGION_NAME, DJANGO_SECRET_KEY: These are crucial environment variables for interacting with S3 and securing your Django application. These are marked as sync: false, meaning you'll set them manually in Render.

  • ALLOWED_HOSTS: This variable defines the allowed hosts, and we'll use the URL generated by Render.

Amazon S3: Storing Your Media Files in the Cloud

Now, we'll set up Amazon S3 to securely and efficiently store the media files of your Django application.

Step 3: Creating Your S3 Bucket

1. Log in to your AWS Management Console: Navigate to the AWS website and log in using your AWS credentials.

2. Create an S3 Bucket: Access the Amazon S3 service in the console, and click on "Create bucket."

3. Provide a Unique Name: Give your bucket a unique name. This will serve as the primary identifier for your S3 bucket.

4. Region Selection: Choose the geographical region where you want to store your bucket.

5. Permissions: Configure the permissions for your bucket. For this setup, you'll need to allow read permissions for the objects within your bucket.

Step 3.2: Granting Access with an IAM User

1. IAM User Creation: Go to the IAM service in the AWS console and create a new user. This user will be solely responsible for interacting with your S3 bucket.

2. Assign Permissions: You have two options:

   • AmazonS3FullAccess: Grants full access to your S3 bucket, but it's recommended to restrict permissions for enhanced security.

   • Custom Policy: Create a custom IAM policy that grants only the necessary permissions for your Django application to access your S3 bucket.

3. Access Keys Generation: Generate access keys for this new IAM user. These keys (AWS Access Key ID and AWS Secret Access Key) will be used to set up your environment variables in Render, enabling your Django application to access your S3 bucket.

Bringing It All Together: Deployment and Beyond

With your project prepared, your S3 bucket configured, and Render ready to host your application, let's proceed with the deployment process.

Step 4: Version Control - Putting Your Project on GitHub

1. Git Initialization: Navigate to the root directory of your Django project and initialize a Git repository using:

      git init
    

1. Add Your Files: Stage all your files for tracking using:

      git add .
    

1. Commit Your Changes: Commit your initial changes with a descriptive message:

      git commit -m "Initial commit for Render deployment"
    

1. GitHub Connection: Add a remote repository on GitHub:

      git remote add origin https://github.com/yourusername/your-repo-name.git
    

Replace yourusername and your-repo-name with your actual GitHub username and repository name.

1. Push to GitHub: Finally, push your local changes to the remote GitHub repository:

      git push -u origin master
    

Step 5: Deployment on Render

1. Create a New Web Service: Visit the Render dashboard, click "New," and select "Web Service."

2. Connect Your GitHub Repository: Connect your newly created GitHub repository with Render.

3. Branch Selection: Select the branch you want to deploy (usually master or main).

4. Configuration: Render will automatically detect your render.yaml file and configure your service.

5. Environment Variables: Navigate to the "Environment" tab in your Render service settings. Here, you need to configure your environment variables.

   • DATABASE_URL: If you created a PostgreSQL database, this variable will be generated by Render.

   • AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_STORAGE_BUCKET_NAME, AWS_S3_REGION_NAME, DJANGO_SECRET_KEY: Enter the values you obtained from your IAM user credentials and the AWS console (refer to Section 3.2).

   • ALLOWED_HOSTS: Enter the URL that Render assigns to your deployed Django application.

6. Create Your Web Service: Click "Create Web Service." Render will build and deploy your Django application. Monitor the logs for any potential issues.

Step 6: Post-Deployment - Running Migrations and Testing

1. Running Database Migrations: After your service is deployed, log in to the Render service shell (you can access this from the Render dashboard). Once you are in the shell, run the following command:

      python manage.py migrate
    

1. Media File Uploads: Test uploading images or media files through your Django application. Ensure that these files are being correctly stored in your S3 bucket and that you can access them via the generated URLs.

Conclusion

This comprehensive guide has equipped you with the knowledge and steps required to deploy your Django application to Render, efficiently storing media files on Amazon S3. By leveraging Render and S3, you've gained the tools to scale your application, manage your media files effectively, and enhance security for your production environment.