Installing Python

Prerequisites

Before installing new packages, it is always a good practice to update your system packages and

package indexes. To do that execute:

apt-get update apt-get upgrade

Installing Apache

Since this text focuses on using Apache to serve the application, the server itself is necessary. To install

the necessary packages execute:

apt-get install apache2

Straight after installation Apache will already be running. You can check whether the Apache web

server has been properly set-up by opening your web browser and pointing it to the server IP address.

You should see a simple It works! page on the screen.

Installing pip and virtualenv

To begin working with Python and Django on a webserver, pip and virtualenv must be installed first.

Pip is a Python package manager that facilitates installing Python software packages such as Django

itself, whereas virtualenv makes it possible to create separate virtual environments for Python

applications in order to separate libraries needed for different applications and avoid version clash

between them.

To do that execute:

apt-get install python-pip python-virtualenv

This command will install pip and virtualenv from the Debian package repository. You can verify that

both tools have been properly installed by running them with --version switch.

root@django:~# virtualenv --version 1.7.1.2 root@django:~# pip --version pip 1.1 from /usr/lib/python2.7/dist-packages (python 2.7) root@django:~#

Creating a virtual environment using virtualenv

Upon Apache installation a /var/www directory is automatically created in which the default web server root is set up. We will put our new Django application there with all its dependencies.

Let's create a new directory called sampleapp inside that directory and enter the new directory:

cd /var/www mkdir sampleapp cd sampleapp

Then let's create a new virtual environment using virtualenv. A Python virtual environment is basically a directory in which the Python interpreter and a local instance of pip resides. The local instance of pipinstalls all packages inside the virtual environment. That way no installed packages pollute global Python installation and also there is no possibility of package version clash in a hypothetical scenario of

two applications running two different versions of Django or any other library.

To create a new virtual environment enter:

virtualenv env

where env is the virtual environment name - it could be any other word. The output from this command should look like this:

root@django:/var/www/sampleapp# virtualenv env New python executable in env/bin/python Installing distribute.............................................................................................................................................................................................done. Installing pip...............done. root@django:/var/www/sampleapp#

The virtual environment is now ready and can be used in two different ways.

One way is to run commands using virtual environment interpreter directly. With this method it is

necessary to always remember to execute the correct interpreter or pip instance, as there is a possibility to run a system-wide one.

root@django:/var/www/sampleapp# env/bin/pip --version pip 1.1 from /var/www/sampleapp/env/lib/python2.7/site-packages/pip-1.1-py2.7.egg (python 2.7) root@django:/var/www/sampleapp# env/bin/python --version Python 2.7.3 root@django:/var/www/sampleapp#

The other way is to activate the environment first, using

source env/bin/activate

the environment name will then be prepended to the command line as such

root@django:/var/www/sampleapp# source env/bin/activate (env)root@django:/var/www/sampleapp#

and all commands executed will be using local virtual environment versions

(env)root@django:/var/www/sampleapp# pip --version pip 1.1 from /var/www/sampleapp/env/lib/python2.7/site-packages/pip-1.1-py2.7.egg (python 2.7) (env)root@django:/var/www/sampleapp# python --version Python 2.7.3 (env)root@django:/var/www/sampleapp#

it is easier to work that way; however it is necessary to deactivate the environment after the work is done using the following command

deactivate

it will return the shell to normal

(env)root@django:/var/www/sampleapp# deactivate root@django:/var/www/sampleapp#

The freshly created environment will be used to store all necessary dependencies, including Django

and related libraries. It will also be used by Apache and mod_wsgi later on to serve the application

using correct dependencies.

Installing Django inside virtual environment

Next necessary step is to install Django inside the virtual environment. Let's do that without activating

the environment beforehand using:

env/bin/pip install django

The last messages shown after executing this command should look like this

Successfully installed django Cleaning up...

Django is now installed inside virtual environment and is not available from within system-wide Python

installation. You can verify that behavior by importing django module using both interpreters

root@django:/var/www/sampleapp# python Python 2.7.3 (default, Mar 13 2014, 11:03:55) [GCC 4.7.2] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import django Traceback (most recent call last): File "", line 1, in ImportError: No module named django >>> exit()

Import using system-wide interpreter failed, whereas

root@django:/var/www/sampleapp# env/bin/python Python 2.7.3 (default, Mar 13 2014, 11:03:55) [GCC 4.7.2] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import django >>>

the one executed inside the virtual environment succeeded.

Creating first Django project

To create a simple, basic example project we can use django-admin.py script as follows

env/bin/django-admin.py startproject sampleapp .

Please note the trailing . in the command - without it the project will be created in an additional subdirectory. After executing that command a new sampleapp directory and manage.py script will be created in /var/www/sampleapp. The manage.py script is used to execute Django commands for this particular project. One of the possible uses of manage.py is to run a test server instance to verify that everything is working as intended.

Please execute:

env/bin/python manage.py runserver 0.0.0.0:8000

This will run a test server bound to all interfaces on port 8000. The output should look like this:

Validating models... 0 errors found April 08, 2014 - 12:29:31 Django version 1.6.2, using settings 'sampleapp.settings' Starting development server at http://0.0.0.0:8000/ Quit the server with CONTROL-C.

