Django Tutorial · 18 min read · Oct 13, 2025
Cómo instalar Django con Postgres, Nginx y Gunicorn en Rocky Linux 9
Django es un marco de trabajo 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 de aplicaciones, ya que la mayoría de las tareas subyacentes son manejadas por él.
En este tutorial, aprenderás cómo instalar el marco de trabajo Django en un servidor Rocky Linux 9. También crearás un proyecto de demostración y lo probarás.
Prerrequisitos
Un servidor que ejecute Rocky Linux 9.
Un usuario no root con privilegios de sudo.
Un nombre de dominio completamente calificado (FQDN) apuntando a tu servidor. Para nuestros propósitos, usaremos
django.example.comcomo el nombre de dominio.Asegúrate de que todo esté actualizado.
$ sudo dnf updateInstala paquetes de utilidad básicos. Algunos de ellos pueden ya estar instalados.
$ sudo dnf install wget curl nano unzip yum-utils -ySELinux está deshabilitado.
Paso 1 - Configurar el Firewall
El primer paso es configurar el firewall. Rocky Linux utiliza Firewalld Firewall. Verifica el estado del firewall.
$ sudo firewall-cmd --state
running
El firewall trabaja con diferentes zonas, y la zona pública es la predeterminada que utilizaremos. Lista todos los servicios y puertos activos en el firewall.
$ sudo firewall-cmd --permanent --list-services
Debería mostrar la siguiente salida.
cockpit dhcpv6-client ssh
Django necesita puertos HTTP y HTTPS para funcionar. Ábrelos.
$ sudo firewall-cmd --add-service=http --permanent
$ sudo firewall-cmd --add-service=https --permanent
Recarga el firewall para aplicar los cambios.
$ sudo firewall-cmd --reload
Paso 2 - Instalar PostgreSQL y Utilidades
Rocky Linux 9 viene con una versión más antigua de PostgreSQL. Instalaremos Postgres 14 para nuestro tutorial.
Instala el RPM del repositorio 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 de PostgreSQL.
$ sudo systemctl enable postgresql-14 --now
Verifica 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 pg_config no encontrado, necesitas agregar la ruta a la carpeta bin de PostgreSQL. Abre el archivo .bashrc para editar.
$ nano ~/.bashrc
Agrega la siguiente línea al final del archivo.
export PATH=$PATH:/usr/pgsql-14/bin
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Paso 3 - Configurar PostgreSQL
Inicia sesión en el 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 fuerte.
postgres=# CREATE USER djangouser WITH ENCRYPTED PASSWORD 'dbpassword';
Otorga los derechos al usuario para usar la base de datos.
postgres=# GRANT ALL PRIVILEGES ON DATABASE djangoapp TO djangouser;
Sal del Shell de Postgres.
postgres=# \q
Paso 4 - 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 de tus necesidades. Cada método tiene su propio conjunto de pros y contras. Vamos a repasar todos estos métodos.
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.
Creamos 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 quieras 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, necesitas 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.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 nueva de Django que la versión obtenida del repositorio de Rocky Linux.
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.dev20221012095013
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.
Paso 5 - Crear un Proyecto de Muestra
Construyamos un proyecto de 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 el paquete Wheel.
(sample_proj) $ pip install wheel
Instala Django y los paquetes requeridos.
(sample_proj) $ pip install django psycopg2 psycopg2-binary
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 hacerlo, usa 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 predeterminado durante la instalación. Debes reemplazarlo con un valor seguro. Ejecuta el siguiente comando para generar la clave y cópiala 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 editar.
(sample_proj) $ nano demoproject/settings.py
Reemplaza el valor actual de la variable SECRET_KEY con la clave que generaste.
SECRET_KEY = 's)3m=4s&!a=p#brttcqu@1s$8(z6e+u8(^tkpw28qyj0t#8ku2'
Cambia la configuración para la sección DATABASES de la siguiente manera.
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, muévete al final del archivo y agrega una configuración para la ubicación de los archivos estáticos. Esto es importante para que Nginx funcione y maneje solicitudes para estos archivos. Agrega la siguiente línea antes de la variable STATIC_URL.
STATIC_ROOT = os.path.join(BASE_DIR, "static/")
Dado que la variable STATIC_ROOT utiliza el módulo os, necesitamos importarlo ya que no está importado por defecto. Agrega la siguiente línea antes de la línea from pathlib import Path.
import os
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Verifica la configuración de la base de datos.
(sample_proj) $ python manage.py check --database default
Deberías obtener la siguiente salida.
System check identified no issues (0 silenced).
A continuación, necesitamos migrar la base de datos usando el comando migrate. Las migraciones en Django propagan los cambios que haces a tus modelos en el 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 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.
Username (leave blank to use 'navjot'):
Email address: [email protected]
Password:
Password (again):
Superuser created successfully.
Copia los archivos estáticos en el directorio estático. Ingresa yes cuando se te pida.
(sample_proj) $ python manage.py collectstatic
130 static files copied to '/home/navjot/dj-sample/static'.
Paso 6 - 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
Encuentra la siguiente entrada.
ALLOWED_HOSTS = []
Ingresa la dirección IP de tu servidor en los corchetes cuadrados. Cada entrada debe estar encerrada 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 usado la dirección IP para emparejar nuestro servidor. Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Antes de probar el servidor de desarrollo, necesitas configurar el firewall para permitir que Django funcione. Django usa el puerto 8000 por defecto. Abre el puerto usando el Firewall Descomplicado (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
Lanza la URL http:// en tu navegador y obtendrás la siguiente pantalla.
Puedes acceder a la interfaz de administración siguiendo la URL http:// 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 hayas terminado con tu proyecto de demostración, puedes cerrar el servidor presionando Ctrl + C en tu terminal.
Paso 7 - 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: ignoring input and appending output to '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 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 ID 153474 y el otro con ID 153475.
Ejecuta el siguiente comando para cerrar el servidor usando los IDs de proceso que obtuviste anteriormente.
(sample_proj) $ sudo kill -9 153474 153475
Instalar Gunicorn
El segundo método para ejecutar un servidor Django persistente requiere que instales Gunicorn y 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:application
Esto iniciará Gunicorn en la misma interfaz en la que estaba funcionando Django. Para verificar, abre la URL http:// en tu navegador y obtendrás la misma página de inicio de Django. Esto significa que Gunicorn está funcionando perfectamente.
Cuando hayas terminado de probar, presiona Ctrl + C en la terminal para salir de Gunicorn.
Desactiva el entorno virtual para volver a tu shell regular.
(sample_proj) $ deactivate
Paso 8 - 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á al inicio y escuchará conexiones. Cuando ocurra una conexión, el systemd 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=gunicorn socket
[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=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 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 - 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.
El servicio de Gunicorn aún no se está ejecutando como puedes comprobar.
$ 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 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 - 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 más 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 el siguiente código en él.
[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 presionando Ctrl + X y entrando 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
Verifica 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 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. Requiere el repositorio EPEL para funcionar.
$ sudo dnf install epel-release
Usaremos 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 core 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 en tu servidor.
Genera un certificado de grupo Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Para verificar si la renovación de SSL está funcionando bien, haz una prueba del proceso.
$ sudo certbot renew --dry-run
Si no ves errores, estás listo. Tu certificado se renovará automáticamente.
Paso 11 - 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.
# 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 "";
}
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
Recarga el servidor Nginx.
$ sudo systemctl reload nginx
Abre el puerto HTTP. También puedes eliminar el puerto 8000 si no vas a usarlo más.
$ sudo firewall-cmd --remove-port=8000/tcp --permanent
$ sudo firewall-cmd --reload
Verifica abriendo la URL http://django.example.com y la página de inicio de Django se cargará.
Conclusión
Esto concluye nuestro tutorial donde aprendiste cómo instalar Django junto con Gunicorn y Nginx en un servidor Rocky Linux 9. 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.
Recibe nuevas publicaciones en tu bandeja de entrada.
No spam. Cancela la suscripción en cualquier momento.