//barrabarra

JAVIER ROMERO
Programación web y escritorio
 

Our blog, keeping you up-to-date on our latest news.

 

Configurar Ubuntu 12.10 en Linode para servir aplicaciones de Django

abril 11, 2013 at 12:14 pm | Blog, Django, Programación, virtualenv | No comment

 

Hemos creado una nueva máquina virtual usando Linode y vamos a ver cómo configurar un entorno virtual y servir webs con django.

Lo primero que haremos será loguearnos mediante ssh a nuestra cuenta, una vez echo esto, ponemos al día los paquetes:

apt-get update && apt-get upgrade

A continuación instalamos los programas que vamos a necesitar:

apt-get install git python2.7 virtualenvwrapper

Aceptamos las dependencias y los dejamos instalados. Como puede que hay descargado nuevas versiones de la imagen del kernel reiniciamos y de paso aprovechamos ese reinicio para que virtualenvwrapper añada algunas líneas de configuración a nuestro archivo de configuración del intérprete de comandos. Esperamos unos segundos y volvemos a conectar vía ssh.

Cuando ya hemos conectado de nuevo vamos a crear el proyecto y su entorno virtual:

mkvirtualenv -p /usr/bin/python2.7 mi-proyecto-django

(usamos la opción -p para indicar el ejecutable de Python 2, ya que la última versión de Ubuntu llega de fábrica con Python 3.
Cuando hemos creado el entorno automáticamente estaremos dentro, como se puede observar porque el prompt de la terminal ha cambiado a (mi-proyecto-django)usuario@localhost:…

Nos vamos a /var/www/ (que será el directorio en el que contengamos nuestros proyectos de django) y clonamos desde nuestro repositorio/subimos via ftp/similar el código. Lo recomendable es usar un sistema de control de versiones, github o bitbucket ofrecen ambas servicio gratuito de alojamiento. Cuando lo tenemos descargado podemos seguir con la configuración del proyecto. Al usar entornos virtuales es muy sencillo replicar las condiciones de las máquinas de desarrollo en el entorno de producción con la ayuda del programa pip. Mientras vamos desarrollando e instalando programas y dependencias en el entorno virtual no tenemos que ir apuntando cada programa y cada versión, podemos obtenerlos todos de una vez ejecutando

pip freeze

pip freeze > requirements.txt es una forma de volcar la salida de los resultados de paquetes y versiones a un único archivo de requisitos, que debería ir acompañando al código fuente en el control de versiones para que al subirlo al hosting de producción estuviera preparado para instalarlas.

Contando con que tenemos ese archivo con los nombres y versiones de paquetes, podemos instalarlos fácilmente con la ejecución en el hosting de:

pip install -r requirements.txt

Vigila los mensajes que devuelve la ejecución ya que por ejemplo en una de mis dependencias (django-chronograph) la versión de “distribute” es demasiado antigua y tengo que actualizarla antes de poder completar la intalación de todos los requisitos. El propio mensaje te informa de que eso se resuelve ejecutando

easy_install -U distribute

Como ya le hemos indicado al virtualenv que la versión de python a usar es la 2.7 no hace falta que indiquemos que queremos usar “easy_install 2.7 -U distribute” ya que son equivalentes. Cuando hemos actualizado distribute volvemos a instalar los requisitos de requirements.txt, terminará de descargar e instalar los paquetes que quedaron pendientes y tendremos el entorno correctamente preparado. Si vas a instalar PIL date una vuelta por esta entrada en la que comentan cómo habilitar el soporte para varios formatos: http://askubuntu.com/questions/156484/how-do-i-install-python-imaging-library-pil

Vamos con el resto de programas que vamos a utilizar: necesitaremos un servidor de bases de datos, un servidor web y para facilitarnos la vida con la gestión de la base de datos una interfaz gráfica, para ello instalamos los paquetes:

apt-get install mysql-server phpmyadmin nginx php5-fpm

y sus dependencias.

Vamos con la configuración del software. Lo primero que te preguntará el sistema al instalar el servidor MySQL es que le proporciones una clave para el usuario root, hazlo y termina de configurarlo. Tras eso, el asistente de instalación de phpmyadmin te indicará que deben instalarse ciertas tablas de configuración, acepta, indícale la clave de root que anteriormente habías elegido y por último deja que se elija una clave aleatoria para el acceso de phpmyadmin a la base de datos.

En el siguiente paso vamos a comprobar si el servidor NGINX está funcionando, primero nos aseguramos de que se esté ejecutando con la orden:

service nginx start

y posteriormente vamos a la ip de nuestro hosting, en la que deberíamos ver un mensaje similar a: Welcome to nginx!
Si lo vemos, continuaremos creando la configuración para servir phpmyadmin. Crearemos un archivo phpmyadmin en la ruta /etc/nginx/sites-available/ con el contenido siguiente:


server {
listen 81; ## listen for ipv4; this line is default and implied
#listen [::]:80 default_server ipv6only=on; ## listen for ipv6

root /usr/share/;
index index.php index.html index.htm;

# Make site accessible from http://localhost/
server_name localhost;

# Make sure files with the following extensions do not get loaded by nginx because nginx would display the source code, and these files can contain PASSWORDS!
location ~* \.(engine|inc|info|install|make|module|profile|test|po|sh|.*sql|theme|tpl(\.php)?|xtmpl)$|^(\..*|Entries.*|Repository|Root|Tag|Template)$|\.php_ {
deny all;
}

# Deny all attempts to access hidden files such as .htaccess, .htpasswd, .DS_Store (Mac).
location ~ /\. {
deny all;
access_log off;
log_not_found off;
}

location ~* \.(jpg|jpeg|png|gif|css|js|ico)$ {
expires max;
log_not_found off;
}

location ~ \.php$ {
try_files $uri =404;
include fastcgi_params;
fastcgi_pass unix:/var/run/php5-fpm.sock;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
}

# pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
#
location /phpmyadmin {
root /usr/share/;
index index.php index.html index.htm;
location ~ ^/phpmyadmin/(.+\.php)$ {
try_files $uri =404;
root /usr/share/;
fastcgi_split_path_info ^(.+\.php)(/.+)$;
# With php5-fpm:
fastcgi_pass unix:/var/run/php5-fpm.sock;
fastcgi_index index.php;
include fastcgi_params;
}
location ~* ^/phpmyadmin/(.+\.(jpg|jpeg|gif|css|png|js|ico|html|xml|txt))$ {
root /usr/share/;
}
}

location /phpMyAdmin {
rewrite ^/* /phpmyadmin last;
}
}

Con esto tendremos a NGINX sirviendo phpyadmin a través de php-fpm, y vamos a intentar acceder a él para ver si lo hemos configurado correctamente.
Primero arrancamos php5-fpm por si no lo estuviera:

service php5-fpm start

Habilitamos la configuración que hemos creado

ln -s /etc/nginx/sites-available/phpmyadmin /etc/nginx/sites-enabled/

y reiniciamos NGINX para que lea la nueva configuración:

service nginx restart

Por último vamos a probar si está sirviendo en el puerto que hemos configurado (el 81) introduciendo el dominio/ip seguido de :81, algo como 111.222.333.444:81 (esta ip es de pega)
Nos debería dar la bienvenida la página de login de phpmyadmin.

Ahora, si tenéis algunas tablas de la base de datos que queráis importar podéis hacerlo mediante la terminal con

mysql -u username -p database_name < dumpfile.sql

Comprobamos antes de continuar que todo está correctamente ejecutando

./manage.py validate

Y pasamos a configurar el sitio que servirá NGINX en /etc/nginx/sites-available/proyecto y luego hacemos un soft link a él en /sites-enabled/


server {
index index.html index.htm index.php;
#client_max_body_size i8M;

# Make site accessible from http://localhost/
listen 82;
#server_name tu.dominio.com;

location /media/ { # MEDIA_URL
root /var/www/proyecto/ruta/a/carpeta/padre/de/media; # MEDIA_ROOT
autoindex off;
access_log off;
expires 30d;
}

location /static/ { # STATIC_URL
root /var/www/proyecto/ruta/a/carpeta/padre/de/static; # STATIC_ROOT
autoindex off;
access_log off;
expires 30d;
}

location /favicon.ico {
root /var/www/proyecto/ruta/a/carpeta/padre/de/favicon.ico;
try_files $uri $uri/ /static/img/favicon.png;
autoindex off;
access_log off;
expires 30d;
}

# Serve shakingjobs django project at /var/www
location / {
root /var/www/proyecto/ruta/a/manage.py; # Ej /var/www/proyecto/miproyecto , no incluir manage.py
proxy_pass_header Server;
proxy_set_header Host $http_host;
proxy_redirect off;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Scheme $scheme;
proxy_connect_timeout 60;
proxy_read_timeout 60;
proxy_pass http://localhost:8000/; # puerto local en el que se lanzará el servidor gunicorn
}
}

Probaremos a lanzar el servidor gunicorn y a reiniciar el servidor NGINX con:


./manage.py run_gunicorn &
service nginx restart

Acudiendo a tu.direccion.ip:82 deberás encontrar tu proyecto ejecutándose. Si va bien podemos adornar un poquito el lanzamiento de gunicorn, controlar logs y similar con un script un poco más detallado como un runserver.sh:


#!/bin/bash
set -e
LOGFILE=/var/log/gunicorn/proyecto.log
LOGDIR=$(dirname $LOGFILE)
NUM_WORKERS=3
cd /var/www/ruta/a/proyecto/
source /home/django/.virtualenvs/proyecto/bin/activate
test -d $LOGDIR || mkdir -p $LOGDIR
exec gunicorn_django -w $NUM_WORKERS \
--log-level=debug --bind=127.0.0.1:8002 \
--log-file=$LOGFILE 2>>$LOGFILE

Bien, sólo queda automatizar el lanzamiento de gunicorn en cada inicio del sistema. Esto se hace creando un archivo de configuración en /etc/init/proyecto.conf con un contenido similar a:


description "My Project gunicorn instance"
start on runlevel [2345]
stop on runlevel [06]
respawn
respawn limit 10 5
exec /var/www/proyecto/runserver.sh

Y tras eso habilitarlo como servicio con la orden:

ln -s /lib/init/upstart-job /etc/init.d/proyecto

Con eso podremos arrancar el servicio con service proyecto start y detenerlo con service proyecto stop, además de que se iniciará en los niveles 2, 3, 4 y 5 del sistema

 

Instalar y configurar un entorno virtual con Django y Compass para utilizar SASS

septiembre 26, 2011 at 9:51 am | Blog, Django, Sass, virtualenv | No comment

 

Guía breve para instalar y configurar Django + Compass bajo un entorno virtual en Archlinux.

En primer lugar me parece una herramienta indisplensable VirtualEnv y la utilidad virtualenvwrapper, que nos permitirá tener nuestros entornos de desarrollo separados para cada proyecto. Por lo tanto lo primero es instalarlo:

sudo pacman -Sy python-virtualenvwrapper

Una vez descargado e instalado, vamos a configurar el entorno creando la carpeta ~/.envs y añadiendo a nuestro ~/.bashrc las líneas

export WORKON_HOME=~/.envs
source /usr/bin/virtualenvwrapper.sh 

Refresca la terminal (source ~/.bashrc) y ya podemos empezar a utilizar nuestros entornos separados. Fácil ¿no?
Vamos a crear un primer entorno:

mkvirtualenv -p /usr/bin/python2.7 --no-site-packages nombre

El parámetro -p nos permitirá indicarle qué versión de Python debe usarse, útil si tienes versiones más antiguas en servidores en producción que no puedes actualizar y debes instalar el entorno de desarrollo con las mismas características. El otro parámetro –no-site-packages indica al entorno que no utilice el directorio site-packages general del sistema operativo. Con eso tendremos entornos limpios y verdaderamente independientes. Por último se le indica el nombre del entorno.

Hecho eso nos movemos a nuestro entorno simplemente con:

workon nombre

Ya está. Si te fijas, el prompt habrá cambiado a algo parecido a (nombre)usuario@maquina ~ $, el (nombre) denota que estamos dentro del entorno virtual. Vamos a empezar a instalar programas:

pip install django hg+https://bitbucket.org/slafs/django-compass

Añadimos django-compass a nuestras INSTALLED_APPS y para utilizar compass y poder generar nuestro css a partir de SASS vamos a instalar ruby

sudo pacman -S ruby

Y configurarlo para que instale las gemas en el directorio de nuestro entorno virtual, añadiendo al archivo ~/.envs/postactivate las líneas:

export GEM_HOME=$VIRTUAL_ENV/gems
export GEM_PATH=""

A continuación, salimos y volvemos a entrar al entorno para que tenga en cuenta los últimos cambios: esto se hace con los comandos “deactivate” y “workon nombre” de nuevo. Y ya podemos instalar las gemas compass y compass-less-plugins (que me parece un maravilloso framework para poder obtener diseños “responsivos”)

gem install compass compass-less-plugin

Hay un problemilla con compass-less-plugin y es que creo que no se registra correctamente, así que vamos a ~/.envs/nombre/gems/compass-(version)/frameworks y creamos la carpeta less, dentro de ella pegamos las carpetas stylesheets y templates de ~/.envs/nombre/gems/compass-less-plugin-(version).
Y ahora tenemos que configurar compass para que trabaje en las carpetas que queramos:

~/.envs/nombre/gems/bin/compass create -r less estilos --using less
mv estilos/sass sass
mv estilos/config.rb config.rb
rm -rf estilos

Abre config.rb y adáptalo a la configuración particular de tu proyecto. Configuraremos también el settings.py de nuestro proyecto añadiendo algo como:

COMPASS_INPUT = os.path.join(SITE_ROOT, 'static_media', 'sass') # adáptalo
COMPASS_OUTPUT = os.path.join(SITE_ROOT, 'static_media', 'css') # adáptalo
COMPASS_STYLE = 'compact'
COMPASS_EXECUTABLE = '/home/javi/.envs/nombre/gems/bin/compass'

Por último, sólo queda arrancar el servidor de pruebas y poner compass en modo vigilante para compilar los cambios que hagamos a los archivos .scss automáticamente:

En una terminal: python manage.py runserver
En otra: python manage.py compass watch

Fuentes:
Este artículo se basa en la estupenda exposición “Responsive web design with Django, Compass and the Less framework“, de Idan Gazit en la DjangoCon 2011

 

Categorias:

Archivo: