1. Preparing the Application for Deployment
a. Project Structure
Ensure your Django project follows a standard structure:
myproject/
├── myproject/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
├── app/
│ ├── migrations/
│ ├── __init__.py
│ ├── models.py
│ ├── views.py
│ └── serializers.py
├── manage.py
├── requirements.txt
└── Dockerfile
b. Dependencies
Create a requirements.txt file with the following dependencies:
Django==3.2
djangorestframework==3.12.4
gunicorn==20.0.4
psycopg2-binary==2.8.6
boto3==1.17.27
django-storages==1.11.1
c. Dockerfile
Create a Dockerfile to containerize your application:
FROM python:3.8-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
RUN python manage.py collectstatic --noinput
EXPOSE 8000
CMD ["gunicorn", "--workers", "3", "myproject.wsgi:application", "--bind", "0.0.0.0:8000"]
d. GitHub Setup
Create a Repository:
Push Your Code:
Clone the repository to your local machine:
git clone https://github.com/yourusername/yourrepository.git
Add your Django project files to the repository:
cd yourrepository
git add .
git commit -m "Initial commit"
git push origin main
2. Setting Up DigitalOcean for Deployment
Create a New Project:
Deploy a New App:
Go to the App Platform and click "Launch Your App".
Select "GitHub" as your source repository and connect your GitHub account.
Choose the repository and branch (e.g., main) you want to deploy.
b. Configuring Environment Variables
Add Environment Variables:
Go to your App in the App Platform.
Navigate to "Settings" and then "Environment Variables".
Add the following environment variables:
c. Setting Up PostgreSQL
Create a PostgreSQL Database:
Go to the "Databases" section and create a new PostgreSQL database.
Note down the connection details (host, port, username, password, database name).
Configure Django for PostgreSQL:
Update your settings.py:
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': os.getenv('DB_NAME'),
'USER': os.getenv('DB_USER'),
'PASSWORD': os.getenv('DB_PASSWORD'),
'HOST': os.getenv('DB_HOST'),
'PORT': os.getenv('DB_PORT'),
}
}
d. Configuring DigitalOcean Spaces
Create a Space:
Go to the "Spaces" section and create a new Space.
Configure Django to use this Space in settings.py:
DEFAULT_FILE_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'
STATICFILES_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'
AWS_ACCESS_KEY_ID = os.environ.get('AWS_ACCESS_KEY_ID')
AWS_SECRET_ACCESS_KEY = os.environ.get('AWS_SECRET_ACCESS_KEY')
AWS_STORAGE_BUCKET_NAME = os.environ.get('AWS_STORAGE_BUCKET_NAME')
AWS_S3_ENDPOINT_URL = 'https://nyc3.digitaloceanspaces.com'
3. Monitoring and Alerts
a. Setting Up Alerts to Slack
Create a Slack Webhook:
Configure DigitalOcean Alerts:
In your DigitalOcean App Platform project, go to "Monitoring & Alerts".
Create a new alert policy and set it to send alerts to your Slack webhook URL.
Choose the metrics you want to monitor (e.g., CPU usage, memory usage).
b. Monitoring with New Relic
Sign Up for New Relic:
- Go to New Relic's website and sign up for an account.
Install New Relic Agent:
Configure New Relic:
Update Your Command:
Update the CMD in your Dockerfile to include New Relic:
CMD ["newrelic-admin", "run-program", "gunicorn", "--workers", "3", "myproject.wsgi:application", "--bind", "0.0.0.0:8000"]
4. Accessing and Managing the Application
a. Accessing the Database
Direct Access:
- Use a PostgreSQL client like pgAdmin or DBeaver to connect to your database using the provided connection details.
b. SSH Access to the Server
Console Access:
DigitalOcean App Platform doesn't provide direct SSH access to managed app instances.
For tasks like running Celery manually, use the "Console" feature in the DigitalOcean dashboard.
c. Running Celery Tasks Manually
Execute Tasks:
Open the Console from the DigitalOcean App Platform dashboard.
Run Celery tasks manually using Django management commands:
python manage.py shell
from yourapp.tasks import your_task
your_task.delay()
5. Observability and Monitoring
a. Setting Up Observability
DigitalOcean Insights:
Integrate with Sentry:
Sign up for Sentry and configure it in your Django project for error tracking:
import sentry_sdk
from sentry_sdk.integrations.django import DjangoIntegration
sentry_sdk.init(
dsn="YOUR_SENTRY_DSN",
integrations=[DjangoIntegration()],
traces_sample_rate=1.0,
send_default_pii=True
)
a. Managed Infrastructure
Ease of Use: Simplifies the deployment process by managing infrastructure for you.
Scalability: Easily scale applications up or down based on demand without manual intervention.
Built-in Monitoring: Integrated monitoring and alerting tools to keep track of application performance.
b. Comparison to Manual Deployment
Time-Saving: Reduces the time spent on setting up and managing servers.
Reduced Complexity: Avoids the complexity of managing OS-level configurations and dependencies.
Enhanced Security: Ensures the latest security patches and updates are applied automatically.
This detailed guide covers the complete process of deploying a Python-DRF application to DigitalOcean's App Platform, including setup, monitoring, and management. By following these steps, you can ensure a smooth and efficient deployment process for your Django application.
For further help, you can visit me at AhmadWKhan.com
