Cómo instalar Django Python Framework en Ubuntu 22.04

Django es un framework python utilizado para desarrollar sitios web y aplicaciones dinámicas. Sigue la arquitectura MVC (Modelo-Vista-Controlador). Utilizar Django acelera el proceso de desarrollo, ya que se encarga de la mayoría de las tareas subyacentes.

Este tutorial te enseñará a instalar el framework Django en un servidor Ubuntu 22.04. También crearás un proyecto de demostración y lo probarás.

Requisitos previos

• Un servidor con Ubuntu 22.04.
• Un usuario sudo no root.
• Asegúrate de que todo está actualizado.

  $ sudo apt update 
  $ sudo apt upgrade
  

Instalar Django

Existen varios métodos para instalar Django. Decidir cuál te conviene más depende de cómo quieras configurar tu entorno de desarrollo y de tus necesidades. Cada método tiene sus pros y sus contras. Repasemos todos estos métodos.

Instalar desde los repositorios de Ubuntu

El método más sencillo para instalar Django es utilizar los repositorios de Ubuntu. Ubuntu 22.04 incluye Python 3.10. Puedes verificarlo utilizando el siguiente comando.

$ python3 -V
Python 3.10.4

Instala Django utilizando el siguiente comando.

$ sudo apt install python3-django

Ejecuta el siguiente comando para verificar que la instalación se ha realizado correctamente.

$ django-admin --version
3.2.12

La versión de Django suministrada con Ubuntu es la versión LTS actual, soportada hasta 2024. Sin embargo, no es la versión actual. Si quieres instalar una versión reciente, este método no es para ti.

Instalar con pip

Esta es la forma más común de instalar Django. La forma recomendada de hacerlo es creando un entorno virtual Python. Esto te permite instalar paquetes Python sin afectar al sistema.

Instala los módulos pip y venv. venv se utiliza para crear entornos virtuales Python y pip instala paquetes Python.

$ sudo apt install python3-pip python3-venv

Vamos a crear un directorio de proyecto de demostración.

$ mkdir ~/sampleproject
$ cd ~/sampleproject

Crea un entorno virtual utilizando el siguiente comando. Sustituye sample_env por el nombre con el que quieras llamar a tu entorno virtual.

$ python3 -m venv sample_env

Esto instala una versión portable de Python, pip dentro del directorio de tu proyecto. Para instalar cualquier paquete en el proyecto, debes activar el entorno utilizando el siguiente comando.

$ source sample_env/bin/activate

Tu intérprete de comandos cambiará para reflejar el entorno virtual.

(sample_env) navjot@django:~/sampleproject$

Ahora que el entorno virtual está activado, utiliza pip para instalar Django. Ejecuta el siguiente comando para instalar Django.

(sample_env) $ pip install django

Verifica la instalación.

(sample_env) $ django-admin --version
4.0.5

Dependiendo de los requisitos de tu proyecto, puedes instalar una versión diferente de Django de la siguiente manera.

(sample_env) $ pip install django==3.2.1

Verifica la instalación.

(sample_env) $ django-admin --version
3.2.1

Como puedes ver, este método instala una versión de Django más reciente que la versión obtenida del repositorio de Ubuntu.

Para salir del entorno virtual, ejecuta el siguiente comando.

(sample_env) $ deactivate

Instalar la versión de desarrollo

También puedes utilizar pip para instalar la versión de desarrollo de Django. Para ello, tomaremos la versión de desarrollo del repositorio Github de Django.

Clona el repositorio en el directorio ~/django-dev utilizando el siguiente comando.

$ git clone https://github.com/django/django ~/django-dev

Cambia al directorio recién creado.

$ cd ~/django-dev

Crea el entorno virtual.

$ python3 -m venv dev_django_env

Activa el entorno.

$ source dev_django_env/bin/activate

Instala Django utilizando pip. La bandera -e lo instala en modo editable, lo cual es necesario si instalas desde el control de versiones.

(dev_django_dev) $ pip install -e ~/django-dev

Verifica la instalación.

(dev_django_dev) $ django-admin --version
4.2.dev20220628195651

Como puedes ver, la versión que aparece aquí es la última versión de desarrollo. La versión de desarrollo de Django no es útil para entornos de producción.

Crear un proyecto de ejemplo

Vamos a crear un proyecto Django de ejemplo. Crea un directorio para el proyecto de ejemplo.

$ mkdir ~/dj-sample
$ cd ~/dj-sample

Crea un entorno virtual Python.

$ python3 -m venv sample_proj

Activa el entorno.

$ source sample_proj/bin/activate

Instala Django.

(sample_proj) $ pip install django

Para construir el proyecto, necesitamos utilizar el comando startproject. Este comando crea otro directorio que incluye

• Un script de gestión, manage.py, utilizado para administrar tareas específicas de Django.
• Un directorio con el mismo nombre que el proyecto que incluye el código del proyecto.

Crearemos el directorio del proyecto en nuestro directorio de trabajo actual. Para ello, utiliza el carácter punto(.) al final del siguiente comando.

(sample_proj) $ django-admin startproject demoproject .

A continuación, tenemos que migrar la base de datos utilizando el comando migrate. Las migraciones en Django propagan los cambios que hagas en tus modelos al esquema de tu base de datos. Python utiliza por defecto la base de datos SQLite.

(sample_proj) $ python manage.py migrate

Obtendrás la siguiente salida.

Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying admin.0003_logentry_add_action_flag_choices... OK
  Applying contenttypes.0002_remove_content_type_name... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  Applying auth.0005_alter_user_last_login_null... OK
  Applying auth.0006_require_contenttypes_0002... OK
  Applying auth.0007_alter_validators_add_error_messages... OK
  Applying auth.0008_alter_user_username_max_length... OK
  Applying auth.0009_alter_user_last_name_max_length... OK
  Applying auth.0010_alter_group_name_max_length... OK
  Applying auth.0011_update_proxy_permissions... OK
  Applying auth.0012_alter_user_first_name_max_length... OK
  Applying sessions.0001_initial... OK

A continuación, crea un usuario administrador para acceder a la interfaz de administración de Django.

(sample_proj) $ python manage.py createsuperuser

Se te pedirá un nombre de usuario, un correo electrónico y una contraseña.

Username (leave blank to use 'navjot'):
Email address: [email protected]
Password:
Password (again):
Superuser created successfully.

Probar el servidor de desarrollo

Es hora de probar la aplicación. Para ello, necesitas modificar la directiva ALLOWED_HOSTS en la configuración de Django. Esta directiva define la lista de direcciones IP y nombres de dominio que tienen acceso a la aplicación Django.

Abre el archivo de configuración utilizando el siguiente comando.

(sample_proj) $ nano demoproject/settings.py

Busca la siguiente entrada.

ALLOWED_HOSTS = []

Introduce la dirección IP de tu servidor entre los corchetes. Cada entrada debe ir entre comillas y las entradas múltiples deben separarse mediante comas. Si introduces www.example.com, coincidirá exactamente. Sin embargo, .example.com coincidirá con example.com y www.example.com, y con cualquier otro subdominio de example.com. Por tanto, se recomienda utilizar el signo de punto como prefijo de un nombre de dominio para que coincida con él y sus subdominios.

ALLOWED_HOSTS = ['<yourserver_ip_address>']

Hemos utilizado la dirección IP para que coincida con nuestro servidor. Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

Antes de probar el servidor de desarrollo, debes configurar el cortafuegos para permitir que Django funcione. Django utiliza el puerto 8000 por defecto. Abre el puerto utilizando el cortafuegos sin complicaciones (UFW).

(sample_proj) $ sudo ufw allow 8000

Inicia el servidor de desarrollo.

(sample_proj) $ python manage.py runserver 0.0.0.0:8000

Inicia la URL http://<yourserver_ip_address>:8000 en tu navegador y obtendrás la siguiente pantalla.

Puedes acceder a la interfaz de administración siguiendo la URL http://<yourserver_ip_address>:8000/admin/ y verás la siguiente pantalla de inicio de sesión.

Introduce las credenciales creadas anteriormente para acceder al panel de administración que se muestra a continuación.

Una vez que termines tu proyecto de demostración, puedes cerrar el servidor pulsando Ctrl + C en tu terminal.

Instalar y probar Gunicorn

Ejecuta el servidor Django persistente utilizando nohup

Hasta ahora, el servicio de Django no es persistente. Para hacer que el servicio sea persistente, existen dos métodos. El primer método consiste en utilizar la utilidad nohup. nohup es un comando POSIX que significa no colgar. Se utiliza para ejecutar comandos de forma que no se detengan aunque un usuario cierre la sesión.

Asegúrate de que has salido del servidor desde el terminal pulsando Ctrl + C.

Ejecuta el siguiente comando para ejecutar el servidor de desarrollo de Django.

(sample_proj) $ nohup python manage.py runserver 0.0.0.0:8000 &

Ahora, tu servidor Django seguirá ejecutándose hasta que lo mates manualmente. El comando te dará el ID del proceso y mostrará otro comando.

[1] 42595
(sample_proj) $ nohup: ignoring input and appending output to 'nohup.out'
^C

Pulsa Ctrl + C para salir. El servidor Django original seguirá funcionando. Puedes comprobarlo abriendo la URL en tu navegador.

