Django Tutorial · 18 min read · Oct 13, 2025

Come installare Django con Postgres, Nginx e Gunicorn su Rocky Linux 9

Django è un framework Python utilizzato per sviluppare siti web e applicazioni dinamiche. Segue l’architettura MVC (Model-View-Controller). Utilizzare Django accelera il processo di sviluppo delle applicazioni poiché la maggior parte delle attività sottostanti è gestita da esso.

In questo tutorial, imparerai come installare il framework Django su un server Rocky Linux 9. Creerai anche un progetto demo e lo testerai.

Requisiti

  • Un server che esegue Rocky Linux 9.

  • Un utente non root con privilegi sudo.

  • Un nome di dominio completamente qualificato (FQDN) che punta al tuo server. Per i nostri scopi, utilizzeremo django.example.com come nome di dominio.

  • Assicurati che tutto sia aggiornato. $ sudo dnf update

  • Installa pacchetti di utilità di base. Alcuni di essi potrebbero già essere installati. $ sudo dnf install wget curl nano unzip yum-utils -y

  • SELinux è disabilitato.

Passo 1 - Configurare il Firewall

Il primo passo è configurare il firewall. Rocky Linux utilizza Firewalld Firewall. Controlla lo stato del firewall.

$ sudo firewall-cmd --state
running

Il firewall funziona con diverse zone, e la zona pubblica è quella predefinita che utilizzeremo. Elenca tutti i servizi e le porte attive sul firewall.

$ sudo firewall-cmd --permanent --list-services

Dovrebbe mostrare il seguente output.

cockpit dhcpv6-client ssh

Django ha bisogno delle porte HTTP e HTTPS per funzionare. Aprile.

$ sudo firewall-cmd --add-service=http --permanent
$ sudo firewall-cmd --add-service=https --permanent

Ricarica il firewall per applicare le modifiche.

$ sudo firewall-cmd --reload

Passo 2 - Installare PostgreSQL e Utilità

Rocky Linux 9 viene fornito con una versione più vecchia di PostgreSQL. Installeremo Postgres 14 per il nostro tutorial.

Installa il repository RPM per PostgreSQL.

$ sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm

Installa il server PostgreSQL 14.

$ sudo dnf install -y postgresql14-server postgresql14-contrib postgresql14-devel python3-psycopg2

Inizializza il database.

$ sudo /usr/pgsql-14/bin/postgresql-14-setup initdb

Abilita e avvia il servizio PostgreSQL.

$ sudo systemctl enable postgresql-14 --now

Controlla lo stato del servizio.

$ 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...

Installiamo alcune utilità aggiuntive di cui avremo bisogno per far funzionare Django.

$ sudo dnf install -y python3 python3-devel python3-pip gcc

Per risolvere eventuali errori futuri riguardanti pg_config non trovato, è necessario aggiungere il percorso alla cartella bin di PostgreSQL. Apri il file .bashrc per la modifica.

$ nano ~/.bashrc

Aggiungi la seguente riga alla fine del file.

export PATH=$PATH:/usr/pgsql-14/bin

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Passo 3 - Configurare PostgreSQL

Accedi alla shell di PostgreSQL.

$ sudo -i -u postgres psql

Crea un nuovo database per Django.

postgres=# CREATE DATABASE djangoapp;

Crea un nuovo utente del database con una password sicura.

postgres=# CREATE USER djangouser WITH ENCRYPTED PASSWORD 'dbpassword';

Concedi i diritti all’utente di utilizzare il database.

postgres=# GRANT ALL PRIVILEGES ON DATABASE djangoapp TO djangouser;

Esci dalla shell di Postgres.

postgres=# \q

Passo 4 - Installare Django

Ci sono diversi metodi per installare Django. Decidere quale funziona meglio per te dipende da come vuoi configurare il tuo ambiente di sviluppo e dalle tue esigenze. Ogni metodo ha il proprio insieme di pro e contro. Esaminiamo tutti questi metodi.

Installare usando pip

Questo è il modo più comune per installare Django. Il modo consigliato per farlo è creare un ambiente virtuale Python. Questo ti consente di installare pacchetti Python senza influenzare il sistema.

Creiamo una directory per il progetto demo.

$ mkdir ~/sampleproject
$ cd ~/sampleproject

Crea un ambiente virtuale utilizzando il seguente comando. Sostituisci sample_env con il nome che vuoi dare al tuo ambiente virtuale.

$ python3 -m venv sample_env

Questo installa una versione portatile di Python, pip all’interno della tua directory di progetto. Per installare pacchetti nel progetto, devi attivare l’ambiente utilizzando il seguente comando.

$ source sample_env/bin/activate

Il tuo prompt della shell cambierà per riflettere l’ambiente virtuale.

(sample_env) navjot@django:~/sampleproject$

Ora che l’ambiente virtuale è attivato, usa pip per installare Django. Esegui il seguente comando per installare Django.

(sample_env) $ pip install django

Verifica l’installazione.

(sample_env) $ django-admin --version
4.1.2

A seconda delle esigenze del tuo progetto, puoi installare una versione diversa di Django nel seguente modo.

(sample_env) $ pip install django==3.2.1

Verifica l’installazione.

(sample_env) $ django-admin --version
3.2.1

Come puoi vedere, questo metodo installa una versione più recente di Django rispetto alla versione ottenuta dal repository di Rocky Linux.

Per uscire dall’ambiente virtuale, esegui il seguente comando.

(sample_env) $ deactivate

Installare la versione di sviluppo

Puoi anche usare pip per installare la versione di sviluppo di Django. Per questo, prenderemo la versione di sviluppo dal repository Github di Django.

Clona il repository nella directory ~/django-dev utilizzando il seguente comando.

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

Passa alla nuova directory creata.

$ cd ~/django-dev

Crea l’ambiente virtuale.

$ python3 -m venv dev_django_env

Attiva l’ambiente.

$ source dev_django_env/bin/activate

Installa Django usando pip. Il flag -e lo installa in modalità modificabile, che è necessaria se stai installando dal controllo di versione.

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

Verifica l’installazione.

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

Come puoi vedere, la versione qui è l’ultima versione di sviluppo. La versione di sviluppo di Django non è utile per ambienti di produzione.

Passo 5 - Creare un Progetto di Esempio

Costruiamo un progetto Django di esempio. Crea una directory per il progetto di esempio.

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

Crea un ambiente virtuale Python.

$ python3 -m venv sample_proj

Attiva l’ambiente.

$ source sample_proj/bin/activate

Installa il pacchetto Wheel.

(sample_proj) $ pip install wheel

Installa Django e i pacchetti richiesti.

(sample_proj) $ pip install django psycopg2 psycopg2-binary

Per costruire il progetto, dobbiamo usare il comando startproject. Questo comando crea un’altra directory che include:

  • Uno script di gestione, manage.py, utilizzato per amministrare compiti specifici di Django.
  • Una directory con lo stesso nome del progetto che include il codice del progetto.

Creeremo la directory del progetto nella nostra directory di lavoro corrente. Per farlo, usa il carattere punto (.) alla fine del seguente comando.

(sample_proj) $ django-admin startproject demoproject .

Django utilizza la variabile SECRET_KEY per fornire firme crittografiche. Genera un valore predefinito durante l’installazione. Dovresti sostituirlo con un valore sicuro. Esegui il seguente comando per generare la chiave e copiarla per dopo.

(sample_proj) $ python3 -c 'from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())'

Otterrai il seguente output con una chiave.

wm#dzb^ymuo3s3tza=f5cx^kan!$4sch1!b-q=v%)=d0pb(jqf

Il primo passo è regolare le impostazioni del progetto. Apri il file delle impostazioni per la modifica.

