Search for a command to run...
This article walks you through the process of hosting a Dockerized Django application on GCP.
Adesegun Adebayo is a Senior Software Engineer based in Lagos, Nigeria. He loves exploring technologies and writing about stuff he does. When he’s not geeking around, he’s watching anime or catching up with his favourite manga.
No comments yet. Be the first to comment.
In this article, we’ll learn how to build APIs for a library management system using the Django REST Framework and document the APIs with swagger
Recently, I was trying to work on a jQuery datatable where the profile pictures of users were to be displayed on the table and I discovered that the images uploaded were quite heavy, ranging between 3 to 5 megabytes, that's quite large! However, the ...
This article shows you how to easily Dockerize and host a Django application on Google Cloud Platform, using Cloud Run — a fully managed serverless platform to develop and deploy highly scalable containerized applications.
The main components of the pipeline are:
The CI/CD pipeline setup listens for changes pushed or merged to the repository's main branch on GitHub through a trigger defined on Cloud Build.
In order to follow along, you'll need to set up a google account and then create a project on GCP, google has an article you can read through if you need any help with that process and also understand the requirements and benefits of having a GCP account.
GCP allows you the flexibility of enabling cloud APIs that suits your development needs, these APIs allows communication with google services and their integration with other services. For example, enabling the Cloud Build API allows us to connect and create build triggers to GitHub for the CI/CD pipeline.
Note: you'll be required to have set up a billing account to enable the APIs
For the purpose of what we want to achieve, we'll be enabling the:
You can clone the sample repository I created for the purpose of this article from GitHub .
One important lesson I learned the hard way was how to properly structure your application for GCP. the screenshot below is from Docker Desktop, and I had this error popping up anytime I ran the docker container and it sure took a while to figure out that the issue I had was just with the folder structure 😒.
The image below shows that the Dockerfile must be in the same directory as the manage.py and requirements.txt file or in the case where you use an app.yaml file, it has to be in the same directory as manage.py also.
Here's the Dockerfile that runs our application:
# Use an official lightweight Python image.
# https://hub.docker.com/_/python
FROM python:3.9-slim
ENV APP_HOME /app
WORKDIR $APP_HOME
RUN apt-get update \
&& apt-get upgrade \
&& apt-get install -y nginx \
&& apt-get install -y supervisor
# Install dependencies.
COPY requirements.txt .
RUN pip install -U pip && pip install -r requirements.txt
# Copy local code to the container image.
COPY . .
# Service must listen to $PORT environment variable.
# This default value facilitates local development.
ENV PORT 8000
# Setting this ensures print statements and log messages
# promptly appear in Cloud Logging.
ENV PYTHONUNBUFFERED TRUE
# Run the web service on container startup. Here we use the gunicorn
# webserver, with one worker process and 8 threads.
# For environments with multiple CPU cores, increase the number of workers
# to be equal to the cores available.
CMD exec gunicorn --bind 0.0.0.0:$PORT --workers 3 --threads 8 --timeout 120 --preload dockerized_django_app.wsgi
Now that we have been able to prepare our repository and also enable the Cloud Build and Cloud Run APIs. The next step is creating a Cloud Run service by navigating to the service page.
From the image above, ensure you select the "Continuously deploy new revisions from a source repository" to set up the Cloud Build trigger that connects your GitHub repository and sets a trigger to build a new image anytime there's a push to the main branch.
Authenticate and select your repository, then click connect
We see here that the repository has been selected and the trigger is set to listen on the main branch.
In the configuration section, we specify the directory for cloud build to pick up the Dockerfle, and the name of the docker file. You'll also notice that Cloud Build automatically named the docker image.
In the authentication section, select "Allow unauthenticated invocations" to allow access to your application over the internet.
Having filled in the right details, we can then click on create which setups the expected trigger and we can monitor the build under the build history of the Cloud Build service page.
Once, the build has succeeded, you can access the application using the URL generated from Cloud Run.
Awesome, our docker container runs successfully on App URL
Glad you got to the end of this! ✌️
Let me know if you have any questions in the comment section. 😁