Cómo instalar el marco Django de Python en Ubuntu 22.04

Django es un marco de Python utilizado para desarrollar sitios web y aplicaciones dinámicas. Sigue la arquitectura MVC (Modelo-Vista-Controlador). Usar Django acelera el proceso de desarrollo, ya que la mayoría de las tareas subyacentes son manejadas por él.

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

Prerrequisitos

• Un servidor que ejecute Ubuntu 22.04.
• Un usuario sudo que no sea root.
• Asegúrate de que todo esté actualizado. $ sudo apt update $ sudo apt upgrade

Instalar Django

Hay varios métodos por los cuales puedes instalar Django. Decidir cuál funciona mejor para ti depende de cómo quieras configurar tu entorno de desarrollo y tus necesidades. Cada método tiene su propio conjunto de ventajas y desventajas. Vamos a repasar todos estos métodos.

Instalar desde los repositorios de Ubuntu

El método más simple para instalar Django es usar los repositorios de Ubuntu. Ubuntu 22.04 viene con Python 3.10. Puedes verificarlo usando el siguiente comando.

$ python3 -V
Python 3.10.4

Instala Django usando el siguiente comando.

$ sudo apt install python3-django

Ejecuta el siguiente comando para verificar la instalación exitosa.

$ django-admin --version
3.2.12

La versión de Django que se envía con Ubuntu es la versión LTS actual que está soportada hasta 2024. Sin embargo, no es la versión actual. Si deseas instalar una versión reciente, este método no es para ti.

Instalar usando pip

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

Instala el módulo pip y venv. venv se utiliza para crear entornos virtuales de Python y pip instala paquetes de 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 usando el siguiente comando. Reemplaza sample_env con el nombre que deseas darle a tu entorno virtual.

$ python3 -m venv sample_env

Esto instala una versión portátil de Python, pip dentro de tu directorio de proyecto. Para instalar cualquier paquete en el proyecto, debes activar el entorno usando el siguiente comando.

$ source sample_env/bin/activate

Tu indicador de shell cambiará para reflejar el entorno virtual.

(sample_env) navjot@django:~/sampleproject$

Ahora que el entorno virtual está activado, usa 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 más nueva de Django 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 usar pip para instalar la versión de desarrollo de Django. Para esto, obtendremos la versión de desarrollo del repositorio de Github de Django.

Clona el repositorio en el directorio ~/django-dev usando 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 usando pip. La bandera -e lo instala en un modo editable que es necesario si estás instalando 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 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 muestra

Vamos a construir un proyecto Django de muestra. Crea un directorio para el proyecto de muestra.

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

Crea un entorno virtual de 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 usar 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 hacer eso, usa el carácter punto (.) al final del siguiente comando.

(sample_proj) $ django-admin startproject demoproject .

A continuación, necesitamos migrar la base de datos usando el comando migrate. Las migraciones en Django propagan los cambios que realizas en tus modelos a tu esquema de base de datos. Python utiliza la base de datos SQLite por defecto.

(sample_proj) $ python manage.py migrate

Obtendrás la siguiente salida.

Operaciones a realizar:
  Aplicar todas las migraciones: admin, auth, contenttypes, sessions
Ejecutando migraciones:
  Aplicando contenttypes.0001_initial... OK
  Aplicando auth.0001_initial... OK
  Aplicando admin.0001_initial... OK
  Aplicando admin.0002_logentry_remove_auto_add... OK
  Aplicando admin.0003_logentry_add_action_flag_choices... OK
  Aplicando contenttypes.0002_remove_content_type_name... OK
  Aplicando auth.0002_alter_permission_name_max_length... OK
  Aplicando auth.0003_alter_user_email_max_length... OK
  Aplicando auth.0004_alter_user_username_opts... OK
  Aplicando auth.0005_alter_user_last_login_null... OK
  Aplicando auth.0006_require_contenttypes_0002... OK
  Aplicando auth.0007_alter_validators_add_error_messages... OK
  Aplicando auth.0008_alter_user_username_max_length... OK
  Aplicando auth.0009_alter_user_last_name_max_length... OK
  Aplicando auth.0010_alter_group_name_max_length... OK
  Aplicando auth.0011_update_proxy_permissions... OK
  Aplicando auth.0012_alter_user_first_name_max_length... OK
  Aplicando sessions.0001_initial... OK

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

(sample_proj) $ python manage.py createsuperuser

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

Nombre de usuario (dejar en blanco para usar 'navjot'):
Dirección de correo electrónico: [email protected]
Contraseña:
Contraseña (nuevamente):
Superusuario creado con éxito.

Probar el servidor de desarrollo

Es hora de probar la aplicación. Para eso, 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 usando el siguiente comando.

(sample_proj) $ nano demoproject/settings.py

Busca la siguiente entrada.

ALLOWED_HOSTS = []

Ingresa la dirección IP de tu servidor en los corchetes. Cada entrada debe estar entre comillas y múltiples entradas deben estar separadas por comas. Ingresar www.example.com se emparejará exactamente. Sin embargo, .example.com se emparejará con example.com y www.example.com, y cualquier otro subdominio de example.com. Por lo tanto, se recomienda usar el signo de punto para prefijar un nombre de dominio para emparejarlo y sus subdominios.

ALLOWED_HOSTS = ['']

Hemos utilizado la dirección IP para emparejar nuestro servidor. Guarda el archivo presionando Ctrl + X y ingresando Y cuando se te pida.

Antes de probar el servidor de desarrollo, necesitas configurar el firewall para permitir que Django funcione. Django utiliza el puerto 8000 por defecto. Abre el puerto usando el Firewall 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

Lanza la URL http://:8000 en tu navegador y obtendrás la siguiente pantalla.

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

Ingresa las credenciales creadas anteriormente para iniciar sesión en el panel de administración que se muestra a continuación.

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

Instalar y probar Gunicorn

Ejecutar un servidor Django persistente usando nohup

Hasta ahora, el servicio de Django no es persistente. Para hacer que el servicio sea persistente, hay dos métodos. El primer método implica usar la utilidad nohup. El nohup es un comando POSIX que significa no colgar. Se utiliza para ejecutar comandos de una manera que no se detiene incluso cuando un usuario cierra sesión.

Asegúrate de haber salido del servidor desde la terminal presionando 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á funcionando hasta que lo mates manualmente. El comando te dará el ID del proceso y mostrará otro comando.

[1] 42595
(sample_proj) $ nohup: ignorando la entrada y agregando la salida a 'nohup.out'
^C

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

Una vez que hayas terminado, necesitas matar el proceso. El comando nohup te da un ID de proceso. Pero en realidad, se están ejecutando dos procesos. Para encontrar los IDs 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 el otro con ID 42651.

Ejecuta el siguiente comando para cerrar el servidor usando los IDs de proceso que obtuviste anteriormente.

(sample_proj) $ sudo kill -9 42650 42651

Instalar Gunicorn

El segundo método para ejecutar un servidor Django persistente requiere que instales Gunicorn y servidores web Nginx. Gunicorn es un servidor HTTP WSGI de Python. Interfacing con la aplicación Django y luego Nginx actuará como un proxy inverso para Gunicorn. Este método tiene el beneficio adicional de proporcionarte la seguridad y el rendimiento que viene con 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 estaba funcionando Django. Para verificar, abre la URL http://:8000 en tu navegador y obtendrás la misma página de inicio de Django. Esto significa que Gunicorn está funcionando perfectamente.

Cuando termines de probar, presiona Ctrl + C en la terminal para salir de Gunicorn.

Desactiva el entorno virtual para volver a tu shell habitual.

(sample_proj) $ deactivate

Crear un archivo de socket y 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á conexiones. Cuando ocurre una conexión, el sistema iniciará automáticamente el proceso de Gunicorn para manejarlo.

Crea y abre el archivo de socket de Gunicorn para editar.

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

Pega el siguiente código en él.

[Unit]
Description=socket de gunicorn

[Socket]
ListenStream=/run/gunicorn.sock

[Install]
WantedBy=sockets.target

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.

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

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

Pega el siguiente código en él.

[Unit]
Description=daemon gunicorn de django
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 presionando Ctrl + X y entrando Y cuando se te pida. Reemplaza navjot con tu nombre de usuario del sistema. El grupo nginx permitirá que el servidor Nginx se comunique con Django.

Recarga el demonio del sistema para refrescar los archivos de systemd.

$ sudo systemctl daemon-reload

Habilita e inicia el archivo de socket de Gunicorn.

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

Verifica el estado del socket de Gunicorn.

$ sudo systemctl status gunicorn.socket

Recibirás una salida similar.

? gunicorn.socket - socket de gunicorn
     Cargado: cargado (/etc/systemd/system/gunicorn.socket; deshabilitado; preset del proveedor: habilitado)
     Activo: activo (escuchando) desde Thu 2022-06-30 01:43:24 UTC; hace 20s
   Disparadores: ? gunicorn.service
     Escuchar: /run/gunicorn.sock (Stream)
     CGroup: /system.slice/gunicorn.socket

Jun 30 01:43:24 django systemd[1]: Escuchando en el socket de gunicorn.

El servicio de Gunicorn aún no está en ejecución como puedes comprobar.

$ sudo systemctl status gunicorn.service
? gunicorn.service - daemon gunicorn de django
     Cargado: cargado (/etc/systemd/system/gunicorn.service; deshabilitado; preset del proveedor: habilitado)
     Activo: inactivo (muerto)
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 de inicio de Django en tu terminal. Esto también inicia Gunicorn para servir la aplicación. Verifica el estado del servicio nuevamente y verás que ahora está en ejecución.

$ sudo systemctl status gunicorn.service
? gunicorn.service - daemon gunicorn de django
     Cargado: cargado (/etc/systemd/system/gunicorn.service; deshabilitado; preset del proveedor: habilitado)
     Activo: activo (en ejecución) desde Thu 2022-06-30 01:45:09 UTC; hace 12s
TriggeredBy: ? gunicorn.socket
   PID principal: 42365 (gunicorn)
      Tareas: 4 (límite: 2241)
     Memoria: 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]: Iniciado el daemon gunicorn de django.
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Iniciando gunicorn 20.1.0
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Escuchando en: unix:/run/gunicorn.sock (42365)
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Usando trabajador: sync
Jun 30 01:45:09 django gunicorn[42366]: [2022-06-30 01:45:09 +0000] [42366] [INFO] Iniciando trabajador con pid: 42366
.......

Instalar Nginx

El último paso es instalar y configurar Nginx. Ubuntu 22.04 viene con una versión más 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

Agrega el repositorio para 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 editar.

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

Pega el siguiente código en él.

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;
    }
}

Reemplaza la ubicación raíz en el archivo anterior con el directorio en tu servidor.

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.

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

$ sudo nano /etc/nginx/nginx.conf

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

server_names_hash_bucket_size  64;

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.

Verifica tu configuración de Nginx.

$ sudo nginx -t

Si no ves errores, significa que estás listo para continuar.

También necesitarás agregar 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 = ['','django.example.com']

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.

Reinicia el socket y el servicio de Gunicorn.

$ 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 no lo vas a usar más.

$ sudo ufw delete allow 8000
$ sudo ufw allow http

Verifica abriendo la URL http://django.example.com y la página de inicio de Django se cargará.

Instalar SSL

Hasta ahora, tu aplicación Django se está sirviendo a través de una conexión HTTP en texto plano. Se recomienda encarecidamente que la protejas a través de un certificado SSL. Para esto, usa la herramienta Certbot utilizando 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 confirmar.

Conclusión

Esto concluye nuestro tutorial, donde aprendiste cómo instalar Django y Gunicorn y Nginx en un servidor Ubuntu 22.04. También instalaste un certificado SSL para mejorar la seguridad de tu proyecto Django. Si tienes alguna pregunta, publícalas en los comentarios a continuación.