GNU/Linux >> Linux Esercitazione > >> Ubuntu

Come installare Flask con Python 3 su Ubuntu 18.04

Flask è un framework molto semplice, ma estremamente flessibile, pensato per fornire funzionalità alle tue applicazioni senza essere troppo restrittivo in termini di struttura e design. Puoi utilizzare lo stack generale descritto in questo articolo per servire le applicazioni di flask progettate.

In questo articolo, configureremo una semplice applicazione Python utilizzando il micro-framework Flask su Ubuntu 18.04.

La maggior parte di questo articolo riguarderà come configurare il server delle applicazioni Gunicorn per avviare l'applicazione e Nginx per fungere da proxy inverso front-end.

Prerequisiti

Prima di iniziare questo articolo, dovresti avere un utente non root configurato sul tuo server. Questo utente deve disporre dei privilegi sudo in modo che possa eseguire funzioni amministrative.

Crea un utente non root con i privilegi sudo configurati:
1- Accesso come root
2- Creazione di un nuovo utente

# adduser bobby

3- Concessione di privilegi amministrativi

Per aggiungere questi privilegi al nostro nuovo utente, dobbiamo aggiungere il nuovo utente al gruppo sudo. Per impostazione predefinita, su Ubuntu 18.04, gli utenti che appartengono al gruppo sudo possono utilizzare il comando sudo.

# usermod -aG sudo bobby

Installa i componenti dai repository di Ubuntu

Il primo passo sarà installare tutti i pezzi di cui abbiamo bisogno dai repository. Installeremo pip, il gestore di pacchetti Python 3, per installare e gestire i nostri componenti Python 3. Otterremo anche i file di sviluppo Python 3 necessari per costruire alcuni dei componenti di Gunicorn. Installeremo anche Nginx ora.
Aggiorna l'indice del pacchetto locale e quindi installa i pacchetti. I pacchetti specifici di cui hai bisogno dipenderanno dalla versione di Python che stai utilizzando per il tuo progetto.
Installando Python 3, digita:

$ sudo apt-get update
$ sudo apt-get install python3-pip python3-dev nginx

Crea un ambiente virtuale Python 3

Successivamente, configureremo un ambiente virtuale per isolare la nostra applicazione Flask dagli altri file Python sul sistema.
Inizia installando il pacchetto virtualenv usando pip.
Se stai usando Python 3, digita:

sudo pip3 install virtualenv

Ora possiamo creare una directory padre per il nostro progetto Flask. Sposta nella directory dopo averla creata:

mkdir ~/flaskproject
cd ~/flaskproject

Possiamo creare un ambiente virtuale per archiviare i requisiti Python del nostro progetto Flask digitando:

virtualenv flaskprojectenv

Questo installerà una copia locale di Python e pip in una directory chiamata flaskprojectenv all'interno della directory del tuo progetto.
Prima di installare le applicazioni all'interno dell'ambiente virtuale, è necessario attivarlo. Puoi farlo digitando:

source flaskprojectenv/bin/activate

La tua richiesta cambierà per indicare che ora stai operando all'interno dell'ambiente virtuale. Sarà simile a questo (flaskprojectenv)user@host:~/flaskproject$ .

Configura un'applicazione Flask

Ora che sei nel tuo ambiente virtuale, possiamo installare Flask e Gunicorn e iniziare a progettare la nostra applicazione:

Installa Flask e Gunicorn

Possiamo usare l'istanza locale di pip per installare Flask e Gunicorn. Digita i seguenti comandi per ottenere questi due componenti:

Nota: Indipendentemente dalla versione di Python che stai utilizzando, quando l'ambiente virtuale è attivato, dovresti usare il pip comando (non pip3 ).

(flaskprojectenv) $ pip install gunicorn flask

Crea un'app di esempio

Ora che abbiamo Flask disponibile, possiamo creare una semplice applicazione. Flask è un micro-quadro. Non include molti degli strumenti che potrebbero essere framework più completi ed esiste principalmente come modulo che puoi importare nei tuoi progetti per aiutarti nell'inizializzazione di un'applicazione web.
Anche se la tua applicazione potrebbe essere più complessa, creeremo la nostra app Flask in un unico file, che chiameremo flaskproject.py:

(flaskprojectenv) $ nano ~/flaskproject/flaskproject.py

All'interno di questo file, collocheremo il nostro codice dell'applicazione. Fondamentalmente, dobbiamo importare flask e creare un'istanza di un oggetto Flask. Possiamo usarlo per definire le funzioni che dovrebbero essere eseguite quando viene richiesto un percorso specifico:

