Cómo instalar Django con Postgres, Nginx y Gunicorn en Rocky Linux 9
Django es un framework python utilizado para desarrollar sitios web y aplicaciones dinámicas. Sigue la arquitectura MVC (Modelo-Vista-Controlador). El uso de Django acelera el proceso de desarrollo de aplicaciones, ya que se encarga de la mayoría de las tareas subyacentes.
En este tutorial, aprenderás a instalar el framework Django en un servidor Rocky Linux 9. También crearás un proyecto de demostración y lo probarás.
Requisitos previos
- Un servidor que ejecute Rocky Linux 9.
- Un usuario no root con privilegios sudo.
- Un nombre de dominio completo (FQDN) que apunte a tu servidor. Para nuestros propósitos, utilizaremos
django.example.comcomo nombre de dominio. - Asegúrate de que todo está actualizado.
$ sudo dnf update
- Instala los paquetes de utilidades básicas. Puede que algunos de ellos ya estén instalados.
$ sudo dnf install wget curl nano unzip yum-utils -y
- Desactiva SELinux.
Paso 1 – Configurar el cortafuegos
El primer paso es configurar el cortafuegos. Rocky Linux utiliza el cortafuegos Firewalld. Comprueba el estado del cortafuegos.
$ sudo firewall-cmd --state running
El cortafuegos funciona con diferentes zonas, y la zona pública es la que utilizaremos por defecto. Enumera todos los servicios y puertos activos en el cortafuegos.
$ sudo firewall-cmd --permanent --list-services
Debería mostrar la siguiente salida.
cockpit dhcpv6-client ssh
Django necesita los puertos HTTP y HTTPS para funcionar. Ábrelos.
$ sudo firewall-cmd --add-service=http --permanent $ sudo firewall-cmd --add-service=https --permanent
Recarga el cortafuegos para aplicar los cambios.
$ sudo firewall-cmd --reload
Paso 2 – Instalar PostgreSQL y utilidades
Rocky Linux 9 viene con una versión antigua de PostgreSQL. Instalaremos Postgres 14 para nuestro tutorial.
Instala el repositorio RPM para PostgreSQL.
$ sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm
Instala el servidor PostgreSQL 14.
$ sudo dnf install -y postgresql14-server postgresql14-contrib postgresql14-devel python3-psycopg2
Inicializa la base de datos.
$ sudo /usr/pgsql-14/bin/postgresql-14-setup initdb
Habilita e inicia el servicio PostgreSQL.
$ sudo systemctl enable postgresql-14 --now
Comprobar el estado del servicio.
$ sudo systemctl status postgresql-14
? postgresql-14.service - PostgreSQL 14 database server
Loaded: loaded (/usr/lib/systemd/system/postgresql-14.service; enabled; vendor preset: disabled)
Active: active (running) since Mon 2022-09-12 01:17:24 UTC; 2s ago
Docs: https://www.postgresql.org/docs/14/static/
Process: 87995 ExecStartPre=/usr/pgsql-14/bin/postgresql-14-check-db-dir ${PGDATA} (code=exited, status=0/SUCCESS)
Main PID: 88000 (postmaster)
Tasks: 8 (limit: 5915)
Memory: 16.5M
CPU: 60ms
CGroup: /system.slice/postgresql-14.service
??88000 /usr/pgsql-14/bin/postmaster -D /var/lib/pgsql/14/data/
??88001 "postgres: logger "
??88003 "postgres: checkpointer "
??88004 "postgres: background writer "
??88005 "postgres: walwriter "
??88006 "postgres: autovacuum launcher "
??88007 "postgres: stats collector "
??88008 "postgres: logical replication launcher "
Sep 12 01:17:24 board.example.com systemd[1]: Starting PostgreSQL 14 database server...
Instalemos algunas utilidades adicionales que necesitaremos para que Django funcione.
$ sudo dnf install -y python3 python3-devel python3-pip gcc
Para resolver cualquier error futuro relacionado con que no se encuentra pg_config, tienes que añadir la ruta a la carpeta bin de PostgreSQL. Abre el archivo .bashrc para editarlo.
$ nano ~/.bashrc
Añade la siguiente línea al final del archivo.
export PATH=$PATH:/usr/pgsql-14/bin
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.
Paso 3 – Configurar PostgreSQL
Accede al shell de PostgreSQL.
$ sudo -i -u postgres psql
Crea una nueva base de datos para Django.
postgres=# CREATE DATABASE djangoapp;
Crea un nuevo usuario de base de datos con una contraseña segura.
postgres=# CREATE USER djangouser WITH ENCRYPTED PASSWORD 'dbpassword';
Concede los derechos al usuario para utilizar la base de datos.
postgres=# GRANT ALL PRIVILEGES ON DATABASE djangoapp TO djangouser;
Sal del shell Postgres.
postgres=# \q
Paso 4 – 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 usando pip
Esta es la forma más común de instalar Django. La forma recomendada de hacerlo es mediante la creación de un entorno virtual Python. Esto te permite instalar paquetes Python sin afectar al sistema.
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, tienes que 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.1.2
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 reciente de Django que la versión obtenida del repositorio Rocky Linux.
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.dev20221012095013
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.
Paso 5 – 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 el paquete Rueda.
(sample_proj) $ pip install wheel
Instala Django y los paquetes necesarios.
(sample_proj) $ pip install django psycopg2 psycopg2-binary
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 las 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 .
Django utiliza la variable SECRET_KEY para proporcionar firma criptográfica. Genera un valor por defecto durante la instalación. Debes sustituirlo por un valor seguro. Ejecuta el siguiente comando para generar la clave y copiarla para más tarde.
(sample_proj) $ python3 -c 'from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())'
Obtendrás la siguiente salida con una clave.
wm#dzb^ymuo3s3tza=f5cx^kan!$4sch1!b-q=v%)=d0pb(jqf
El primer paso es ajustar la configuración del proyecto. Abre el archivo de configuración para editarlo.
(sample_proj) $ nano demoproject/settings.py
Sustituye el valor actual de la variable SECRET_KEY por la clave que has generado.
SECRET_KEY = 's)3m=4s&!a=p#brttcqu@1s$8(z6e+u8(^tkpw28qyj0t#8ku2'
Cambia los ajustes de la sección DATABASES como se indica a continuación.
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'DATABASE_DB',
'USER': 'DATABASE_USER',
'PASSWORD': 'DATABASE_PASSWORD',
'HOST': 'DATABASE_HOST',
'PORT': 'DATABASE_PORT',
},
}
A continuación, ve al final del archivo y añade una configuración para la ubicación de los archivos estáticos. Esto es importante para que Nginx funcione y gestione las peticiones de estos archivos. Añade la siguiente línea encima de la variable STATIC_URL.
STATIC_ROOT = os.path.join(BASE_DIR, "static/")
Como la variable STATIC_ROOT utiliza el módulo os, necesitamos importarlo ya que no está importado por defecto. Añade la siguiente línea encima de la línea from pathlib import Path.
import os
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.
Comprueba la configuración de la base de datos.
(sample_proj) $ python manage.py check --database default
Deberías obtener el siguiente resultado.
System check identified no issues (0 silenced).
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.
(sample_proj) $ python manage.py makemigrations (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.
Copia los archivos estáticos en el directorio static. Introduce yes cuando se te solicite.
(sample_proj) $ python manage.py collectstatic 130 static files copied to '/home/navjot/dj-sample/static'.
Paso 6 – Prueba del servidor de desarrollo
Es hora de probar la aplicación. Para ello, debes 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, tienes que 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 firewall-cmd --add-port=8000/tcp --permanent (sample_proj) $ sudo firewall-cmd --reload
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.
Cuando hayas terminado con tu proyecto de demostración, puedes cerrar el servidor pulsando Ctrl + C en tu terminal.
Paso 7 – 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 153474 1.6 3.9 46264 39016 pts/0 S 04:15 0:00 python manage.py runserver 0.0.0.0:8000 navjot 153475 3.0 4.4 196060 43500 pts/0 Sl 04:15 0:00 /home/navjot/dj-sample/sample_proj/bin/python manage.py runserver 0.0.0.0:8000 navjot 153483 0.0 0.2 6420 2248 pts/0 S+ 04:15 0:00 grep --color=auto manage.py
Como puedes ver, se están ejecutando dos procesos, uno con el ID 153474 y otro con el ID 153475.
Ejecuta el siguiente comando para cerrar el servidor utilizando los ID de proceso que has obtenido anteriormente.
(sample_proj) $ sudo kill -9 153474 153475
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:application
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
Paso 8 – Crear un socket y un archivo de servicio para Gunicorn
El primer paso es crear un archivo de socket de Gunicorn. El socket Gunicorn se creará en el momento del arranque y escuchará las conexiones. Cuando se produzca una conexión, el systemd 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 \
-t 3000 \
--access-logfile - \
--workers 3 \
--bind unix:/run/gunicorn.sock \
demoproject.wsgi:application -w 2
[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 socket 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; enabled; vendor preset: disabled)
Active: active (listening) since Thu 2022-10-13 04:19:28 UTC; 14s ago
Until: Thu 2022-10-13 04:19:28 UTC; 14s ago
Triggers: ? gunicorn.service
Listen: /run/gunicorn.sock (Stream)
CGroup: /system.slice/gunicorn.socket
Oct 13 04:19:28 django.nspeaks.xyz 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 ya se está ejecutando.
$ sudo systemctl status gunicorn.service
? gunicorn.service - django gunicorn daemon
Loaded: loaded (/etc/systemd/system/gunicorn.service; disabled; vendor preset: disabled)
Active: active (running) since Thu 2022-10-13 06:13:55 UTC; 1min 34s ago
TriggeredBy: ? gunicorn.socket
Main PID: 157742 (gunicorn)
Tasks: 4 (limit: 5915)
Memory: 96.2M
CPU: 1.198s
CGroup: /system.slice/gunicorn.service
??157742 /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 -w 2
??157746 /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 -w 2
??157747 /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 -w 2
??157748 /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 -w 2
.......
Paso 9 – Instalar Nginx
El último paso es instalar y configurar Nginx. Rocky Linux viene con una versión antigua de Nginx. Necesitas descargar el repositorio oficial de Nginx para instalar la última versión.
Crea y abre el archivo /etc/yum.repos.d/nginx.repo para crear el repositorio oficial de Nginx.
$ sudo nano /etc/yum.repos.d/nginx.repo
Pega en él el siguiente código.
[nginx-stable] name=nginx stable repo baseurl=http://nginx.org/packages/centos/$releasever/$basearch/ gpgcheck=1 enabled=1 gpgkey=https://nginx.org/keys/nginx_signing.key module_hotfixes=true [nginx-mainline] name=nginx mainline repo baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/ gpgcheck=1 enabled=0 gpgkey=https://nginx.org/keys/nginx_signing.key module_hotfixes=true
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.
Instala el servidor Nginx.
$ sudo dnf install nginx -y
Verifica la instalación.
$ nginx -v nginx version: nginx/1.22.1
Habilita e inicia el servidor Nginx.
$ sudo systemctl enable nginx --now
Comprueba el estado del servidor.
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; vendor preset: disabled)
Active: active (running) since Thu 2022-10-13 06:17:24 UTC; 1s ago
Docs: http://nginx.org/en/docs/
Process: 157900 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 157901 (nginx)
Tasks: 2 (limit: 5915)
Memory: 1.9M
CPU: 18ms
CGroup: /system.slice/nginx.service
??157901 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??157902 "nginx: worker process"
Oct 13 06:17:24 django.example.com systemd[1]: Starting nginx - high performance web server...
Paso 10 – 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. Requiere el repositorio EPEL para funcionar.
$ sudo dnf install epel-release
Utilizaremos Snapd para instalar Certbot. Instala Snapd.
$ sudo dnf install snapd
Habilita e Inicia el servicio Snap.
$ sudo systemctl enable snapd.socket --now
Crea los enlaces necesarios para que Snapd funcione.
$ sudo ln -s /var/lib/snapd/snap /snap $ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh
Instala el repositorio principal de Snapd.
$ sudo snap install core $ sudo snap refresh 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 certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d django.example.com
El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/django.example.com de tu servidor.
Genera un certificado de grupo Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Para comprobar si la renovación SSL funciona correctamente, realiza una ejecución en seco del proceso.
$ sudo certbot renew --dry-run
Si no ves ningún error, ya está todo listo. Tu certificado se renovará automáticamente.
Paso 11 – 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.
# enforce HTTPS
server {
listen 80 default_server;
server_name django.example.com;
return 301 https://$server_name$request_uri;
}
server {
listen 443 ssl http2;
server_name django.example.com;
access_log /var/log/nginx/django.access.log;
error_log /var/log/nginx/django.error.log;
http2_push_preload on; # Enable HTTP/2 Server Push
ssl_certificate /etc/letsencrypt/live/django.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/django.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/django.example.com/chain.pem;
ssl_session_timeout 1d;
# Enable TLS versions (TLSv1.3 is required upcoming HTTP/3 QUIC).
ssl_protocols TLSv1.2 TLSv1.3;
# Enable TLSv1.3's 0-RTT. Use $ssl_early_data when reverse proxying to
# prevent replay attacks.
#
# @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
ssl_early_data on;
ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
ssl_prefer_server_ciphers on;
ssl_session_cache shared:SSL:50m;
# OCSP Stapling ---
# fetch OCSP records from URL in ssl_certificate and cache them
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
add_header X-Early-Data $tls1_3_early_data;
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;
}
}
# This block is useful for debugging TLS v1.3. Please feel free to remove this
# and use the `$ssl_early_data` variable exposed by NGINX directly should you
# wish to do so.
map $ssl_early_data $tls1_3_early_data {
"~." $ssl_early_data;
default "";
}
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 pida.
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
Vuelve a cargar el servidor Nginx.
$ sudo systemctl reload nginx
Abre el puerto HTTP. También puedes eliminar el puerto 8000 si ya no lo vas a utilizar.
$ sudo firewall-cmd --remove-port=8000/tcp --permanent $ sudo firewall-cmd --reload
Compruébalo abriendo la URL http://django.example.com y se cargará la página principal de Django.
Conclusión
Con esto concluye nuestro tutorial en el que has aprendido a instalar Django junto con Gunicorn y Nginx en un servidor Rocky Linux 9. 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.