Installation django on ubuntu

Django is a Python web framework that allows you to create interactive websites and applications. You can easily build Python web applications with Django and rely on the framework to do a lot of the heavy lifting for you.

It’s fast and designed to help developers get their apps up and running as soon as possible. SQL Injection, XSS, CSRF, and clickjacking are all common security errors that Django helps developers to avoid.

This tutorial will show you how to install Django on an Ubuntu 18.04 server. After installation, you’ll create a new project to serve as the foundation for your website.

Django supports four main databases (PostgreSQL, MariaDB, MySQL, Oracle and SQLite) and community libraries support other popular SQL and NoSQL databases at various levels. We recommend that you select the same database for both production and development, even though Django brings many of the differences in the database using its Object-Relational Mapper (ORM).

Different Methods

Depending on your needs and how you want to set up your development environment, there are different ways to install Django. These have various advantages and any one method might accommodate you better than others.

Some of the various methods are:

  • Global install from packages: Django packages can be installed with the conventional apt package manager in the official repositories in Ubuntu. This is straightforward, but not so flexible. The version contained in the repositories may also be lagging behind the official project versions.
  • Install with pip in a virtual environment: Using tools like venv and virtualenv, you can create an independent environment for your projects. A virtual environment enables you to install Django in the project directory, along with other project customizations and packages. This approach to work with Django is normally the most practical and recommended.
  • Development version install with git: Instead of stable release, you can get the code from the Git repo if you want to install the latest development version. This needs to be done in your virtual environment and to obtain the most current features/fixes. However, development models do not have the same guarantees of stability as more stable versions.

Prerequisites

Hardware Requirements

  • RAM- 2 GB
  • Storage- 4 of Hard Disk Space

Software Requirements

  • Web Browser: Any browser such as Google Chrome, Mozilla Firefox, Microsoft Edge.
  • Operating System: An Ubuntu 18.04 server installed with a non-root sudo user and firewall.

Installation Procedure

Global Install from Packages

The process is very simple if you want to install Django using the Ubuntu repositories.

Step 1: update your local package index with apt:

$ sudo apt update

Step 2: Now check the version of python you have installed in your Ubuntu server. You can check it by using:

$ python3 –V

Step 3: Now, you can install Django on your system:

$ sudo apt install python3-django

Step 4: You can check the installation with:

$ django-admin –version

Output:This results in a successful installation of the software. You may also find that the version of Django is not the latest stable version.

Install with pip in a Virtual Environment

Django can be installed flexibly and easily on your system within a virtual environment. We’ll demonstrate how to instal Django in a virtual environment that will be created in the standard Python 3 library with the venv module. With this tool, you can create virtual Python environment without affecting the rest of the system, and install python packages. Thus, regardless of conflict with the requirements of other projects, you can select Python packages on a project basis.

1. First refresh the local package index:

$ sudo apt update

2. Check the installed python version:

$ python3 -V 

3. Now, use Ubuntu repositories to install pip:

$ sudo apt install python3-pip

4. Once the pip has been installed, the venv package can be installed:

$ sudo apt install python3-venv

Step 5: Now, you can create a virtual environment for it whenever you start a new project. Begin with creating a new project directory and move it to a new project directory:

$ mkdir ~/newpProject
$ cd ~/newProject

Step 6: Next, create a virtual environment for your Python version in the project directory using the python command. We’ll call my_env as our virtual environment, but you should call it descriptive:

$ python3.6 - venv my_env

Step 7: This will instal standalone python versions and pip in your project directory into an isolated directory structure. A directory with the name you specify will be created to hold the file hierarchy where your packages will be installed.

You can install packages into the isolated environment by:

$ source my_env/bin/activate

Step 8: Your prompt should update to show that your virtual environment is now in place. It will look something like (my env)username@hostname:~/newProject$.

You can use pip to install Django in your new environment. Whatever version of your Python, when you are in your virtual environment you should only call pip. Also note that since you install locally, you won’t have to use sudo:

(my_env) $  pip install django

Step 9: You can verify the installation by:

(my_env) $  django-admin –version

Note that the version shown here may differ.

Step 10: You need to issue the deactivate command from anywhere on the system to get out of your virtual environment:

(my_env) $ deactivate

Step 11: The conventional display should return to your prompt. If you want to work on your project again, reactivate your virtual environment by returning to your project directory and activating:

$ cd ~/newProject
$ source my_env/bin/activate

Development Version Install with Git

You can download and instal Django from its Git repository if you need a development version of Django. Let’s do this in a virtual environment.

Step 1: First update the local package index:

$ sudo apt update

Step 2: Check the installed python version:

$ python3 -V

Step 3: Now, use Ubuntu repositories to install pip:

$ sudo apt install python3-pip

Step 4: Once the pip has been installed, the venv package can be installed:

$ sudo apt install python3-venv

Step 5: The next step is to clone the repository of Django. This repository will have more up-to-date features and bug corrections at the possible cost of stability between releases. In your home directory, you can clone the repository into the directory ~/django-install using:

$  git clone git://github.com/django/django ~/django-install

Step 6: Change the directory:

$  cd ~/django-install

Step 7: Next, create a virtual environment for your Python version in the project directory using the python command.

$ python3.6 -m venv my_env

Step 8: You can install packages into the isolated environment by:

$  source my_env/bin/activate

Step 9: The repository can next be installed with a pip. In “editable” mode, the -e option is installed and required for installation from version control:

(my_env)  $ pip install -e ~/django-install

Step 10: Verify the installation by:

$  django-admin –version

Creating a Sample Project

You can start building your project with Django. We will discuss how to create a project and test it using a virtual environment on your development server.

Step 1: Start by creating a directory for the project and switch to it.

$ mkdir ~/django-demoproject
$ cd ~/django-demoproject

Step 2: Now, create a virtual environment:

$ python3.6 -m venv my_env

Step 3: Activate:

$ source my_env/bin/activate

Step 4: Install Django:

$ pip install django

Step 5: You can use the django-admin command to build your project. with startproject. You could replace this with another name; however, we’ll call our project djangoproject. In your existing working directory, startproject will create a directory containing:

  • manage.py management script that you can use to manage different tasks in Django.
  • A directory (which contains the actual project code) with the same name.
  • However, let us tell Django to place the management script and inner directory into the current directory to prevent too many nesting directories:
(my-env) $ django-admin startproject

Step 6: To migrate the database, using the manage.py command to migrate. Migration applies any changes to your database scheme that you have made to your Django models.

To migrate the database use:

(my_env) $ python manage.py migrate

Output:Step 7: Let us create an admin user to use the admin interface of Django. Let’s do this with the  createsuperuser command:

(my_env) $ python manage.py createsuperuser

Testing the Development Server

Step 1:  You can start the development server in Django to see what a new project looks like. You should use it exclusively for development. Be sure to follow Django’s deployment guidelines if you are ready to deploy.

We will use the created folder and navigate into it.

$ mkdir ~/django-sample
$ cd ~/django-sample

Step 2: You can use the django-admin command to build your project.

(my-env) $ django-admin startproject djangoproject

Step 3: We can use the manage.py and the runserver command from this folder, as shown.

$ python3 manage.py runserver

$ python manage.py migrate

Step 4: After the server running, you can view the site through your browser by navigating to the following URL: http://127.0.0.1:8000/ : A site that looks like this should be visible:

Step 5: You can add /admin/ to the end to access the admin interface:

You will see:

When the default site is finished, the development server can be stopped by typing CTRL-C into your terminal.

Uninstall Django

1. If you have the system installed widely, sudo should be used, and pip is enough if you have it in a virtual environment.

$ sudo pip uninstall django

2. If installed with apt, then use:

$ sudo apt-get remove python-django

Learn more about the Python and Django in depth with the Web Development with Python and Django Course.

Conclusion

Django should now be installed on your Ubuntu 18.04 server to create powerful web applications. You should also know how to launch the developer server in a new project. 

With django-admin startproject a new website can be created and executed on the web-development server in your browser (python3 manage.py runserver).

Similar Articles

Comments

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Most Popular

Hitting the Books: How memes spread through society like a ‘mind virus’

The struggle for survival is not always limited to animate objects. Ideas can be expressed just as biological genes are, compete for attention-based resources,...

Samsung Galaxy A52 5G Review: Not Perfect, But Reliable

Last year, I said Samsung's $400 Galaxy A51 was overpriced. Naturally, Samsung went ahead and jacked up the price of its successor, the...