~/flaskproject/flaskproject.py
from flask import Flask
app = Flask(__name__)

@app.route("/")
def greeting():
    return "<h1 style='color:green'>Hello World!</h1>"

if __name__ == "__main__":
    app.run(host='0.0.0.0')

Questo sostanzialmente definisce quale contenuto presentare quando si accede al dominio principale. Salva e chiudi il file quando hai finito.

Se hai seguito la guida all'installazione iniziale del server, dovresti avere un firewall UFW abilitato. Per testare la nostra applicazione, dobbiamo consentire l'accesso alla porta 5000.

Apri la porta 5000 digitando:

(flaskprojectenv) $ sudo ufw allow 5000

Ora puoi testare la tua app Flask digitando:

(flaskprojectenv) $ python flaskproject.py

Visita il nome di dominio o l'indirizzo IP del tuo server seguito da :5000 nel tuo browser web:

http://server_domain_or_IP:5000

Dovresti vedere qualcosa del genere:

Quando hai finito, premi CTRL-C nella finestra del terminale alcune volte per arrestare il server di sviluppo Flask.

Crea il punto di ingresso WSGI

Successivamente, creeremo un file che fungerà da punto di ingresso per la nostra applicazione. Questo dirà al nostro server Gunicorn come interagire con l'applicazione.

Chiameremo il file wsgi.py :

(flaskprojectenv) $ nano ~/flaskproject/wsgi.py

Il file è incredibilmente semplice, possiamo semplicemente importare l'istanza Flask dalla nostra applicazione e quindi eseguirla:

~/flaskproject/wsgi.py
from flaskproject import app

if __name__ == "__main__":
    app.run()

Salva e chiudi il file quando hai finito.

Testare la capacità di Gunicorn di servire il progetto

Prima di andare avanti, dovremmo controllare che Gunicorn possa farlo correttamente. Possiamo farlo semplicemente passandogli il nome del nostro punto di ingresso. Questo è costruito dal nome del modulo (meno il .py estensione, come di consueto) più il nome del chiamabile all'interno dell'applicazione. Nel nostro caso, questo sarebbe wsgi:app .

Specificheremo anche l'interfaccia e la porta a cui associare in modo che venga avviato su un'interfaccia disponibile pubblicamente:

(flaskprojectenv) $ cd ~/flaskproject
(flaskprojectenv) $ gunicorn --bind 0.0.0.0:5000 wsgi:app

Visita di nuovo il nome di dominio o l'indirizzo IP del tuo server con :5000 aggiunto alla fine nel tuo browser web:

http://server_domain_or_IP:5000

Dovresti vedere di nuovo l'output della tua applicazione:

Dopo aver verificato che funziona correttamente, premi CTRL-C nella finestra del tuo terminale.
Ora abbiamo finito con il nostro ambiente virtuale, quindi possiamo disattivarlo:

(flaskprojectenv) $ deactivate

Qualsiasi comando Python ora utilizzerà nuovamente l'ambiente Python del sistema.

Crea un file Unit di sistema

Il prossimo pezzo di cui dobbiamo occuparci è il file dell'unità di servizio systemd. La creazione di un file di unità systemd consentirà al sistema init di Ubuntu di avviare automaticamente Gunicorn e servire la nostra applicazione Flask ogni volta che il server si avvia.

Crea un file di unità che termina con .service all'interno di /etc/systemd/system directory per iniziare:

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

All'interno, inizieremo con il [Unit] sezione, che viene utilizzata per specificare metadati e dipendenze. Metteremo qui una descrizione del nostro servizio e diremo a init sistema per avviarlo solo dopo che l'obiettivo di rete è stato raggiunto

Successivamente, apriremo il [Service] sezione. Specifichiamo l'utente e il gruppo in cui vogliamo che venga eseguito il processo. Daremo al nostro account utente regolare la proprietà del processo poiché possiede tutti i file pertinenti. Daremo la proprietà del gruppo ai www-data gruppo in modo che Nginx possa comunicare facilmente con i processi Gunicorn.

Quindi mapperemo la directory di lavoro e imposteremo la variabile ambientale PATH in modo che init il sistema sa dove si trovano gli eseguibili per il processo (all'interno del nostro ambiente virtuale). Definiremo quindi il comando per avviare il servizio. Systemd richiede di fornire il percorso completo all'eseguibile Gunicorn, che è installato nel nostro ambiente virtuale.

Gli diremo di avviare 3 processi di lavoro (regolarlo se necessario). Gli diremo anche di creare e associare un file socket Unix all'interno della nostra directory di progetto chiamata flaskproject.sock . Imposteremo un valore umask di 007 in modo che il file socket venga creato dando accesso al proprietario e al gruppo, limitando al contempo altri accessi. Infine, dobbiamo passare il nome del file del punto di ingresso WSGI e il richiamabile Python all'interno.

Infine, aggiungeremo un [Install] sezione. Questo dirà a systemd a cosa collegare questo servizio se lo consentiamo per l'avvio all'avvio. Vogliamo che questo servizio venga avviato quando il normale sistema multiutente è attivo e funzionante:

/etc/systemd/system/flaskproject.service
[Unit]
Description=Gunicorn instance to serve flaskproject
After=network.target

[Service]
User=bobby
Group=www-data
WorkingDirectory=/home/bobby/flaskproject
Environment="PATH=/home/bobby/flaskproject/flaskprojectenv/bin"
ExecStart=/home/bobby/flaskproject/flaskprojectenv/bin/gunicorn --workers 3 --bind unix:flaskproject.sock -m 007 wsgi:app

[Install]
WantedBy=multi-user.target

Con ciò, il nostro file di servizio systemd è completo. Salvalo e chiudilo ora.

Ora possiamo avviare il servizio Gunicorn che abbiamo creato e abilitarlo in modo che si avvii all'avvio:

$ sudo systemctl start flaskproject
$ sudo systemctl enable flaskproject

Configurazione di Nginx in richieste proxy

Il nostro server delle applicazioni Gunicorn dovrebbe ora essere attivo e funzionante, in attesa di richieste sul file socket nella directory del progetto. Abbiamo bisogno di configurare Nginx per passare le richieste web a quel socket apportando alcune piccole aggiunte al suo file di configurazione.

Inizia creando un nuovo file di configurazione del blocco server in sites-available di Nginx directory. Chiameremo semplicemente questo flaskproject per restare in linea con il resto dell'articolo:

$ sudo nano /etc/nginx/sites-available/flaskproject

Apri un server bloccare e dire a Nginx di rimanere in ascolto sulla porta predefinita 80. Dobbiamo anche dirgli di utilizzare questo blocco per le richieste del nome di dominio o dell'indirizzo IP del nostro server.

L'unica altra cosa che dobbiamo aggiungere è una location blocco che corrisponde a ogni richiesta. All'interno di questo blocco, includeremo i proxy_params file che specifica alcuni parametri generali di proxy che devono essere impostati. Passeremo quindi le richieste al socket che abbiamo definito usando il proxy_pass direttiva:

/etc/nginx/sites-available/flaskproject
server {
    listen 80;
    server_name server_domain_or_IP;

    location / {
        include proxy_params;
        proxy_pass http://unix:/home/bobby/flaskproject/flaskproject.sock;
    }
}

Questo è in realtà tutto ciò di cui abbiamo bisogno per servire la nostra applicazione. Salva e chiudi il file quando hai finito.

Per abilitare il server di Nginx blocca la configurazione che abbiamo appena creato, collega il file a sites-enabled directory:

$ sudo ln -s /etc/nginx/sites-available/flaskproject /etc/nginx/sites-enabled

Con il file in quella directory, possiamo verificare la presenza di errori di sintassi digitando:

$ sudo nginx -t

Se questo ritorna senza indicare alcun problema, possiamo riavviare il processo Nginx per leggere la nostra nuova configurazione:

$ sudo systemctl restart nginx

L'ultima cosa che dobbiamo fare è regolare di nuovo il nostro firewall. Non abbiamo più bisogno dell'accesso tramite la porta 5000, quindi possiamo rimuovere quella regola. Possiamo quindi consentire l'accesso al server Nginx:

$ sudo ufw delete allow 5000
$ sudo ufw allow 'Nginx Full'

Ora dovresti essere in grado di accedere al nome di dominio o all'indirizzo IP del tuo server nel tuo browser web:

http://server_domain_or_IP

Dovresti vedere l'output della tua applicazione:

Nota:dopo aver configurato Nginx, il passaggio successivo dovrebbe essere la protezione del traffico verso il server tramite SSL/TLS. Questo è importante perché senza di essa, tutte le informazioni, comprese le password, vengono inviate sulla rete in testo normale. Il modo più semplice per ottenere un certificato SSL per proteggere il tuo traffico è utilizzare Let's Encrypt.