Django en Producción con Centos, PostgreSQL, Virtualenv, Gunicorn, Nginx y Supervisor

En este articulo vamos llevar a un entorno de Producción nuestra aplicación que creamos con Django, para ello vamos a utilizar varias herramientas:

Nos basaremos en el sistema operativo Centos 6.4 que es el clon libre del Red Hat Enterprise Server, un sistema operativo Linux hecho para servidores. en el caso de otras distribuciones de Linux, solo busca como instalar los paquetes y donde están ubicados sus archivos de configuración.

Puedes hacer esto en un servidor local, o puedes utilizar cualquiera de los proveedores que dan servicio de VPS.

Voy a asumir que usted conoce o sabe como configurar su servidor para apuntar un dominio a la dirección IP del servidor.

1.- Crear un usuario donde va estar nuestro proyecto y darle permisos de Administrador

como usuario root, ejecutamos:

[root@localhost ~]#  useradd django

luego editamos el archivo /etc/sudoers, con tu editor de preferencia

[root@localhost ~]# vim /etc/sudoers

allí agrega debajo de la linea donde esta root:

## Allow root to run any commands anywhere
root    ALL=(ALL)       ALL
django        ALL=(ALL)       ALL

2.- Instalar PostgreSQL

Yo particularmente recomiendo que cuando este en el proceso de instalación de Centos, escoge la opción de Servidor de Base de datos, para tener ya PostgreSQL instalado, en caso contrario, instalarlo con el siguiente comando:

[root@localhost ~]#  yum install postgresql postgresql-server postgresql-contrib

Ahora iniciamos el servidor PostgreSQL

 [root@localhost ~]# service postgresql initdb

Arrancamos el servicio:

 [root@localhost ~]# service postgresql start

Y lo configuramos para que arranque cada vez que iniciemos el servidor:

 [root@localhost ~]# chkconfig postgresql on

Luego configuramos los archivos pg_hba.conf y postgres.conf para poder conectarnos al PostgreSQL, por favor revise la documentación para ver las opciones de configuración para su servidor. Editamos postgres.conf

[root@localhost ~]# vi /var/lib/pgsql/data/postgresql.conf

Descomentar las siguientes lineas y agregamos * en la variable listen_addresses si queremos administrar nuestro PostgreSQL desde cualquier equipo:

listen_addresses = '*'
port = 5432

Ahora editamos pg_hba.conf:

[root@localhost ~]# vi /var/lib/pgsql/data/pg_hba.conf

Y cambiamos la siguiente linea por esto:

 # TYPE  DATABASE    USER        CIDR-ADDRESS          METHOD
# "local" is for Unix domain socket connections only
local   all         all                               trust

Ahora reiniciamos nuestro servicio:

[root@localhost ~]# service postgresql restart

Le asignamos una clave al usuario que viene por defecto llamado postgres en la Base de Datos

[root@localhost ~]# su postgres
bash-4.1$
bash-4.1$ psql
could not change directory to "/root"
psql (8.4.13)
Type "help" for help.
postgres=# ALTER ROLE postgres WITH PASSWORD 'abc123';
postgres=# \q
bash-4.1$

En este caso se le asigno la clave abc123, coloque la que mas le conviene.

Y esta nuestro servidor funcionando, ahora creamos nuestro usuario y base de datos para nuestra aplicación:

bash-4.1$ createuser django -P
could not change directory to "/root"
Enter password for new role:
Enter it again:
Shall the new role be a superuser? (y/n) n
Shall the new role be allowed to create databases? (y/n) n
Shall the new role be allowed to create more new roles? (y/n) n
bash-4.1$ 

Ya tenemos creado el usuario django en PostgreSQL, ese es el usuario que colocaremos en el archivo settings.py de Django, ahora creamos la base de datos de nuestra aplicación:

bash-4.1$ psql
could not change directory to "/root"
psql (8.4.13)
Type "help" for help.
postgres=# CREATE DATABASE mibasedatos OWNER django;
GRANT
postgres=# \q
bash-4.1$ exit

3.- Instalar el repositorio EPEL (Extra Packages for Enterprise Linux):

[root@localhost ~]# wget http://ftp.riken.jp/Linux/fedora/epel/RPM-GPG-KEY-EPEL-6
[root@localhost ~]# rpm --import RPM-GPG-KEY-EPEL-6
[root@localhost ~]# rm -f  RPM-GPG-KEY-EPEL-6

Instalamos en este caso para Centos de 64:

[root@localhost ~]# wget http://ftp.riken.jp/Linux/fedora/epel/6/x86_64/epel-release-6-8.noarch.rpm
[root@localhost ~]# rpm -ivh epel-release-6-8.noarch.rpm
[root@localhost ~]# yum update

4.- Instalamos Nginx

[root@localhost ~]# yum install nginx

Arrancamos el servicio y lo configuramos para que arranque cada vez que inicie la maquina:

[root@localhost ~]# service nginx start
[root@localhost ~]# chkconfig nginx on

Nota: debemos inhabilitar el firewall que viene por defecto o configurar para acepte peticiones, en nuestro caso lo vamos a inhabilitar:

[root@localhost ~]# service iptables stop

Probamos nuestro servidor Web en nuestro navegador: http://localhost

5.- Instalar Python y librerías necesarias

Instalamos Python y las librerías y componentes necesarios para que nuestra aplicación funcione correctamente con PostgreSQL

[root@localhost ~]# yum install python python-devel python-setuptools python-pip libxml2-devel

Ademas vamos a instalar gcc, el compilador de C y postgresql-devel. que nos lo exige el psycopg2 para conectarnos desde Django a PostgreSQL

[root@localhost ~]# yum install gcc postgresql-devel

6.- Instalación de Virtualenv 

Para instalar virtualenv, utilizamos pip, ya aquí podemos ingresar con nuestro usuario que creamos al principio:

[django@localhost ~]$ sudo pip install virtualenv

Al terminar de instalar, procedemos a crear nuestro ambiente para la aplicación que vamos colocar en producción:

[django@localhost ~]$ virtualenv ~/env

Para activar ejecutamos:

[django@localhost ~]$ source ~/env/bin/activate

Y miren como nos cambia el prompt

(env)[django@localhost ~]$ 

Todo lo que instalemos aquí vía pip, solo estará en este ambiente, esto es muy útil cuando vamos a tener varias aplicaciones con diferentes versiones de Django

7.- Instalamos Django, psycopg2 y nuestra aplicación

Dentro de nuestro ambiente virtual, este pendiente que tengamos en el prompt los paréntesis con nuestro ambiente "(env)[django@localhost ~]$", instalamos lo que requerimos para nuestra aplicación, primero por supuesto Django:

 (env)[django@localhost ~]$ pip install django

La librería para conectarnos a PostgreSQL:

(env)[django@localhost ~]$ pip install psycopg2

La aplicación la copiamos al directorio que queramos, puede ser en /opt/webapps, o donde ustedes lo consideren:

(env)[django@localhost ~]$ sudo mkdir -p /opt/webapps
[sudo] password for django:

Lo mas importante es que el directorio tenga permiso de lectura:

drwxr-xr-x. 4 root root 4096 oct  9 19:31 /opt

Cambiamos el usuario de la carpeta webapps:

(env)[django@localhost ~]$cd /opt
(env)[django@localhost opt]$ sudo chown django:nginx webapps
[sudo] password for django:

 Solo para probar creamos una aplicación en Django:

 (env)[django@localhost opt]$ cd webapps/
(env)[django@localhost webapps]$ django-admin.py startproject demo
(env)[django@localhost webapps]$ cd demo
(env)[django@localhost demo]$ python manage.py runserver
Validating models...
0 errors found
October 09, 2013 - 19:12:55
Django version 1.5.4, using settings 'demo.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Ya podemos ver que nuestro servidor de desarrollo funciona en nuestro navegador con http://127.0.0.1:8000

Nos queda configurar Django con la Base de datos y podemos empezar a crear las tablas de nuestra aplicación:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'mibasedatos',                    
        'USER': 'django',
        'PASSWORD': 'abc123',
        'HOST': 'localhost',                
        'PORT': '',                
    }
}

Solo queda que montes tu aplicación y crear las tablas de tu base de datos en el servidor, ahora a configurar Gunicorn y Nginx:

8.- Instalando y configurando Gunicorn

Gunicorn es también conocido como Green Unicorn (Unicornio Verde), es un servidor WSGI HTTP para Python. Es un pre-fork del proyecto Unicorn de Ruby. Gunicorn es compatible con varios frameworks, soporta WSGI, Django y Paster de forma nativa; consume pocos recursos en ejecución y es bastante rápido. Aquí solo voy a tratar lo básico, cualquier configuración adicional, por favor busque la documentación. Para instalarlo:

(env)[django@localhost opt]$ pip install gunicorn

Probemos nuestra pequeña aplicación con Gunicorn:

(env)[django@localhost demo]$ gunicorn -w3 demo.wsgi:application --bind 127.0.0.1:8000
2013-10-09 20:14:49 [8571] [INFO] Starting gunicorn 18.0
2013-10-09 20:14:49 [8571] [INFO] Listening at: http://127.0.0.1:8000 (8571)
2013-10-09 20:14:49 [8571] [INFO] Using worker: sync
2013-10-09 20:14:49 [8576] [INFO] Booting worker with pid: 8576
2013-10-09 20:14:49 [8577] [INFO] Booting worker with pid: 8577
2013-10-09 20:14:49 [8578] [INFO] Booting worker with pid: 8578

Ahora podemos probar en nuestro navegador  http://127.0.0.1:8000 y allí tenemos nuestra aplicación corriendo en un servidor WSGI HTTP

El comando gunicorn ofrece una extensa lista de opciones para configurar su comportamiento, pero las que he utilizado en esta oportunidad son:

-w INT: número de procesos workers que se arrancarán para servir las peticiones.Este dependerá en medida de la carga de trabajo que tenga la aplicación, también depende del hardware con que se cuente, de acuerdo a la siguiente formula: 2*CPU +1, Para las maquinas que tienen un solo procesador escriba 3.

