7/7/2020 How to use PostgreSQL with Django | EDB
Postgres Tutorials
Back
How to use PostgreSQL with Django
Developer Tools Python Django
Richard Yen, Principal Support Engineer . Dec 30, 2019
This article covers how to use PostgreSQL together with the Python web application framework
Django. After walking through the Django installation process it shows how to get started
creating a simple Django application.
1. Getting started
2. Creating a virtual environment
3. Installing Django
4. Building a simple app in Django with PostgreSQL
In the early days of web development, the framework of choice was LAMP, or
Linux+Apache+MySQL+PHP. While PHP is still a great language for coding, Python has picked up a lot
of popularity. With its clean syntax and use in a variety of industries, Python becomes a natural choice
for any budding coder. In this article, we’ll show you how to get Postgres connected with Django, a
popular web application framework for Python.
Getting started
When working with Python, it’s highly recommended to use a virtual environment. This prevents
dependency collisions and undesired behaviors that would otherwise arise from premature or
unintended version changes. As such, we highly encourage you to use “virtualenv,” along with Python
https://www.enterprisedb.com/postgres-tutorials/how-use-postgresql-django 1/13
7/7/2020 How to use PostgreSQL with Django | EDB
v. 3.x. Obtaining and installing Python v. 3.x is a task outside the scope of this article, but there are
many resources out there that provide instructions on how to do this.
We will also assume that you’ve got a Postgres instance up and running somewhere. If you need help
with that, we’ve got articles that you can refer to.
Creating a virtual environment
The first step to getting started with Django is to create the virtual environment. If you don’t already
have “virtualenv” installed, then simply install with “pip”:
sudo pip install virtualenv
We’ll create a project folder called “myproject” in the “/var” directory:
mkdir /var/myproject
cd /var/myproject
Then, you will need to use “virtualenv” to create a place for the environment-specific dependencies to
be installed:
[root@pga /]# virtualenv /var/myproject/myprojectenv
Using base prefix '/opt/rh/rh-python36/root/usr'
New python executable in /var/myproject/myprojectenv/bin/python3
Also creating executable in /var/myproject/myprojectenv/bin/python
Installing setuptools, pip, wheel...done.
[root@pga /]# ls /var/myproject/myprojectenv/
bin include lib lib64
Then, activate the environment:
[root@pga /]# python --version
Python 2.7.5
[root@pga /]# source /var/myproject/myprojectenv/bin/activate
(myprojectenv) [root@pga /]# python --version
Python 3.6.3
To get Python working with Postgres, you will need to install the “psycopg2” module. However, you
must first have pg_config installed on your OS:
https://www.enterprisedb.com/postgres-tutorials/how-use-postgresql-django 2/13
7/7/2020 How to use PostgreSQL with Django | EDB
[root@pga /]# pg_config
bash: pg_config: command not found
[root@pga /]# export PATH=/usr/pgsql-12/bin/:${PATH}
[root@pga /]# which pg_config
/usr/pgsql-12/bin/pg_config
If you can’t find pg_config on your OS, you will need to install a Postgres client first. After you ensure
pg_config is available on your system, go ahead and install “psycopg2”:
# pip install psycopg2
Installing Django
Once we’ve activated the virtual environment, we can install Django into that environment, so as to
keep things in your project from interfering with the host OS:
# pip install django
Once Django has been installed, you can start a new Django project:
(myprojectenv) [root@pga bin]# pwd
/var/myproject/myprojectenv/bin
(myprojectenv) [root@pga bin]# django-admin.py startproject myproject .
By default, Django is configured to use SQLite as its backend. To use Postgres instead,
“myproject/settings.py” needs to be updated:
# cat myproject/settings.py
. . .
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': ‘<db_name>’,
'USER': '<db_username>',
'PASSWORD': '<password>',
'HOST': '<db_hostname_or_ip>',
'PORT': '<db_port>',
. . .
https://www.enterprisedb.com/postgres-tutorials/how-use-postgresql-django 3/13
7/7/2020 How to use PostgreSQL with Django | EDB
Once you’ve got things pointed to the Postgres database, you can build the default schema. If you
didn’t know already, Django was designed with user access in mind, so by default a Django application
will create a database schema involving users, groups, and permissions. To create the schema,
generate a migration and run it:
(myprojectenv) [root@pga bin]# python manage.py makemigrations
No changes detected
(myprojectenv) [root@pga bin]# python manage.py migrate
Operations to perform:
Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
Applying contenttypes.0001_initial... OK
Applying auth.0001_initial... OK
Applying admin.0001_initial... OK
Applying admin.0002_logentry_remove_auto_add... OK
Applying admin.0003_logentry_add_action_flag_choices... OK
Applying contenttypes.0002_remove_content_type_name... OK
Applying auth.0002_alter_permission_name_max_length... OK
Applying auth.0003_alter_user_email_max_length... OK
Applying auth.0004_alter_user_username_opts... OK
Applying auth.0005_alter_user_last_login_null... OK
Applying auth.0006_require_contenttypes_0002... OK
Applying auth.0007_alter_validators_add_error_messages... OK
Applying auth.0008_alter_user_username_max_length... OK
Applying auth.0009_alter_user_last_name_max_length... OK
Applying auth.0010_alter_group_name_max_length... OK
Applying auth.0011_update_proxy_permissions... OK
Applying sessions.0001_initial... OK
(myprojectenv) [root@pga bin]#
After creating the default schema, create the default superuser:
(myprojectenv) [root@pga bin]# python manage.py createsuperuser
Username (leave blank to use 'root'): richyen
Email address: support@enterprisedb.com
Password:
Password (again):
Superuser created successfully.
(myprojectenv) [root@pga bin]#
https://www.enterprisedb.com/postgres-tutorials/how-use-postgresql-django 4/13
7/7/2020 How to use PostgreSQL with Django | EDB
Now, the moment of truth! Start the application up, and point your browser to the corresponding port:
(myprojectenv) [root@pga bin]# python manage.py runserver 0.0.0.0:5000
Watching for file changes with StatReloader
Performing system checks...
System check identified no issues (0 silenced).
December 06, 2019 - 07:06:22
Django version 3.0, using settings 'myproject.settings'
Starting development server at http://0.0.0.0:5000/
Quit the server with CONTROL-C.
Hooray! We’re in business!
To verify that your superuser works, go to the “/admin” page:
Enter the password, and we’re in!
https://www.enterprisedb.com/postgres-tutorials/how-use-postgresql-django 5/13
7/7/2020 How to use PostgreSQL with Django | EDB
Building a simple app in Django with PostgreSQL
At this point, we’ve got a Postgres database running with Django. Now, how can we build out Django
further, and leverage the ORM to do the heavy lifting of interacting with the database?
Let’s make the app display a relationship between cars and their owners:
(myprojectenv) [root@pga bin]# python manage.py startapp cars
This creates a folder called “cars”, which consists of the following important files:
(myprojectenv) [root@pga bin]# cd cars/
(myprojectenv) [root@pga cars]# ls -l
total 24
-rw-r--r-- 1 root root 63 Dec 6 07:29 admin.py
-rw-r--r-- 1 root root 94 Dec 6 07:29 apps.py
-rw-r--r-- 1 root root 0 Dec 6 07:29 __init__.py
drwxr-xr-x 2 root root 4096 Dec 6 07:29 migrations
-rw-r--r-- 1 root root 57 Dec 6 07:29 models.py
-rw-r--r-- 1 root root 60 Dec 6 07:29 tests.py
-rw-r--r-- 1 root root 63 Dec 6 07:29 views.py
Let’s tell the framework what a Car and a Driver look like, by defining them in “models.py”:
https://www.enterprisedb.com/postgres-tutorials/how-use-postgresql-django 6/13
7/7/2020 How to use PostgreSQL with Django | EDB
(myprojectenv) [root@pga bin]# cat cars/models.py
from django.db import models
class Driver(models.Model):
name = models.TextField()
license = models.TextField()
class Car(models.Model):
make = models.TextField()
model = models.TextField()
year = models.IntegerField()
vin = models.TextField()
owner = models.ForeignKey("Driver", on_delete=models.SET_NULL, null=True)
Then, make the migration to build the tables in the database, and run it:
(myprojectenv) [root@pga bin]# python manage.py makemigrations cars
Migrations for 'cars':
cars/migrations/0001_initial.py
- Create model Driver
- Create model Car
(myprojectenv) [root@pga bin]# python manage.py migrate cars
Operations to perform:
Apply all migrations: cars
Running migrations:
Applying cars.0001_initial... OK
Take a look in the database, and you’ll see that the table has been created with the format
“<project_name>_<object_name>”:
https://www.enterprisedb.com/postgres-tutorials/how-use-postgresql-django 7/13
7/7/2020 How to use PostgreSQL with Django | EDB
postgres=# \d
List of relations
Schema | Name | Type | Owner
--------+-----------------------------+----------+----------
public | auth_group | table | postgres
public | auth_group_id_seq | sequence | postgres
<...>
public | cars_car | table | postgres
public | cars_car_id_seq | sequence | postgres
public | cars_driver | table | postgres
public | cars_driver_id_seq | sequence | postgres
I also created some random data for the purposes of this tutorial:
postgres=# select * from cars_driver;
id | name | license
----+----------+----------
1 | John Doe | Z1234567
2 | Jane Doe | Z9876543
(2 rows)
postgres=# select * from cars_car;
id | make | model | year | vin | owner_id
----+--------+--------+------+----------------------------------+----------
1 | Ford | F-150 | 2004 | 01083da2df15d6ebfe62186418a76863 | 1
2 | Toyota | Sienna | 2014 | 53092a17afa460689ca931f0d459e399 | 1
3 | Honda | Civic | 2018 | 844c56840b5fc26d414cf238381a5f1a | 2
4 | GMC | Sierra | 2012 | 29aeffa4d5aa21d25d7196db3728f72c | 2
(4 rows)
We need to tell Django how to pull stuff out of the database and display it. By editing the
“cars/views.py” file, we can accomplish this:
https://www.enterprisedb.com/postgres-tutorials/how-use-postgresql-django 8/13
7/7/2020 How to use PostgreSQL with Django | EDB
(myprojectenv) [root@pga cars]# cat views.py
from django.shortcuts import render
from cars.models import Car, Driver
def car_detail(request, pk):
owner_obj = Driver.objects.get(pk=pk)
car_objs = Car.objects.filter(owner_id=owner_obj.id)
context = {
"vehicles": car_objs,
"drivers": owner_obj,
return render(request, "car_detail.html", context)
We also need to define a template so that the “views.py” procedures have a place to send the data.
First, we create a “cars/template/base.html” file that contains the more generic elements of an HTML
page:
(myprojectenv) [root@pga cars]# cat templates/base.html
<!doctype html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Contacts</title>
<link rel="stylesheet"
href="https://unpkg.com/tachyons@4.10.0/css/tachyons.min.css"/>
</head>
<body>
{% block page_content %}{% endblock %}
</body>
</html>
Then, we define how the “car_detail.html” template will look:
https://www.enterprisedb.com/postgres-tutorials/how-use-postgresql-django 9/13
7/7/2020 How to use PostgreSQL with Django | EDB
(myprojectenv) [root@pga cars]# cat templates/car_detail.html
{% extends "base.html" %}
{% block page_content %}
<div class="mw6 center pa3 sans-serif">
<h1 class="mb4">Driver: {{ drivers.name | linebreaks }}</h1>
<header class="b mb2">License: {{ drivers.license }}</header>
{% for v in vehicles %}
<div class="pa2 mb3 striped--near-white">
<div class="pl2">
<p class="mb2">Make/Model: {{ v.make }} {{ v.model }}</p>
<p class="mb2">Year: {{ v.year }}</p>
<p class="mb2">Vin: {{ v.vin }}</p>
</div>
</div>
{% endfor %}
</div>
{% endblock %}
Finally, we need to tell the webserver how to route the traffic. First, in “cars/urls.py”, we define how
the REST behavior works:
(myprojectenv) [root@pga cars]# cat urls.py
from django.urls import path
from . import views
urlpatterns = [
path("<int:pk>/", views.car_detail, name="car_detail"),
Note that this will allow us to retrieve Car and Driver objects based on the ID provided in the URL.
Then, in “myproject/urls.py,” we define the root URL for the “cars” application:
https://www.enterprisedb.com/postgres-tutorials/how-use-postgresql-django 10/13
7/7/2020 How to use PostgreSQL with Django | EDB
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path("cars/", include("cars.urls")),
Tell Django that the “cars” app is active by adding “cars” to the “INSTALLED_APPS” list in
“myproject/settings.py”:
Spin up the webserver:
(myprojectenv) [root@pga bin]# python manage.py runserver 0.0.0.0:5000
Watching for file changes with StatReloader
Performing system checks...
System check identified no issues (0 silenced).
December 09, 2019 - 23:53:09
Django version 3.0, using settings 'myproject.settings'
Starting development server at http://0.0.0.0:5000/
Quit the server with CONTROL-C.
And visit http://127.0.0.1:5000/cars/1/:
Change the “1” to a “2” in the URL, and we will get the Driver with `id=2` and the Cars owned by that
Driver:
https://www.enterprisedb.com/postgres-tutorials/how-use-postgresql-django 11/13
7/7/2020 How to use PostgreSQL with Django | EDB
This is a very simple example of how Django can be used to serve up web pages with data from
PostgreSQL. More information about how to define relationships between Django and PostgreSQL
(many-to-many relationships, complex joins, complex filtering, etc.) can be found at the Django
documentation.
Richard Yen, Principal Support Engineer
Ready to take the next step with PostgreSQL? Contact Us
Why EDB?
Use Cases
Oracle Migration
Hybrid Cloud
High Availability
Solutions for
IT Professionals
Database Architects
Developers
Database Admins
Products
Databases
EDB Postgres Advanced Server
PostgreSQL
Cloud Database Service
Tools
Postgres Enterprise Manager
Backup and Recovery Tool
Failover Manager
Open Source Projects
Migration Portal
Migration Toolkit
https://www.enterprisedb.com/postgres-tutorials/how-use-postgresql-django 12/13
7/7/2020 How to use PostgreSQL with Django | EDB
Migration Toolkit
Replication Server
Services
Services Overview
Getting Started
Postgres Optimization
Enterprise Strategy
Custom Services
Support
Customer Support Portal
Support Overview
PostgreSQL Technical Support
Remote DBA Service
Cloud DBA Service
Technical Account Management
Resources
Downloads
Blog
Webinars
PostgreSQL Tutorials
Training
Partners
White Papers
Case Studies
Docs
Plans
Company
About EDB
PostgreSQL Contributions
Careers
Events
Press Releases
Media Coverage
Customers
Follow Us
Twitter
LinkedIn
YouTube
© 2020 EDB . GDPR . Privacy Policy . Terms of Use . Trademarks
https://www.enterprisedb.com/postgres-tutorials/how-use-postgresql-django 13/13