If you open your server IP address with port 8000 in your browser (the address should look

likehttp://:8000/) you should see the It worked! example Django page. This is the result we will work towards using Apache web server instead of the built-in Django development server.

Since the Django application is working properly, we can proceed to pair the application with Apache.

Installing mod_wsgi for Apache

The easiest and also recommended way to serve Python applications using Apache is to use

mod_wsgimodule. It is not installed by default with neither Python nor Apache, so we have to install an

additional package.

apt-get install libapache2-mod-wsgi

The next step will be to configure default Apache virtual host that at the beginning of the article served

It works! page to serve our Django application.

Configuring mod_wsgi in a default virtual host

The idea behind configuring mod_wsgi for any other virtual host in Apache is the same as the one

presented here. We will use the default virtual host for simplicity, since it is the one already provided

by a clean Apache installation.

Open the default virtual host configuration file in nano editor

nano /etc/apache2/sites-enabled/000-default

and add three following lines just below

WSGIDaemonProcess sampleapp python-path=/var/www/sampleapp:/var/www/sampleapp/env/lib/python2.7/site-packages WSGIProcessGroup sampleapp WSGIScriptAlias / /var/www/sampleapp/sampleapp/wsgi.py

The first line spawns a WSGI daemon process called sampleapp that will be responsible for serving ourDjango application. The daemon name can be basically anything, but is good practice to *use

descriptive names such as application names here.

If we were using global Python installation and global Django instance, the python-path directive would not be necessary. However, using virtual environment makes it obligatory to specify the alternate

Python path so that mod_wsgi will know where to look for Python packages.

The path must contain two directories: the directory of Django project itself - /var/www/sampleapp - and directory of Python packages inside our virtual environment for that project

-/var/www/sampleapp/env/lib/python2.7/site-packages. Directories in path definition are delimited using a colon sign.

The second line tells that particular virtual host to use the WSGI daemon created beforehand, and as

such, the daemon name must match between those two. We used sampleapp in both lines.

The third line is the most important, as it tells Apache and mod_wsgi where to find WSGI configuration.

The wsgi.py supplied by Django contains the barebone default configuration for WSGI for servingDjango application that works just fine and changing the configuration in this file is out of this

article scope.

After these changes it is necessary to restart Apache

service apache2 restart

After that, upon opening the web browser on your server IP address, without any additional ports, you

should see the same Django page as before instead of initial It works! page that we have seen earlier.

That makes our configuration complete.

Installing PostgreSQL

By default PostgreSQl is available in Ubuntu repository. To install PostgreSQL in Ubuntu Server 13.10 is

simple, just run the following commands:

sudo apt-get update

sudo apt-get install postgresql

You can also install postresql by adding the following PPA.

sudo apt-get install python-software-properties

sudo add-apt-repository ppa:pitti/postgresql

sudo apt-get update

sudo apt-get install postgresql

If youre getting an error message, make sure you already install libpq-dev.The libpq-dev package is for

compiling wrappers/clients against libpq.

sudo apt-get install postgresql-9.1 libpq-dev

Configuring PostgreSQL

Enabling TCP connections. By default TCP/IP connections is disabled due to which users will not be

able to access remotely PostgreSQL server from another computers. to enable it edit file

/etc/postgresql/9.1/main/postgresql.conf.

sudo nano /etc/postgresql/9.1/main/postgresql.conf

Change #listen_addresses = localhost to listen_addresses =192.168.1.8 it allowing remote access

only from specific ip address, if you want remote access from any computers in your network

setlocalhost to listen_addresses =*

uncomment #password_encryption = on to password_encryption = on

Save and exit ( Ctrl + O, Ctrl + X), Restart postgreSQl daemon:

sudo /etc/init.d/postgresql restart

After editing file /etc/postgresql/9.1/main/postgresql.conf. you need to setup the root password PostgreSQL. In PostgreSQL, root user is postgres which by default, does not have any password. Enter

following line in terminal to set a password for the default root user postgres:

$ sudo -u postgres psql

Now psql will ask for a new password twice. Enter the new password and continue. Type \q and hit

enter to quit.

To create a database the following command can be run from the terminal:

$ sudo -u postgres createdb mydb

Installing and Configuring PhpPgAdmin

phpPgAdmin is a php-based web application that provides a GUI interface for the postgresql. It performs a similar function to phpMyAdmin, which allows users to manipulate database information in

a visual program in MySQL.

Execute the following command to installing PhpPgadmin in ubuntu server:

sudo apt-get install phppgadmin

By default you can only access phppgadmin locally. If you want to access remotely from another computers change the following file:

sudo nano /etc/apache2/conf.d/phppgadmin

Comment out the line:

127.0.0.0/255.0.0.0 allow from :: 1/128

uncomment the line:

allow from all

Create a symbolic link /var/www/phppgadmin which would point to /usr/share/phppgadmin

sudo ln -s /usr/share/phppgadmin /var/www/

Restart apache2 daemon:

sudo service apache2 restart

Probably when trying to log into phppgadmin you receive the following message Login disallowed for

security Reasons and this can be solved by changing a configuration variable in Archiving below

sudo nano /usr/share/phppgadmin/conf/config.inc.php

By default comes as :

$conf['extra_login_security']= true;

just switch to :

$conf['extra_login_security']=false;

Now, Access phpPgadmin using web browser from any computer in your network by typing in address

bar http://host_or_ip/phppgadmin/. You should be able to login using any users youve setup in

PostgreSQL. It will be appear like the following screenshot: