Ricerca nel sito web

Come installare Django Framework su Debian 11

Questo tutorial esiste per queste versioni del sistema operativo

  • Debian 11 (Bullseye)
  • Debian 10 (Buster)

Su questa pagina

  1. Prerequisiti
  2. Per iniziare
  3. Installa il server database PostgreSQL
  4. Crea un ambiente virtuale Python
  5. Installa e configura Django
  6. Esegui il server di sviluppo Django
  7. Verifica Django con Gunicorn
  8. Crea un file di servizio Systemd per Gunicorn
  9. Configura Nginx come proxy inverso per Django
  10. Conclusione

Django è un framework di sviluppo web gratuito e open source scritto in Python. Viene utilizzato per lo sviluppo di applicazioni Python complesse e basate su database. Viene fornito con una serie di script Python per la creazione di progetti Python. Può essere eseguito su qualsiasi sistema operativo in grado di eseguire Python, inclusi Windows, macOS, Linux/Unix e Solaris. Aiuta gli sviluppatori a scrivere meno codice e creare un nuovo sito Web in un breve lasso di tempo.

In questo tutorial, spiegherò come configurare Django in ambiente virtuale Python utilizzando il database PostgreSQL su Debian 11. Successivamente installeremo e configureremo Nginx come proxy inverso per Django.

Prerequisiti

  • Un server che esegue Debian 11.
  • Un nome di dominio valido indicato con l'IP del tuo server.
  • Sul server è configurata una password di root.

Iniziare

Prima di iniziare, è una buona idea aggiornare i pacchetti di sistema all'ultima versione. Puoi farlo usando il seguente comando:

apt-get update -y

Una volta aggiornati tutti i pacchetti, installa altri strumenti Python e il pacchetto Nginx con il seguente comando:

apt-get install python3-pip python3-dev libpq-dev curl nginx -y

Una volta installati tutti i pacchetti richiesti, puoi procedere al passaggio successivo.

Installa il server database PostgreSQL

Qui useremo PostgreSQL come database back-end. Quindi installiamolo usando il seguente comando:

apt-get install postgresql postgresql-contrib -y

Una volta installato PostgreSQL, connettiti alla shell PostgreSQL con il seguente comando:

su - postgres
psql

Successivamente, crea un database e un utente per Django con il seguente comando:

CREATE DATABASE django;
CREATE USER django WITH PASSWORD 'password';

Quindi, assegna alcuni ruoli richiesti con il seguente comando:

ALTER ROLE django SET client_encoding TO 'utf8';
ALTER ROLE django SET default_transaction_isolation TO 'read committed';
ALTER ROLE django SET timezone TO 'UTC';
GRANT ALL PRIVILEGES ON DATABASE django TO django;

Successivamente, esci dalla shell PostgreSQL usando il seguente comando:

\q
exit

A questo punto, il database PostgreSQL è pronto per Django. Ora puoi procedere al passaggio successivo.

Crea un ambiente virtuale Python

Successivamente, dovrai creare un ambiente virtuale Python per creare un progetto Django.

Innanzitutto, aggiorna il pacchetto PIP alla versione più recente utilizzando il seguente comando:

pip3 install --upgrade pip

Successivamente, verifica la versione PIP utilizzando il seguente comando:

pip --version

Esempio di output:

pip 21.2.4 from /usr/local/lib/python3.9/dist-packages/pip (python 3.9)

Successivamente, installa il pacchetto dell'ambiente virtuale utilizzando il seguente comando:

pip3 install virtualenv

Successivamente, crea una directory per il progetto Django e crea un ambiente virtuale Django:

mkdir ~/djangoapp
cd ~/djangoapp
virtualenv djangoenv

Successivamente, attiva l'ambiente virtuale Django utilizzando il comando seguente:

source djangoenv/bin/activate

Successivamente, installa Django, Gunicorn e altri pacchetti utilizzando il seguente comando:

pip install django gunicorn psycopg2-binary

A questo punto, Django è installato nell'ambiente virtuale Python. Ora puoi procedere al passaggio successivo.

Installa e configura Django

Django fornisce uno script django-admin.py per creare un progetto. Puoi eseguire il seguente comando per creare un progetto Django:

django-admin.py startproject djangoapp ~/djangoapp

Successivamente, dovrai modificare settings.py e definire le impostazioni del tuo database:

nano ~/djangoapp/djangoapp/settings.py

Modifica la seguente riga con il tuo nome di dominio:

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

Rimuovere il commento dal backend del database predefinito e aggiungere le impostazioni del database PostgreSQL:

#DATABASES = {
#    'default': {
#        'ENGINE': 'django.db.backends.sqlite3',
#        'NAME': BASE_DIR / 'db.sqlite3',
#    }
#}

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'django',
        'USER': 'django',
        'PASSWORD': 'password',
        'HOST': 'localhost',
        'PORT': '',

    }
}

Aggiungere le seguenti righe alla fine del file:

STATIC_URL = '/static/'
import os
STATIC_ROOT = os.path.join(BASE_DIR, 'static/')

Salva e chiudi il file, quindi migra lo schema del database iniziale nel database PostgreSQL:

./manage.py makemigrations
./manage.py migrate

Esempio di outputL:

  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

Quindi, crea un account superutente per Django con il seguente comando:

./manage.py createsuperuser

Imposta il nome utente e la password dell'amministratore come mostrato di seguito:

Username (leave blank to use 'root'): dadmin
Email address: 
Password: 
Password (again): 
Superuser created successfully.

Successivamente, raccogli tutto il contenuto statico nella directory:

./manage.py collectstatic

Esegui il server di sviluppo Django

A questo punto, Django è installato e configurato. Ora puoi avviare il server di sviluppo Django usando il seguente comando:

./manage.py runserver 0.0.0.0:8000

Se tutto va bene, dovresti ottenere il seguente output:

Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).
August 27, 2021 - 10:02:05
Django version 3.2.6, using settings 'djangoapp.settings'
Starting development server at http://0.0.0.0:8000/
Quit the server with CONTROL-C.

Ora apri il tuo browser web e accedi al tuo progetto Django utilizzando l'URL http://django.example.com:8000/admin/. Verrai reindirizzato alla pagina di accesso di Django:

Fornisci il nome utente e la password dell'amministratore e fai clic su Accedi. Dovresti vedere la dashboard di Django nella pagina seguente:

Ora torna al tuo terminale e premi CTRL + C per arrestare il server di sviluppo Django.

Verifica Django con Gunicorn

Successivamente, dovrai anche verificare se il Gunicorn può servire il Django o meno. Puoi avviare Django usando il server Gunicorn con il seguente comando:

gunicorn --bind 0.0.0.0:8000 djangoapp.wsgi

Se tutto va bene, dovresti ottenere il seguente output:

[2021-08-27 10:04:22 +0000] [47383] [INFO] Starting gunicorn 20.1.0
[2021-08-27 10:04:22 +0000] [47383] [INFO] Listening at: http://0.0.0.0:8000 (47383)
[2021-08-27 10:04:22 +0000] [47383] [INFO] Using worker: sync
[2021-08-27 10:04:22 +0000] [47384] [INFO] Booting worker with pid: 47384

Premi CTRL + C per fermare il server Gunicorn.

Successivamente, disattiva dall'ambiente virtuale Python con il seguente comando:

deactivate

Crea un file di servizio Systemd per Gunicorn

Successivamente, dovrai creare un file di servizio systemd per Gunicorn per avviare e arrestare il server delle applicazioni Django.

Puoi creare un Gunicorn con il seguente comando:

nano /etc/systemd/system/gunicorn.socket

Aggiungi le seguenti righe:

[Unit]
Description=gunicorn socket

[Socket]
ListenStream=/run/gunicorn.sock

[Install]
WantedBy=sockets.target

Salva e chiudi il file, quindi crea un file di servizio per Gunicorn:

nano /etc/systemd/system/gunicorn.service

Aggiungi le seguenti righe che corrispondono al percorso del tuo progetto Django:

[Unit]
Description=gunicorn daemon
Requires=gunicorn.socket
After=network.target
[Service]
User=root
Group=www-data
WorkingDirectory=/root/djangoapp
ExecStart=/root/djangoapp/djangoenv/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock          djangoapp.wsgi:application

[Install]
WantedBy=multi-user.target

Salva e chiudi il file, quindi imposta i permessi appropriati per la directory del progetto Django:

chown -R www-data:root ~/djangoapp

Successivamente, ricarica il demone systemd con il seguente comando:

systemctl daemon-reload

Quindi, avvia il servizio Gunicorn e abilitalo per l'avvio al riavvio del sistema:

systemctl start gunicorn.socket
systemctl enable gunicorn.socket

Quindi, controlla lo stato del Gunicorn usando il comando seguente:

systemctl status gunicorn.socket

Dovresti ottenere il seguente output:

? gunicorn.socket - gunicorn socket
     Loaded: loaded (/etc/systemd/system/gunicorn.socket; disabled; vendor preset: enabled)
     Active: active (listening) since Fri 2021-08-27 10:05:46 UTC; 6s ago
   Triggers: ? gunicorn.service
     Listen: /run/gunicorn.sock (Stream)
     CGroup: /system.slice/gunicorn.socket

Aug 27 10:05:46 debian11 systemd[1]: Listening on gunicorn socket.

Configura Nginx come proxy inverso per Django

Successivamente, dovrai configurare Nginx come proxy inverso per servire Django.

Per fare ciò, crea un file di configurazione Nginx:

nano /etc/nginx/conf.d/django.conf

Aggiungi le seguenti righe:

server {
     listen 80;
     server_name django.example.com;
    location = /favicon.ico { access_log off; log_not_found off; }


    location /static/ {
         root /root/djangoapp;
     }

    location / {
         include proxy_params;
         proxy_pass http://unix:/run/gunicorn.sock;
     }
}

Salva e chiudi il file, quindi verifica Nginx per eventuali errori di configurazione:

nginx -t
Output:
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Infine, riavvia il servizio Nginx per applicare le modifiche:

systemctl restart nginx

Per verificare lo stato di Nginx, eseguire:

systemctl status nginx

Esempio di output:

? nginx.service - A high performance web server and a reverse proxy server
     Loaded: loaded (/lib/systemd/system/nginx.service; enabled; vendor preset: enabled)
     Active: active (running) since Fri 2021-08-27 10:06:59 UTC; 6s ago
       Docs: man:nginx(8)
    Process: 47494 ExecStartPre=/usr/sbin/nginx -t -q -g daemon on; master_process on; (code=exited, status=0/SUCCESS)
    Process: 47495 ExecStart=/usr/sbin/nginx -g daemon on; master_process on; (code=exited, status=0/SUCCESS)
   Main PID: 47496 (nginx)
      Tasks: 2 (limit: 2341)
     Memory: 2.5M
        CPU: 49ms
     CGroup: /system.slice/nginx.service
             ??47496 nginx: master process /usr/sbin/nginx -g daemon on; master_process on;
             ??47497 nginx: worker process

Aug 27 10:06:59 debian11 systemd[1]: Starting A high performance web server and a reverse proxy server...
Aug 27 10:06:59 debian11 systemd[1]: nginx.service: Failed to parse PID from file /run/nginx.pid: Invalid argument
Aug 27 10:06:59 debian11 systemd[1]: Started A high performance web server and a reverse proxy server.

Ora puoi accedere all'applicazione Django utilizzando l'URL http://django.example.com/admin. Puoi anche accedere all'applicazione Django utilizzando l'URL http://django.example.com/.

Conclusione

Congratulazioni! hai installato con successo un'applicazione Django con Gunicorn e Nginx come proxy inverso. Ora puoi iniziare a distribuire la tua applicazione Python utilizzando il framework Django.