Cuando hayas terminado, tienes que matar el proceso. El comando nohup te da un ID de proceso. Pero en realidad, se están ejecutando dos procesos. Para encontrar los ID de ambos procesos, ejecuta el siguiente comando.

(sample_proj) $ ps aux | grep manage.py
navjot     42650  3.6  1.8  47792 38168 pts/0    S    02:28   0:00 python manage.py runserver 0.0.0.0.:8000
navjot     42651  7.9  2.0 344904 41708 pts/0    Sl   02:28   0:00 /home/navjot/dj-sample/sample_proj/bin/python manage.py runserver 0.0.0.0:8000
navjot     42657  0.0  0.1   6612  2172 pts/0    S+   02:28   0:00 grep --color=auto manage.py

Como puedes ver, se están ejecutando dos procesos, uno con ID 42650 y otro con ID 42651.

Ejecuta el siguiente comando para cerrar el servidor utilizando los ID de proceso que has obtenido anteriormente.

(sample_proj) $ sudo kill -9 42650 42651

Instalar Gunicorn

El segundo método para ejecutar un servidor Django persistente requiere que instales los servidores web Gunicorn y Nginx. Gunicorn es un servidor HTTP WSGI de Python. Interactuará con la aplicación Django y luego Nginx actuará como proxy inverso hacia Gunicorn. Este método tiene la ventaja añadida de proporcionarte la seguridad y el rendimiento que conlleva el uso de Nginx.

Instala Gunicorn.

(sample_proj) $ pip install gunicorn

Antes de continuar, necesitamos probar la capacidad de Gunicorn para servir el proyecto. Ejecuta el siguiente comando para ejecutar Gunicorn.

(sample_proj) $ gunicorn --bind 0.0.0.0:8000 demoproject.wsgi

Esto iniciará Gunicorn en la misma interfaz en la que se estaba ejecutando Django. Para verificarlo, abre la URL http://<yourserver_ip_address>:8000 en tu navegador y obtendrás la misma página de inicio de Django. Esto significa que Gunicorn se está ejecutando perfectamente.

Cuando hayas terminado las pruebas, pulsa Ctrl + C en el terminal para salir de Gunicorn.

Desactiva el entorno virtual para volver a tu shell habitual.

(sample_proj) $ deactivate

Crear un socket y un archivo de servicio para Gunicorn

El primer paso es crear un archivo de socket de Gunicorn. El socket de Gunicorn se creará en el momento del arranque y escuchará las conexiones. Cuando se produzca una conexión, el systems iniciará automáticamente el proceso Gunicorn para gestionarla.

Crea y abre el archivo del socket Gunicorn para editarlo.

$ sudo nano /etc/systemd/system/gunicorn.socket

Pega en él el siguiente código.

[Unit]
Description=gunicorn socket

[Socket]
ListenStream=/run/gunicorn.sock

[Install]
WantedBy=sockets.target

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

A continuación, crea y abre el archivo de servicio de Gunicorn para editarlo.

$ sudo nano /etc/systemd/system/gunicorn.service

Introduce en él el siguiente código.

[Unit]
Description=django gunicorn daemon
Requires=gunicorn.socket
After=network.target

[Service]
User=navjot
Group=nginx
WorkingDirectory=/home/navjot/dj-sample
ExecStart=/home/navjot/dj-sample/sample_proj/bin/gunicorn \
          --access-logfile - \
          --workers 3 \
          --bind unix:/run/gunicorn.sock \
          demoproject.wsgi:application

[Install]
WantedBy=multi-user.target

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite. Sustituye navjot por el nombre de usuario de tu sistema. El grupo nginx permitirá al servidor Nginx comunicarse con Django.

Recarga el demonio del sistema para actualizar los archivos systemd.

$ sudo systemctl daemon-reload

Habilita e inicia el archivo de sockets Gunicorn.

$ sudo systemctl start gunicorn.socket
$ sudo systemctl enable gunicorn.socket

Comprueba el estado del socket Gunicorn.

$ sudo systemctl status gunicorn.socket

Recibirás una salida similar.

? gunicorn.socket - gunicorn socket
     Loaded: loaded (/etc/systemd/system/gunicorn.socket; disabled; vendor preset: enabled)
     Active: active (listening) since Thu 2022-06-30 01:43:24 UTC; 20s ago
   Triggers: ? gunicorn.service
     Listen: /run/gunicorn.sock (Stream)
     CGroup: /system.slice/gunicorn.socket

Jun 30 01:43:24 django systemd[1]: Listening on gunicorn socket.

Como puedes comprobar, el servicio Gunicorn todavía no se está ejecutando.

$ sudo systemctl status gunicorn.service
? gunicorn.service - django gunicorn daemon
     Loaded: loaded (/etc/systemd/system/gunicorn.service; disabled; vendor preset: enabled)
     Active: inactive (dead)