demo.wsgi:application: la ubicación del archivo wsgi.py y escribimos después de los dos puntos application

--bind ADDRESS: es posible especificar tanto HOST:PUERTO para decirle a gunicorn por donde va recibir peticiones

Bien, hagamos un script para que levante el entorno virtual y ejecute nuestra aplicación con Gunicorn. lo creamos en nuestro home

(env)[django@localhost opt]$ cd
(env)[django@localhost opt]$ vi gunicorn_start.sh

y escribimos en nuestro archivo:

#!/bin/sh
NAME="demo"
DJANGODIR="/opt/webapps/demo"
NUM_WORKERS=3
echo "Arrancando Demo"
cd $DJANGODIR
source ~/env/bin/activate
exec gunicorn -w $NUM_WORKERS $NAME.wsgi:application --bind 127.0.0.1:8000

Salimos del ambiente virtual y ejecutamos para probarlo:

(env)[django@localhost ~]$ deactivate
[django@localhost ~]$ chmod +x gunicorn_start.sh
[django@localhost ~]$ ./gunicorn_start.sh
Arrancando Demo
2013-10-09 20:41:26 [8686] [INFO] Starting gunicorn 18.0
2013-10-09 20:41:26 [8686] [INFO] Listening at: http://127.0.0.1:8000 (8686)
2013-10-09 20:41:26 [8686] [INFO] Using worker: sync
2013-10-09 20:41:26 [8695] [INFO] Booting worker with pid: 8695
2013-10-09 20:41:26 [8696] [INFO] Booting worker with pid: 8696
2013-10-09 20:41:26 [8697] [INFO] Booting worker with pid: 8697

Como podemos ver nos queda nuestro terminal con la aplicación y no nos deja hacer mas nada y si lo cerramos, se cae la aplicación, esto lo vamos a resolver con Supervisor

9.- Instalando y Configurando Supervisor

Supervisor es un sistema cliente servidor que permite a los usuarios monitorear y controlar una serie de procesos en los sistemas operativos tipo UNIX.

Comparte algunos de los mismos objetivos de los programas como launchd , daemontools y runit . A diferencia de algunos de estos programas, no está diseñada para ejecutarse como un sustituto de init. En cambio, está destinado a ser utilizado para el control de procesos relacionados con un proyecto o un cliente, y está destinado a iniciar como cualquier otro programa en el arranque.

le damos Ctrl-C, para salir de Gunicorn y liberar la terminal, instalamos ahora Supervisor con yum:

[django@localhost ~]$ sudo yum install supervisor

Una vez instalado configuramos supervisor para nuestra aplicación en /etc/supervisord.conf. Hay que hacerlo como root:

[django@localhost ~]$ su -
Contraseña:
[root@localhost ~]# vi /etc/supervisord.conf

Agregamos lo siguiente al final del archivo:

[program:demo]
command=/home/django/gunicorn_start.sh
user=django
autostart=true
stdout_logfile=/opt/webapps/demo/logs/gunicorn_supervisor.log
redirect_stderr=true

Creamos la carpeta y archivo para los logs:

[root@localhost ~]# exit
[django@localhost ~]$ mkdir -p /opt/webapps/demo/logs
[django@localhost ~]$ touch /opt/webapps/demo/logs/gunicorn_supervisor.log

Arrancamos Supervisor y lo configuramos para que arranque siempre

[django@localhost ~]$ sudo service supervisord start
[django@localhost ~]$ sudo chkconfig supervisord on

Reiniciamos el servicio propiamente de Supervisor:

[django@localhost ~]$sudo supervisorctl reload
Restarted supervisord

Y ahora veremos nuestra aplicación corriendo:

[django@localhost ~]$ sudo supervisorctl status demo
[sudo] password for django:
demo    RUNNING    pid 8883, uptime 0:11:29

Para detenerla:

[django@localhost ~]$ sudo supervisorctl stop demo

Para reiniciarla:

[django@localhost ~]$ sudo supervisorctl restart demo

Listo ya tenemos nuestra aplicación lista para que arranque al iniciar el servidor

10.- Configuración de Nginx

Buscamos el archivo de configuración de nginx en /etc/nginx/conf.d llamado default.conf y lo cambiamos totalmente por esto:

server {
    listen 80;
    server_name ejemplo.com;
    access_log  /var/log/nginx/server.log;
    root /opt/webapps/demo;
    location /static/ {
    autoindex on;
    alias  /opt/webapps/demo/static/;
    }
    location /media/ {
    autoindex on;
    alias  /opt/webapps/demo/media/;
    }
    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
  }

Lo importante, tu carpeta static y media, es importante colocar la ruta exacta hacia esos archivos, de lo contrario, no te permitirá ver los estilos de tu aplicación. Otra cosa importante es la dirección por donde esta sirviendo tu aplicación el Gunicorn.

Reiniciamos nuestro servicio de Nginx y a probar nuestra aplicación

[django@localhost ~]$ sudo service nginx start

Listo, espero sus comentarios y sugerencias, hasta la próxima.