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.

Actualizando el Samsung Galaxy Nexus a Jelly Bean 4.2.1 desde Linux

Hola, aquí estoy con un nuevo tema, el cual surgió de la necesidad de actualizar mi teléfono Samsung Galaxy Nexus GT-i9250, cansado de esperar la actualización automatica por parte de Google, así que me puse a curiosear un poco por la red y conseguí que se podía hacer, pero mis exigencias eran un poco mas allá de lo que normalmente conseguía, aplicaciones hechas solo en Windows. Quería que funcionaran en linux y logre conseguir a Universal Nexus Linux Toolkit v2.0, que es un programa basado en script bash que ofrece una manera fácil de hacer todo lo que necesita hacer antes de flashear una ROM personalizada en el dispositivo Nexus.

Eso es lo que yo necesitaba y me arriesgue a usarlo, aquí les voy a contar lo sencillo que es, sin complicaciones. Eso si, te recomiendo que hagas tu respaldo, ya que este procedimiento te deja el teléfono como viene de fabrica.

Este programa sirve para los siguientes equipos:

1. Nexus 4 [mako]
2. Nexus 10 [manta]
3. Nexus 7 (WiFi) [grouper]
4. Galaxy Nexus (GSM) [maguro]
5. Galaxy Nexus (Verizon) [toro]
6. Galaxy Nexus (Sprint) [toroplus]
7. Nexus S (worldwide version, i9020t and i9023) [crespo]
8. Nexus S (850MHz version, i9020a) [crespo]
9. Nexus S (Korea version, m200) [crespo]
10. Nexus S 4G (d720) [crespo4g]

En mi caso, por mi modelo voy a usar la numero 4, Galaxy Nexus (GSM) [maguro]

Con esta herramienta usted será capaz de:

• Unlock the bootloader. (Desbloquear el gestor de arranque)
• Flash CWM recovery (Standard or Touch).
• Root the phone. (poner en root el telefono)
• Lock the bootloader. (Bloquear el gestor de arranque)
• Flash Google Factory Image. (Instalar Imagen de Fabrica de Google)

Empecemos:

Como les dije lo primero es estar seguro que tienes tu respaldo al día de tu teléfono asociado con tu cuenta de gmail, es muy sencillo solo entra en la configuración de tu teléfono en la opción copia de seguridad y restablecer y asegura que tengas tildado la opción de "Hacer una copia de seguridad", que tu cuenta de gmail sea la correcta y la opción de "Restaurar automáticamente". Esto te asegura que al asociar tu teléfono a tu cuenta de gmail, el bajara todas tus aplicaciones y contactos que tenias en la versión anterior. esto también es útil cuando cambias de teléfono, por supuesto debe ser otro android.

¿Que necesitamos?

Bien, primero quiero aclarar que yo uso Ubuntu, por lo tanto no lo he probado en otra distribución, pero al ser un shell script no creo que tengan problemas, cualquier cosa revisen la pagina del desarrollador.

Nota:  Si estas corriendo linux en 64 bits, debes instalar las librerías de 32 bits 

1.- bajar el shell script desde aqui
2.- Extrae el archivo .tgz donde tu quieras, te recomiendo que sea dentro de tu carpeta home, en mi caso     

            /home/fquivera
3.- Abre un terminal y escribe lo siguiente:
Primero nos dirigimos a la carpeta donde esta el shell script, en mi caso:

            cd /home/fquivera/unlt

Hay que hacer una corrección en los enlaces dentro del shell script, ya que Google, borro las imágenes anteriores de la versión 4.2 por errores,  para esto editamos el archivo unlt.sh.
Podemos utilizar cualquier editor, en la linea numero 156 y 157, cambiar estas lineas por:
FACTORY_MAGURO="https://dl.google.com/dl/android/aosp/takju-jop40d-factory-e4d13f14.tgz"

MD5_MAGURO="351926836d314848ed4292bbc499ff36"

Cualquier cosa puedes revisar estos enlaces en la pagina de desarrolladores de Google aqui.

4.- En cuanto tu teléfono debes colocarlo en modo USB Depuración, Para activar la depuración USB en el teléfono: desde configuración -> opciones de desarrollo, marcamos la casilla depuración USB. Aqui te doy un enlace de un video de como hacerlo.

5.- Conectamos el teléfono via USB. 

6.- Ahora ejecutamos el shell script

      sudo bash ./unlt.sh 
      se utiliza sudo, porque debe ser utilizado con privilegios de administrador

7.- Escojamos la opción de nuestro teléfono (En mi caso la opción 4):

8.- Ahora nos pedirá si queremos hacerlo en Automático (Recomendado) o Manual.

9.- Ahora nos muestra la pantalla de las acciones que podemos hacer en nuestro dispositivo, en nuestro caso vamos ir por la opción 5  Flash Google Factory Image

10.- Ahora nos pide que tengamos nuestro teléfono encendido y conectado en modo USB Depuración y se procede a empezar el proceso

11.-  Aquí ira a Google developers a descargar la imagen, un error que puede ocurrir es que no tengan instalado en su linux el wget, que es el comando que utiliza para ello. en Ubuntu, lo instalas con:

    sudo apt-get install wget

Luego de descargar la imagen, comienza a cargar la imagen al Nexus, va parpadear varias veces su teléfono y ustedes podrán ver por el terminal del PC, lo que esta pasando. Al terminar reiniciara el teléfono y lo dejara tal como viene de fabrica, para que comiences a configurar con tu cuenta y baje automáticamente tus aplicaciones y contactos.

Como conclusión les comento que mi teléfono funciona excelente con Jelly Bean 4.2.1 y actualizo todas mis aplicaciones.

Esta no es la única forma de actualizar tu Galaxy Nexus  hay varias que puedes ver en Youtube o en Google, espero que este post les ayude y no olviden dejar sus comentarios al respecto. Saludos

Referencias:

galaxy-nexus-linux-toolkit - http://code.google.com/p/galaxy-nexus-linux-toolkit/

xda-developers - http://forum.xda-developers.com/showthread.php?t=1810119

Creando Aplicaciones Web con Django 1.4 (2da Parte)

En el articulo anterior hablamos de como arrancar un proyecto en Django, en esta oportunidad aprenderemos un tema importante como es la configuración del proyecto. podemos decir primeramente que no hay una manera definitiva de hacerla, ya que la flexibilidad de Django nos permite que cada quien la realice a sus gusto.

Django por ser un framework de Python, utiliza este lenguaje para guardar sus configuraciones y aprovecha la manera de trabajar del lenguaje para hacer archivos de configuración fáciles de leer, extender y utilizar dentro de nuestros proyectos. Por eso es que quizás veremos en algunos proyectos que la configuración esta en varios archivos Python. En nuestro caso solo hablaremos y trabajaremos con el archivo settings.py.

Empecemos:

Editamos nuestro archivo settings.py con nuestro editor preferido, en mi caso yo uso vim, pero también lo puedes hacerlo con gedit, geany o nano (que es un clon del antiguo Wordstar, para algunos nostálgicos).

Primeramente importamos os, este módulo provee docenas de funciones para interactuar con el sistema operativo, en nuestro caso lo usaremos para conocer la ruta de nuestro proyecto.

# -*- coding: UTF-8 -*-
# Django settings for recetas project.

import os

#Definimos la ruta del proyecto
RUTA_PROYECTO = os.path.dirname(os.path.realpath(__file__))

También le damos la codificación UTF-8 a nuestro archivo de configuración para evitar los errores de caracteres en nuestro idioma.

Django por defecto trae la opción DEBUG=True, para que mientras estemos en desarrollo, podamos ver en detalle los errores de la aplicación, en le caso que tengamos la opción de DEBUG=False, normalmente en producción, las notificaciones de error de código son enviadas vía correo electrónico a los administradores, junto con los detalles completos del error. Para poner los datos de los administradores, debemos agregar en forma de tupla, en mi caso lo dejaré así:

 ADMINS = (
     ('Francisco Quivera', 'fquivera@gmail.com'),
)

Una vez hecho esto vamos a definir con que manejador de base de datos trabajara nuestro proyecto. Quiero aclarar que aunque es posible usar Django sin una base de datos, Django incluye un mapeador objeto-relacional (ORM), en el que es posible describir la estructura de la base de datos usando Python. Esto lo veremos en mas detalle cuando veamos los modelos, aquí solo le diremos a Django con que manejador de base de datos vamos a trabajar. Django soporta de manera predeterminada la conexión con Postgresql, MySql, Sqlite3 y Oracle. En nuestro proyecto usaremos Sqlite3, por su facilidad de uso, ya que viene con Python desde la versión 2.5.

Busquemos la siguiente sección del archivo y modificamos:

DATABASES = {
    'default': {
      'ENGINE': 'django.db.backends.sqlite3', #Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
        'NAME': os.path.join(RUTA_PROYECTO,'db/recetas.db'), # Or path to database file if using sqlite3.
        'USER': '',                      # Not used with sqlite3.
        'PASSWORD': '',              # Not used with sqlite3.
        'HOST': '',                      # Set to empty string for localhost. Not used with sqlite3.
        'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
    }
}

Estoy resaltando lo que vamos a agregar, en el caso de utilizar MySql o Postgres, deben instalar previamente los módulos Python para la conexión con estas bases de datos, en Ubuntu se hace con:

MySql:

 

sudo install python-mysqldb

Postgres:

sudo apt-get install python-psycopg2

Configurar la zona horaria, Django permite configurar la zona horaria del proyecto, esto lo hacemos en la siguiente sección, en mi caso agregue la que me corresponde, pueden buscar en la red cual es la que aplica para su caso:

TIME_ZONE = 'America/Caracas'

Django también permite configurar el idioma que usará de manera predeterminada para su funcionamiento, esto es muy útil ya que el administrador de Django, utilizara el idioma definido aquí, para configurar esto debemos cambiar lo siguiente:

LANGUAGE_CODE = 'es-VE'

Django requiere rutas de archivos para cargar archivos estáticos y definir donde estarán nuestras Plantillas o Templates, para hacer esto de manera dinámica, usamos las bondades que nos ofrece Python. Como ya definimos la variable RUTA_PROYECTO, que no es mas que la ruta del directorio donde se encuentra dicho archivo, a partir de éste armaremos la ruta de los archivos estáticos.

Para esto primero debemos crear las carpetas donde vamos a tener dichos archivos, como ya estamos ubicados en home/fquivera/recetas/recetas, hacemos lo siguiente:

mkdir static media plantillas db

luego nos cambiamos a static para crear otras carpetas

cd static

mkdir js img css fonts

Nos deba quedar nuestro árbol de directorio de la siguiente manera:

└── recetas
    ├── manage.py
    └── recetas
        ├── __init__.py

        ├── db
        ├── media       
        ├── plantillas
        ├── settings.py
        ├── static
        │   ├── css
        │   ├── fonts
        │   ├── img
        │   └── js
        ├── urls.py
        └── wsgi.py

¿Para que son esas carpetas que acabamos de crear?

Bien, la carpeta static la utilizamos para ubicar los archivos de estilos css, dentro de la carpeta css, los javascript que podamos utilizar dentro de la carpeta js, las imágenes de nuestro proyecto, como logos, backgrounds, entre otros en la carpeta img y por ultimo si requerimos alguna fuente de letra, la ubicamos en la carpeta fonts

Por otro lado esta la carpeta media, esta carpeta la usamos para almacenar las imágenes, videos, sonidos que utilizamos en nuestros datos, osea, multimedia asociada en nuestra base de datos.

Y por ultimo la carpeta plantillas que allí estarán nuestras plantillas html de nuestro proyecto. La carpeta db es para el archivo de base de datos Sqlite3.

Ahora nos toca decirle a Django a través del archivo settings.py donde están ubicados esos archivos, para ello volvemos a editarlo, buscamos y cambiamos lo siguiente:

Esta variable le dirá a Django donde esta ubicada la carpeta media

MEDIA_ROOT = os.path.join(RUTA_PROYECTO,'media')

La siguiente es la ubicación vía URL, nos permitirá ubicarla mediante http://miproyecto/media

MEDIA_URL = '/media/'

Igualmente la URL para los archivos estáticos

STATIC_URL = '/static/'

La ubicación de los archivos estáticos:

STATICFILES_DIRS = (
    os.path.join(RUTA_PROYECTO,'static'),
)

Por ultimo, la ubicación de mis plantillas

TEMPLATE_DIRS = (
    os.path.join(RUTA_PROYECTO,'plantillas'),
)

Los proyectos en Django trabajan con aplicaciones, algunas ya vienen configuradas de manera predeterminada. Primeramente vamos a utilizar la aplicación de administración y su documentación, estas ya vienen construidas. Para habilitar estas aplicaciones debemos buscar la sección de INSTALLED_APPS que se encuentra casi al final del archivo settings.py y quitarle la marca de comentarios a 'django.contrib.admin' y 'django.contrib.admindocs'. Nos debe quedar de la siguiente manera:

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'django.contrib.flatpages',
    'django.contrib.admin',
    'django.contrib.admindocs',
)

Ahora salvamos nuestro archivo settings.py, regresamos a la carpeta principal y ejecutamos el siguiente comando:

python manage.py syncdb

Este comando nos crea la base de datos del proyecto, hasta ahora solo va generar las tablas necesarias por el administrador de Django.

Creating tables ...
Creating table auth_permission
Creating table auth_group_permissions
Creating table auth_group
Creating table auth_user_user_permissions
Creating table auth_user_groups
Creating table auth_user
Creating table django_content_type
Creating table django_session
Creating table django_site
Creating table django_admin_log

You just installed Django's auth system, which means you don't have any superusers defined.
Would you like to create one now? (yes/no):

 

Aquí nos pide si queremos crear el superusuario para el administrador, le decimos que si, y nos pide los datos del usuario que sera el administrador

Would you like to create one now? (yes/no): yes
Username (leave blank to use 'fquivera'):
E-mail address: fquivera@gmail.com
Password:
Password (again):
Superuser created successfully.
Installing custom SQL ...
Installing indexes ...
Installed 0 object(s) from 0 fixture(s)

Ahora para poder ver los cambios que hicimos y navegar por la interfaz administrativa de Django, aún falta modificar un archivo llamado urls.py. Este archivo esta en la misma carpeta donde esta el archivo settings.py. Modifiquemos este archivo:

vim urls.py 

from django.conf.urls import patterns, include, url

# Uncomment the next two lines to enable the admin:
# from django.contrib import admin
# admin.autodiscover()

urlpatterns = patterns('',
    # Examples:
    # url(r'^$', 'recetas.views.home', name='home'),
    # url(r'^recetas/', include('recetas.foo.urls')),

  #Uncomment the admin/doc line below to enable admin documentation:
    # url(r'^admin/doc/', include('django.contrib.admindocs.urls')),

    # Uncomment the next line to enable the admin:
    # url(r'^admin/', include(admin.site.urls)),
)

Quitemos el comentario a algunas cosas y nos queda el archivo de la siguiente manera:

from django.conf.urls import patterns, include, url
from django.contrib import admin

admin.autodiscover()

urlpatterns = patterns('',    # Examples:
    # url(r'^$', 'recetas.views.home', name='home'),
    # url(r'^recetas/', include('recetas.foo.urls')),

    url(r'^admin/doc/', include('django.contrib.admindocs.urls')),

    url(r'^admin/', include(admin.site.urls)),
)

he resaltado lo que he cambiado, además se han borrado las lineas de comentario, bien ahora si probamos lo que hemos hecho hasta ahora

$ python manage.py runserver
Validating models...

0 errors found
Django version 1.4.1, using settings 'recetas.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Y probamos en nuestro navegador http://127.0.0.1:8000

veremos lo siguiente:

Upssss, que paso aquí, como ya modificamos el archivo urls.py, Django, ve cuales son las URLs validas para el proyecto y estas son /admin y /admin/doc, ya que no hemos colocado la url raíz. corregimos la url en nuestro navegador de la siguiente manera:

http://127.0.0.1:8000/admin

Ahora Django nos pide el usuario y contraseña, para ingresar al administrador, lo hacemos y tenemos la siguiente pantalla:

Hasta aquí esta segunda parte, cualquier duda, escriba en los comentarios y así lo compartimos con todos. Hasta la próxima