TriggeredBy: ? gunicorn.socket

Para probar el mecanismo de activación del socket, ejecuta el siguiente comando.

$ curl --unix-socket /run/gunicorn.sock localhost

Recibirás la salida HTML de la página principal de Django en tu terminal. Esto también inicia Gunicorn para servir la aplicación. Comprueba de nuevo el estado del servicio y verás que ahora se está ejecutando.

$ sudo systemctl status gunicorn.service
? gunicorn.service - django gunicorn daemon
     Loaded: loaded (/etc/systemd/system/gunicorn.service; disabled; vendor preset: enabled)
     Active: active (running) since Thu 2022-06-30 01:45:09 UTC; 12s ago
TriggeredBy: ? gunicorn.socket
   Main PID: 42365 (gunicorn)
      Tasks: 4 (limit: 2241)
     Memory: 91.7M
        CPU: 1.128s
     CGroup: /system.slice/gunicorn.service
             ??42365 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application
             ??42366 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application
             ??42367 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application
             ??42368 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application

Jun 30 01:45:09 django systemd[1]: Started django gunicorn daemon.
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Starting gunicorn 20.1.0
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Listening at: unix:/run/gunicorn.sock (42365)
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Using worker: sync
Jun 30 01:45:09 django gunicorn[42366]: [2022-06-30 01:45:09 +0000] [42366] [INFO] Booting worker with pid: 42366
.......

Instalar Nginx

El último paso es instalar y configurar Nginx. Ubuntu 22.04 viene con una versión antigua de Nginx. Necesitas descargar el repositorio oficial de Nginx para instalar la última versión.

Importa la clave de firma de Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Añade el repositorio de la versión estable de Nginx.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list

Actualiza los repositorios del sistema.

$ sudo apt update

Instala Nginx.

$ sudo apt install nginx

Verifica la instalación.

$ nginx -v
nginx version: nginx/1.22.0

Configurar Nginx

Crea y abre el archivo /etc/nginx/conf.d/django-gunicorn.conf para editarlo.

$ sudo nano /etc/nginx/conf.d/django-gunicorn.conf

Pega en él el siguiente código.

server {
    listen 80;
    server_name server_domain_or_IP;

    location = /favicon.ico { access_log off; log_not_found off; }
    location /static/ {
        root /home/navjot/dj-sample;
    }

    location / {
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_pass http://unix:/run/gunicorn.sock;
    }
}

Sustituye la ubicación raíz del archivo anterior por el directorio de tu servidor.

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

Abre el archivo /etc/nginx/nginx.conf para editarlo.

$ sudo nano /etc/nginx/nginx.conf

Añade la siguiente línea antes de la línea include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

Comprueba la configuración de Nginx.

$ sudo nginx -t

Si no ves ningún error, significa que puedes continuar.

También tendrás que añadir el nombre de dominio a tu directiva ALLOWED_HOSTS. Abre el archivo settings.py.

$ nano ~/dj-sample/demoproject/settings.py

Cambia el valor de la variable ALLOWED_HOSTS.

ALLOWED_HOSTS = ['<yourserver_ip_address>','django.example.com']

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.

Reinicia Gunicorn Socket y Service.

$ sudo systemctl restart gunicorn.socket
$ sudo systemctl restart gunicorn.service

Inicia el servidor Nginx.

$ sudo systemctl start nginx

Abre el puerto HTTP. También puedes eliminar el puerto 8000 si ya no lo vas a utilizar.

$ sudo ufw delete allow 8000
$ sudo ufw allow http

Compruébalo abriendo la URL http://django.example.com y se cargará la página principal de Django.

Instalar SSL

Hasta ahora, tu aplicación Django se está sirviendo a través de una conexión HTTP de texto plano. Es muy recomendable que la protejas mediante un certificado SSL. Para ello, utiliza la herramienta Certbot con la herramienta Snapd. Ya está instalada en un sistema Ubuntu 22.04.

Instala el repositorio principal de Snapd.

$ sudo snap install core

Instala Certbot.

$ sudo snap install --classic certbot
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Genera el certificado. El siguiente comando también configurará automáticamente Nginx.

$ sudo certbot --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d django.example.com

Abre primero el puerto HTTPS.

$ sudo ufw allow https

Visita la URL https://django.example.com en tu navegador para confirmarlo.

Conclusión

Con esto concluye nuestro tutorial, en el que has aprendido a instalar Django y Gunicorn y Nginx en un servidor Ubuntu 22.04. También has instalado un certificado SSL para mejorar la seguridad de tu proyecto Django. Si tienes alguna pregunta, publícala en los comentarios a continuación.