(sample_proj) $ nano demoproject/settings.py

Sostituisci il valore attuale della variabile SECRET_KEY con la chiave che hai generato.

SECRET_KEY = 's)3m=4s&!a=p#brttcqu@1s$8(z6e+u8(^tkpw28qyj0t#8ku2'

Cambia le impostazioni per la sezione DATABASES come segue.

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'DATABASE_DB',
        'USER': 'DATABASE_USER',
        'PASSWORD': 'DATABASE_PASSWORD',
        'HOST': 'DATABASE_HOST',
        'PORT': 'DATABASE_PORT',
    },
}

Successivamente, spostati in fondo al file e aggiungi un’impostazione per la posizione dei file statici. Questo è importante per il funzionamento di Nginx e per gestire le richieste per questi file. Aggiungi la seguente riga sopra la variabile STATIC_URL.

STATIC_ROOT = os.path.join(BASE_DIR, "static/")

Poiché la variabile STATIC_ROOT utilizza il modulo os, dobbiamo importarlo poiché non è importato per impostazione predefinita. Aggiungi la seguente riga sopra la riga from pathlib import Path.

import os

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Verifica le impostazioni del database.

(sample_proj) $ python manage.py check --database default

Dovresti ottenere il seguente output.

System check identified no issues (0 silenced).

Successivamente, dobbiamo migrare il database utilizzando il comando migrate. Le migrazioni in Django propagano le modifiche che apporti ai tuoi modelli nel tuo schema di database.

(sample_proj) $ python manage.py makemigrations
(sample_proj) $ python manage.py migrate

Otterrai il seguente output.

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

Successivamente, crea un utente amministrativo per accedere all’interfaccia di amministrazione di Django.

(sample_proj) $ python manage.py createsuperuser

Ti verrà chiesto un nome utente, un’email e una password.

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

Copia i file statici nella directory statica. Inserisci yes quando richiesto.

(sample_proj) $ python manage.py collectstatic
130 static files copied to '/home/navjot/dj-sample/static'.

Passo 6 - Testare il Server di Sviluppo

È tempo di testare l’applicazione. Per questo, devi modificare la direttiva ALLOWED_HOSTS nelle impostazioni di Django. Questa direttiva definisce l’elenco degli indirizzi IP e dei nomi di dominio che hanno accesso all’applicazione Django.

Apri il file delle impostazioni utilizzando il seguente comando.

(sample_proj) $ nano demoproject/settings.py

Trova la seguente voce.

ALLOWED_HOSTS = []

Inserisci l’indirizzo IP del tuo server tra le parentesi quadre. Ogni voce deve essere racchiusa tra virgolette e più voci devono essere separate da virgole. Inserire www.example.com corrisponderà esattamente. Tuttavia, .example.com corrisponderà a example.com e www.example.com, e a qualsiasi altro sottodominio di example.com. Pertanto, è consigliabile utilizzare il punto per prefissare un nome di dominio per corrispondere a esso e ai suoi sottodomini.

ALLOWED_HOSTS = ['']

Abbiamo utilizzato l’indirizzo IP per corrispondere al nostro server. Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Prima di testare il server di sviluppo, devi configurare il firewall per consentire a Django di funzionare. Django utilizza la porta 8000 per impostazione predefinita. Apri la porta utilizzando il Firewall Semplice (UFW).

(sample_proj) $ sudo firewall-cmd --add-port=8000/tcp --permanent
(sample_proj) $ sudo firewall-cmd --reload

Avvia il server di sviluppo.

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

Lancia l’URL http://:8000 nel tuo browser e vedrai la seguente schermata.

Homepage di Django

Puoi accedere all’interfaccia di amministrazione seguendo l’URL http://:8000/admin/ e vedrai la seguente schermata di accesso.

Pagina di accesso di Django

Inserisci le credenziali create in precedenza per accedere al pannello di amministrazione mostrato di seguito.

Pannello di amministrazione di Django

Una volta terminato con il tuo progetto demo, puoi chiudere il server premendo Ctrl + C nel tuo terminale.

Passo 7 - Installare e Testare Gunicorn

Esegui il server Django persistente utilizzando nohup

Finora, il servizio Django non è persistente. Per rendere il servizio persistente, ci sono due metodi. Il primo metodo prevede l’uso dell’utilità nohup. Il nohup è un comando POSIX che significa no hang up. Viene utilizzato per eseguire comandi in un modo che non si ferma nemmeno quando un utente esce.

Assicurati di essere uscito dal server dal terminale premendo Ctrl + C.

Esegui il seguente comando per eseguire il server di sviluppo di Django.

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

Ora, il tuo server Django continuerà a funzionare finché non lo uccidi manualmente. Il comando ti darà l’ID del processo e stamperà un altro comando.

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

Premi Ctrl + C per uscire. Il server Django originale continuerà a funzionare. Puoi verificarlo aprendo l’URL nel tuo browser.

Una volta terminato, devi uccidere il processo. Il comando nohup ti dà un ID di processo. Ma in realtà, vengono eseguiti due processi. Per trovare gli ID di entrambi i processi, esegui il seguente 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

Come puoi vedere, vengono eseguiti due processi, uno con ID 153474 e l’altro con ID 153475.

Esegui il seguente comando per spegnere il server utilizzando gli ID di processo ottenuti sopra.

(sample_proj) $ sudo kill -9 153474 153475

Installare Gunicorn

Il secondo metodo per eseguire un server Django persistente richiede di installare Gunicorn e i server web Nginx. Gunicorn è un server HTTP WSGI Python. Interfaccerà l’applicazione Django e poi Nginx agirà come un proxy inverso per Gunicorn. Questo metodo ha il vantaggio aggiuntivo di fornirti la sicurezza e le prestazioni che derivano dall’uso di Nginx.

Installa Gunicorn.

(sample_proj) $ pip install gunicorn

Prima di procedere, dobbiamo testare la capacità di Gunicorn di servire il progetto. Esegui il seguente comando per eseguire Gunicorn.

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

Questo avvierà Gunicorn sulla stessa interfaccia su cui stava funzionando Django. Per verificare, apri l’URL http://:8000 nel tuo browser e vedrai la stessa homepage di Django. Questo significa che Gunicorn sta funzionando perfettamente.

Quando hai finito di testare, premi Ctrl + C nel terminale per uscire da Gunicorn.

Disattiva l’ambiente virtuale per tornare alla tua shell normale.

(sample_proj) $ deactivate

Passo 8 - Creare un File Socket e di Servizio per Gunicorn

Il primo passo è creare un file socket per Gunicorn. Il socket di Gunicorn verrà creato all’avvio e ascolterà le connessioni. Quando si verifica una connessione, systemd avvierà automaticamente il processo Gunicorn per gestirla.

Crea e apri il file socket di Gunicorn per la modifica.

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

Incolla il seguente codice in esso.

[Unit]
Description=gunicorn socket

[Socket]
ListenStream=/run/gunicorn.sock

[Install]
WantedBy=sockets.target

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Successivamente, crea e apri il file di servizio di Gunicorn per la modifica.

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

Incolla il seguente codice in esso.

[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

Salva il file premendo Ctrl + X e inserendo Y quando richiesto. Sostituisci navjot con il tuo nome utente di sistema. Il gruppo nginx consentirà al server Nginx di comunicare con Django.

Ricarica il demone di sistema per aggiornare i file systemd.

$ sudo systemctl daemon-reload

Abilita e avvia il file socket di Gunicorn.

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

Controlla lo stato del socket di Gunicorn.

$ sudo systemctl status gunicorn.socket

Riceverai un output simile.

? 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.

Il servizio Gunicorn non è ancora in esecuzione, come puoi controllare.

$ 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

Per testare il meccanismo di attivazione del socket, esegui il seguente comando.

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

Riceverai l’output HTML della homepage di Django nel tuo terminale. Questo avvia anche Gunicorn per servire l’applicazione. Controlla di nuovo lo stato del servizio e vedrai che ora è in esecuzione.

$ 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
.......

Passo 9 - Installare Nginx

L’ultimo passo è installare e configurare Nginx. Rocky Linux viene fornito con una versione più vecchia di Nginx. Devi scaricare il repository ufficiale di Nginx per installare l’ultima versione.

Crea e apri il file /etc/yum.repos.d/nginx.repo per creare il repository ufficiale di Nginx.

$ sudo nano /etc/yum.repos.d/nginx.repo

Incolla il seguente codice in esso.

[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

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Installa il server Nginx.

$ sudo dnf install nginx -y

Verifica l’installazione.

$ nginx -v
nginx version: nginx/1.22.1

Abilita e avvia il server Nginx.

$ sudo systemctl enable nginx --now

Controlla lo stato del server.

$ 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...

Passo 10 - Installare SSL

Finora, la tua applicazione Django viene servita tramite una connessione HTTP in chiaro. È altamente consigliato proteggerla tramite un certificato SSL. Per questo, utilizza lo strumento Certbot utilizzando lo strumento Snapd. Richiede il repository EPEL per funzionare.

$ sudo dnf install epel-release

Utilizzeremo Snapd per installare Certbot. Installa Snapd.

$ sudo dnf install snapd

Abilita e avvia il servizio Snap.

$ sudo systemctl enable snapd.socket --now

Crea i collegamenti necessari affinché Snapd funzioni.

$ 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

Installa il repository core di Snapd.

$ sudo snap install core
$ sudo snap refresh core

Installa Certbot.

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

Genera il certificato. Il seguente comando configurerà automaticamente anche Nginx.

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

Il comando sopra scaricherà un certificato nella directory /etc/letsencrypt/live/django.example.com sul tuo server.

Genera un certificato Diffie-Hellman group.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Per controllare se il rinnovo SSL funziona correttamente, esegui un tentativo di rinnovo.

$ sudo certbot renew --dry-run

Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.

Passo 11 - Configurare Nginx

Crea e apri il file /etc/nginx/conf.d/django-gunicorn.conf per la modifica.

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

Incolla il seguente codice in esso.

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

Sostituisci la posizione root nel file sopra con la directory sul tuo server.

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Apri il file /etc/nginx/nginx.conf per la modifica.

$ sudo nano /etc/nginx/nginx.conf

Aggiungi la seguente riga prima della riga include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Verifica la tua configurazione di Nginx.

$ sudo nginx -t

Se non vedi errori, significa che sei a posto.

Dovrai anche aggiungere il nome di dominio alla tua direttiva ALLOWED_HOSTS. Apri il file settings.py.

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

Cambia il valore per la variabile ALLOWED_HOSTS.

ALLOWED_HOSTS = ['','django.example.com']

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Riavvia il Socket e il Servizio di Gunicorn.

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

Ricarica il server Nginx.

$ sudo systemctl reload nginx

Apri la porta HTTP. Puoi anche eliminare la porta 8000 se non la utilizzerai più.

$ sudo firewall-cmd --remove-port=8000/tcp --permanent
$ sudo firewall-cmd --reload

Verifica aprendo l’URL http://django.example.com e la homepage di Django si caricherà.

Conclusione

Questo conclude il nostro tutorial in cui hai imparato come installare Django insieme a Gunicorn e Nginx su un server Rocky Linux 9. Hai anche installato un certificato SSL per migliorare la sicurezza del tuo progetto Django. Se hai domande, postale nei commenti qui sotto.

Share: X/Twitter LinkedIn
#Django Tutorial

Ricevi i nuovi post nella tua casella di posta.

Nessuno spam. Disiscriviti in qualsiasi momento.