Logo Zephyrnet

Intelligenza generativa dei dati

Big Data

Distribuzione del modello di machine learning utilizzando Flask su AWS con Gunicorn e Nginx

Ripubblicato da Platone
Ripubblicato da Platone

Data:

Visualizzazioni: 45

Introduzione

Nell'articolo precedente, abbiamo esaminato il processo di creazione di un modello di apprendimento automatico per l'analisi del sentiment incapsulato in un'applicazione Flask. Questa applicazione Flask utilizza l'analisi del sentiment per classificare i tweet come positivi o negativi. Pronto per l'implementazione, il progetto completo è controllato in versione su GitHub. Andando oltre, esamineremo ora come utilizzare Gunicorn e Nginx per distribuire questa applicazione Flask su un server cloud, garantendo che il modello di machine learning sia scalabile e accessibile in un ambiente di produzione.

Puoi seguire l'articolo precedente su Come distribuire un modello di machine learning utilizzando Flask?

Riprendendo da dove avevamo interrotto, utilizzeremo Gunicorn e NGINX per distribuire questa applicazione Flask su un server cloud. Questo post spiegherà lo spostamento di un'applicazione Flask originariamente ospitata localmente per la distribuzione del machine learning nel cloud.

Distribuzione del modello di machine learning utilizzando Flask su AWS con Gunicorn e Nginx

Sommario

I passaggi includono

  • Configura un'istanza AWS EC2: Avvia un'istanza AWS EC2 con Ubuntu come sistema operativo. Configura i gruppi di sicurezza per consentire il traffico in entrata.
  • SSH nell'istanza EC2: Utilizza SSH per connetterti alla tua istanza EC2 dal tuo macWeis locale. Richiediamo una coppia di chiavi SSH (pubblica e privata) per connetterci al tuo sistema locale.
  • Distribuire l'applicazione Flask: Trasferisci i file dell'applicazione Flask nell'istanza EC2. Se il modello è già su Git Hub, clonalo nell'istanza Ubuntu EC2. Quindi, configura un ambiente virtuale e installa i pacchetti Python richiesti o il file dei requisiti nella directory utilizzando pip. Verifica se l'applicazione Flask viene eseguita correttamente nell'ambiente EC2.
  • Installa le dipendenze: Aggiorna gli elenchi dei pacchetti per gli aggiornamenti e installa le dipendenze necessarie, come Python, pip e qualsiasi altra libreria richiesta dalla tua applicazione Flask.
  • Installa e configura Gunicorn: Installa Gunicorn, un server HTTP WSGI per applicazioni Python. Crea un file di servizio Gunicorn per gestire il processo di richiesta. Avvia e abilita l'esecuzione del servizio Gunicorn in background.
  • Installa e configura NGINX: Installa NGINX, un server Web ad alte prestazioni e un proxy inverso. Configura NGINX per inoltrare le richieste HTTP in entrata al server Gunicorn. Configura blocchi server (host virtuali) per la tua applicazione Flask.
  • Configura il nome di dominio (facoltativo): Se disponi di un nome di dominio, configura le impostazioni DNS in modo che puntino all'indirizzo IP pubblico della tua istanza EC2. In caso contrario, puoi accedere alla tua applicazione Flask direttamente dall'indirizzo IP pubblico.
  • Proteggi l'applicazione: Abilita HTTPS per una comunicazione sicura tra client e server. Ottieni un certificato SSL/TLS (ad esempio, Let's Encrypt) e configura NGINX per utilizzarlo.
  • Testare la distribuzione: Una volta configurato tutto, testa l'applicazione Flask distribuita accedendovi tramite un browser Web o inviando richieste utilizzando cURL o Postman.

Seguendo questi passaggi, distribuiremo con successo la tua applicazione Flask per l'apprendimento automatico su un'istanza AWS EC2, utilizzando Gunicorn come server WSGI e NGINX come server proxy inverso per gestire le richieste in entrata in modo efficiente e sicuro.

Prima di entrare nel vivo, capiamo come è fatto.

Comprensione della comunicazione: Flask, Gunicorn e Nginx

             +-----------------------------+
             |           Client            |
             +-----------------------------+
                          |
                          |
             +------------v-------------+
             |        NGINX (Port 80)   |
             +------------+-------------+
                          |
                          |
             +------------v-------------+
             |       Gunicorn           |
             |     (WSGI Server)        |
             +------------+-------------+
                          |
                          |
             +------------v-------------+
             |   Flask Application      |
             |       (Python)           |
             +--------------------------+

Flacone: il centro dell'applicazione

Flask è un framework web Python leggero e flessibile che fornisce gli strumenti per creare applicazioni/servizi web. Costituisce la base del tuo servizio di analisi del sentiment, poiché gestisce le richieste web in arrivo, le elabora utilizzando il modello di apprendimento automatico e restituisce i risultati dell'analisi. Flask funziona come livello di applicazione nel nostro stack.

Abbiamo già creato l'applicazione Flask nell'articolo precedente. E clonarlo usando il comando.

https://github.com/Geek-shikha/Flask_model_sentiment_analysis.git

Flask da solo non è in grado di gestire più richieste contemporaneamente; è allora che entra in gioco Gunicorn.

Gunicorn: il server HTTP WSGI Python

Gunicorn funge da livello intermedio che si interfaccia con Flask. È un server HTTP WSGI Python progettato per i sistemi UNIX, che offre un modo semplice ma efficiente per distribuire applicazioni web Python. Quando esegui l'app Flask con Gunicorn, viene creato un server WSGI che comunica con l'applicazione Flask. Gunicorn gestisce più processi di lavoro per gestire le richieste in entrata, distribuire il carico e aumentare la capacità di gestire utenti simultanei. No. Il numero di lavoratori e thread dipende dal numero di core del sistema, 2*Core +1.

Finché non si dispone del multithreading, non esiste spazio di memoria separato. Un singolo lavoratore può gestire più richieste dai client in parallelo.

Perché è necessario il Gunicorn?

Per vari motivi, Gunicorn, o Green Unicorn, è un componente cruciale nell'hosting delle applicazioni Flask. Innanzitutto, il server di sviluppo integrato di Flask non può gestire più richieste contemporaneamente, rendendolo inadatto agli ambienti di produzione. Il suo modello di lavoro pre-fork consente la scalabilità eseguendo numerosi processi o thread di lavoro, accogliendo in modo efficace l'aumento del traffico. Il bilanciamento del carico di G Unicorn distribuisce le richieste in modo uniforme, migliorando le prestazioni sotto carichi pesanti. Conforme alle specifiche WSGI, Gunicorn si integra perfettamente con Flask e altri framework conformi a WSGI, semplificando la distribuzione. Gunicorn fornisce funzionalità essenziali come concorrenza, scalabilità, prestazioni e compatibilità, rendendolo indispensabile per la distribuzione delle applicazioni Flask in produzione.

Nginx: il proxy inverso in prima linea

Nginx è un server Web potente e ad alte prestazioni noto per la sua stabilità, configurazione semplice e basso consumo di risorse. Nella nostra implementazione, Nginx è configurato come proxy inverso, posizionato di fronte a Gunicorn. Riceve le richieste dei clienti e le inoltra a Gunicorn, che a sua volta comunica con l'applicazione Flask. Nginx è anche responsabile della fornitura di file statici, della gestione della crittografia SSL/TLS e del potenziale bilanciamento del carico se l'applicazione si adatta a più server.

Perché Nginx?

Oltre a fornire inoltre, NGINX eccelle nella gestione di più modelli o applicazioni contemporaneamente, grazie alle sue robuste capacità di bilanciamento del carico e ai meccanismi di buffering. Mentre Gunicorn può avere difficoltà con la velocità di elaborazione di richieste multiple, NGINX può gestire in modo efficiente questo carico di lavoro memorizzando nel buffer le richieste, garantendo un funzionamento più fluido. Inoltre, NGINX fornisce funzionalità essenziali come la terminazione SSL, l'autenticazione dei token e il bilanciamento del carico, rendendolo indispensabile per proteggere e ottimizzare le applicazioni Flask. Per ulteriore scalabilità e flessibilità, Docker o Kubernetes possono essere integrati insieme a NGINX, consentendo il ridimensionamento dinamico e la gestione semplificata dei servizi. Sia che venga distribuito su AWS o Kubernetes, NGINX rimane uno strumento versatile e potente per ospitare applicazioni Flask su larga scala.

Pre requisiti

Prima di utilizzare i passaggi per distribuire il modello, è necessario comprendere e avere quanto segue.

Account AWS: È necessario un account AWS per accedere a EC2 e ad altri servizi AWS. Se non disponi di un account, puoi crearne uno sul sito Web di AWS.

Se vuoi che la tua app appaia con un nome, devi avere un nome di dominio configurato per puntare al tuo server. Puoi ottenerne uno gratuitamente su Freenom. Non ne abbiamo bisogno qui poiché utilizzeremo direttamente l'indirizzo IP pubblico.

Comprensione delle specifiche dei file WSGI e dei server, proxy e porte. Anche un po’ di comprensione aiuterà.

Distribuzione del modello di machine learning utilizzando Flask su AWS con Gunicorn e Nginx

FASE 1: configura un'istanza AWS EC2

Avvia un'istanza AWS EC2 con Ubuntu come sistema operativo. Un microservizio funzionerebbe perfettamente. Manteniamo il nome dell'istanza come sentiment_analysis_server. Sei libero di scegliere ciò che ti piace. Ma ricorda, la selezione del servizio dell'istanza dipende dalla scala dell'applicazione che stai tentando di ospitare.

Configura un'istanza AWS EC2

Crea una coppia di chiavi per connetterti in modo sicuro al tuo EC2 tramite SSH. Quando crei un'istanza EC2, specifichi una coppia di chiavi e il file della chiave privata corrispondente (.pem) viene utilizzato per autenticare la connessione SSH all'istanza. Utilizza una coppia di chiavi di tipo RSA e segui i passaggi seguenti.

  1. Crea coppia di chiavi: Fare clic sul pulsante "Crea coppia di chiavi" per generare la coppia di chiavi.
  2. Scarica la chiave privata: Una volta creata la coppia di chiavi, un file di chiave privata (.pem) verrà automaticamente scaricato sul tuo computer locale. Questo file di chiave privata autentica le connessioni SSH alle tue istanze EC2.
Configura un'istanza AWS EC2

Avvia la tua istanza con configurazioni di sicurezza che consentono il traffico porta e http. Dopo aver avviato e connesso la tua istanza, copia il comando SSH da essa in modo da poterlo pubblicare sul tuo terminale locale per accedere all'istanza in remoto. Nell'immagine seguente, la parte evidenziata in verde è ciò che devi copiare e incollare nel tuo locale/terminale.

Connetti all'istanza

FASE 2: SSH nell'istanza EC2

Apri il terminale del tuo computer. Se il file della chiave privata (.pem) si trova in una directory, dovrai specificare il percorso completo del file della chiave quando utilizzi il comando SSH per connetterti all'istanza EC2. Ecco come puoi farlo:

Supponiamo che la tua chiave (file .pem) sia in Download. Quindi, devi inserire lì il tuo comando SSH. Quindi, tutto ciò che devi fare è aprire il terminale, accedere alla directory Download e incollare lì il comando.

cd ~/Downloads

Ora incolla il tuo comando SSH, che potrebbe assomigliare all'esempio: ssh -i “sentiment_analysiskey.pem” [email protected]

SSH nell'istanza EC2

PASSO 3: Installazione dei componenti necessari dai repository Ubuntu

Il primo passo è installare tutti i componenti necessari dai repository di Ubuntu. Ciò include i componenti Python, che Pip gestirà, e il gestore pacchetti Python. Verranno inoltre forniti i file di sviluppo Python necessari per assemblare i componenti Gunicorn. Quando installi i pacchetti che ti consentono di creare il tuo ambiente Python, devi prima aggiornare l'indice del pacchetto locale.

sudo apt update 
sudp apt upgrade

Quindi, installa il comando Python-pip per installare pip e l'ambiente virtuale.

sudo apt install python3-pip
sudo apt install python3-venv

Quindi, installa il pacchetto net stat. Il pacchetto net-tools visualizza informazioni relative alla rete, come connessioni di rete attive, tabelle di routing, statistiche dell'interfaccia, ecc.

sudo apt installa net-tools

sudo apt install net-tools

netstat tuln #after installing run this command

Visualizza un elenco di connessioni di rete attive e porte di ascolto sul sistema:

Quindi installa il pacchetto firewall: il pacchetto ufw (Uncomplicated Firewall) è un front-end per la gestione delle regole del firewall iptables su Ubuntu e altre distribuzioni Linux basate su Debian. Fornisce un'interfaccia semplificata per la configurazione delle regole del firewall, semplificando l'impostazione della protezione firewall essenziale per il tuo sistema

  • sudo ufw abilita: Abilita il firewall.
  • Sudo ufw consenti /: Questo comando consente le connessioni in entrata su una porta e un protocollo specifici (ad esempio, sudo ufw consente a 22/TCP di abilitare le connessioni SSH).
  • Stato sudo ufw: Visualizza lo stato attuale e le regole del firewall.
sudo apt install ufw #
sudo ufw allow 22 #ssh access
sudo ufw allow 5000  #5000 port for flask app test 

sudo ufw status
  1. Sudo ufw consenti 5000: Ciò consente connessioni in entrata sulla porta 5000. Per impostazione predefinita, consente sia il traffico TCP che UDP su questa porta. Eseguiremo la nostra app Flask sulla porta 5000, quindi il servizio dell'app Flask in esecuzione sulla porta 5000 deve essere accessibile dalla rete.
  2. Sudo ufw consenti 22: Questo comando abilita le connessioni SSH in entrata sulla porta 22. SSH viene utilizzato per l'accesso remoto al tuo sistema e consentire le connessioni sulla porta 22 ti consente di connetterti al tuo server tramite SSH in modo sicuro. Questo è importante; non dovresti disattivarlo, poiché non sarai in grado di accedere al tuo SSH da remoto.

Passaggio 4: distribuire l'applicazione Flask e configurare l'applicazione

Distribuisci l'applicazione Flask: trasferisci i file dell'applicazione Flask nell'istanza EC2. Se il modello è già su Git Hub, clonalo nell'istanza Ubuntu EC2. Quindi, configura un nuovo ambiente virtuale e installa i pacchetti Python richiesti o il file dei requisiti nella directory utilizzando pip. Quindi, l'applicazione Test Flask viene eseguita correttamente nell'ambiente EC2.

Nel nostro caso stiamo clonando un repository git, che abbiamo utilizzato nello scorso articolo per analizzare il sentiment di un tweet.

Ma prima assicurati che Git sia installato. Se è installato, esegui il comando: git clone -b master –single-branch https://github.com/Geek-shikha/Flask_model_sentiment_analysis.git

git --version # if this exists you need not to sudo apt install git 
git clone -b master --single-branch 
https://github.com/Geek-shikha/Flask_model_sentiment_analysis.git #same line 

#after cloning the repository go tot the directory and list all the files 
cd Flask_model_sentiment_analysis
ls

Nota: Quando cloni il repository, non vedrai alcun file app.py; è invece presente myproject.py, di cui abbiamo bisogno.

Esiste un ambiente virtuale esistente che abbiamo creato in precedenza durante la creazione di un'app Flask in locale. Dobbiamo creare un nuovo ambiente virtuale per evitare errori o discrepanze. Il nuovo ambiente virtuale si chiama “myprojectenv” e deve essere attivato.

python -m venv myprojectenv #virtual env named as myprojectenv
source myprojectenv/bin/activate #activate the virtual environment

Installa le librerie Python archiviate in requisiti.txt

pip install -r requirements.txt #install the dependencies like flask, nltk etc.

Ora testa ed esegui la tua applicazione Python Flask

python3 myproject.py

Eseguendo questo, puoi vedere un output nel terminale come questo:

Per vedere se funziona. Visita l'indirizzo IP del tuo server seguito da:5000 nel tuo browser web. Sul tuo browser web, l'IP del tuo server è 5000, come http://server_pub_ip:5000. Diciamo che l'IP del server è  23.124.09.133 Quindi metti http://23.124.09.133:5000 

Passaggio 5: file WSGI

Successivamente, crea un file che fungerà da punto di ingresso per la tua applicazione. Questo file istruirà il server Gunicorn a interagire con l'applicazione.

creare un file wsgi.py nella cartella Flask_model_sentiment_analysis

nano ~/Flask_model_sentiment_analysis/wsgi.py

In questo file, importa l'istanza Flask dalla nostra applicazione, che abbiamo chiamato myproject.py, quindi eseguila:

from myproject import app

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

Puoi anche installare sudo apt e unicorn in caso di errori.

Passaggio 6: configurazione Gunicorn

Iniziamo configurando Gunicorn e associando l'app wsgi alla porta 5000

Il comando unicorn configure avvia un server Gunicorn che ascolta le connessioni in entrata sulla porta 5000 da qualsiasi indirizzo IP e serve l'applicazione WSGI denominata app definita nel file wsgi.py.

gunicorn --bind 0.0.0.0:5000 wsgi:app

Produzione:

Controlla se funziona. Visita l'indirizzo IP del tuo server seguito da:5000nel tuo browser web: Sul tuo browser web, l'IP del tuo server è 5000, come http://server_pub_ip:5000; diciamo che l'IP del server è  23.124.09.133 Quindi metti http://23.124.09.133:5000 

Dovrebbe darti un output come questo:

Se ottieni la risposta corretta, interrompi il servizio; puoi premere ctrl+c e quindi disattivare il tuo ambiente virtuale dando il comando. Successivamente, creare il file del sistema e dell'unità di servizio. Questa azione consentirà al sistema init di Ubuntu di avviare automaticamente Gunicorn e ospitare l'applicazione Flask all'avvio del server.

sudo nano /etc/systemd/system/myproject.service

Aggiungi il seguente contenuto:

[Unit]
Description=Gunicorn instance to serve myproject
After=network.target

[Service]
User=ubuntu
Group=www-data
WorkingDirectory=/home/ubuntu/Flask_model_sentiment_analysis
Environment="PATH=/ubuntu/Flask_model_sentiment_analysis/myprojectenv/bin"
ExecStart=/home/ubuntu/Flask_model_sentiment_analysis/myprojectenv/bin/gunicorn 
--workers 3 --bind unix:myproject.sock -m 007 w>
[Install]
WantedBy=multi-user.target
  • [Unità]: Questa sezione specifica i metadati e le dipendenze per l'unità.
  • Descrizione: Descrive il servizio.
  • Dopo = network.target: Indica che questa unità si avvia dopo che la rete è attiva, garantendo la connettività di rete prima dell'avvio del servizio.
  • [Servizio]: Questa sezione definisce i parametri per il servizio.
  • Utente=unitàubu: Specifica l'account utente con cui deve essere eseguito il servizio.
  • Gruppo=dati www: Imposta il gruppo per il servizio.
  • Directory di lavoro: Specifica la directory di lavoro per il servizio.
  • Ambiente=”PATH=/ubuntu/Flask_model_sentiment_analysis/myprojectenv/bin”: Questa variabile definisce le variabili di ambiente del servizio, impostando esplicitamente la variabile PATH per includere la directory binaria dell'ambiente virtuale.
  • Inizio esecuzione: Specifica il comando per avviare il servizio. In questo caso, avvia Gunicorn con opzioni specifiche:
  • –lavoratori 3: Configura Gunicorn per utilizzare tre processi di lavoro.
  • –bind unix: il mio progetto.sock: Specifica il file socket attraverso il quale Gunicorn comunicherà con il server web (ad esempio, Nginx o Apache).
  • -m 007: Imposta la maschera su 007, controllando i permessi dei file creati da Gunicorn.
  • wsgi:app: Indica la posizione dell'applicazione WSGI da servire.
  • [Installare]: Questa sezione definisce le informazioni di installazione per l'unità.
  • WantedBy=multi-utente.target: Specifica la destinazione in cui deve essere installata questa unità. In questo caso, è impostato su multiutente. Target, un target standard per i sistemi utente, indica che il servizio dovrebbe avviarsi automaticamente durante l'avvio del sistema.

In sintesi, questo file di unità di sistema configura Gunicorn per servire un'applicazione Flask con configurazioni specifiche e garantisce che il servizio venga avviato automaticamente all'avvio del sistema.

È ora di avviare il servizio Gunicorn che hai creato e abilitarlo in modo che si avvii all'avvio:

sudo systemctl start myproject
sudo systemctl enable myproject
sudo systemctl status myproject#check the status of your service file for errors, ifany

 Se il comando resiste, usalo per ricaricare "sudo systemctl daemon-reload",

Se hai seguito ogni passaggio, non dovrebbero esserci errori; tuttavia, se l'errore persiste, risolverlo. Potrebbe esserci un errore nel percorso o nell'ambiente nel file di servizio. Controlla attentamente

Passaggio 7: installa e configura NGINX

Il server delle applicazioni Gunicorn è operativo e in attesa di richieste tramite il file socket nella directory del progetto. Ora configureremo Nginx per indirizzare le richieste web a questo socket implementando piccole modifiche al suo file di configurazione. Per questo, dobbiamo prima installare nginx

sudo apt install nginx

Inizia generando un nuovo file di configurazione del blocco server nella directory dei siti disponibili di Nginx. Chiama questo file "progetto" per non confonderti. In precedenza abbiamo utilizzato il nome myproject.py

sudo nano /etc/nginx/sites-available/myproject

per aggiungere il contenuto al file, che ha la configurazione del blocco del server Nginx che garantisce che le richieste HTTP in entrata all'indirizzo IP del server specificato vengano inoltrate al server dell'applicazione Gunicorn tramite il file socket Unix, consentendo all'applicazione Flask di gestire le richieste. Salvare il file ed uscire dall'editor.

server {
    listen 80;
    server_name 3.110.196.110; #your server public ip 

    location / {
        include proxy_params;
        proxy_pass http://unix:/home/ubuntu/Flask_model_sentiment_analysis/myproject.sock;
    }
}
  • Server { … }: Questo blocco definisce una configurazione del server all'interno di Nginx. Incapsula le impostazioni di configurazione per la gestione delle richieste per un server specifico.
  • Ascolta 80: Questa direttiva specifica che Nginx dovrebbe ascoltare le richieste HTTP in entrata sulla porta 80, la porta predefinita per il traffico HTTP.
  • nome_server 3.110.196.110: Questa direttiva imposta il nome host o l'indirizzo IP del server. In questo caso, è impostato su 3.110.196.110, che dovrebbe essere sostituito con l'indirizzo IP pubblico del tuo server.
  • Posizione / { … }: questo blocco definisce come Nginx deve gestire le richieste per la directory root / del server.
  • Includi proxy_params: Questa direttiva fornisce le impostazioni di configurazione dal file proxy_params. Queste impostazioni in genere contengono configurazioni relative al proxy, come le intestazioni proxy.
  • proxy_pass http://unix:/home/ubuntu/Flask_model_sentiment_analysis/myproject.sock: Questa direttiva specifica che Nginx deve inoltrare le richieste in entrata al file socket Unix specificato situato in /home/ubuntu/Flask_model_sentiment_analysis/myproject.sock. È qui che Gunicorn ascolta le richieste. Nginx fungerà da proxy inverso, trasmettendo le richieste a Gunicorn e restituendo le risposte al client.

Ora abilita e verifica la presenza di errori

sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled
sudo nginx -t
  • sudo ln -s /etc/nginx/sites-available/mioprogetto /etc/nginx/sites-enabled: questo comando crea un collegamento simbolico denominato myproject nella directory sites-enabled, che punta al file di configurazione situato nella directory sites-available. In questo modo si abilita la configurazione del blocco server per il proprio progetto.
  • Sudo nginx -t: Questo comando verifica la presenza di errori di sintassi nella configurazione di Nginx. Controlla se i file di configurazione di Nginx, incluso il blocco del server myproject appena abilitato, sono scritti correttamente e sono validi. Se ci sono errori, verranno segnalati durante questo test.

Riavvia nginx poiché abbiamo aggiornato le configurazioni

sudo systemctl restart nginx

aggiornando il firewall per nginx

sudo ufw allow 'Nginx Full'

Poiché non abbiamo bisogno della porta 5000, possiamo disabilitarla utilizzando il comando "sudo ufw delete consent 5000", ma non è necessario disabilitare la porta 22.

Ora vai al nome di dominio del tuo server (o indirizzo IP) nel tuo browser web e vedrai l'output:

Se vedi errori come 502 gateway, devi modificare alcune autorizzazioni. Usa il comando

sudo chmod 755 /home/ubuntu

Inoltre, quando provi l'applicazione sul tuo server, dovresti utilizzare http://….. e non https, poiché l'applicazione non è protetta.

Se ci sono errori, puoi controllarli tramite comandi come:

Passaggio 7: installa e configura NGINX

Se vuoi interrompere il servizio, puoi usare il comando

sudo systemctl stop nginx #stop the service 
sudo systemctl start nginx# to start the service

Ulteriori passaggi per proteggere l'applicazione

Sono necessari ulteriori passaggi per proteggere l'applicazione.  

Abilita HTTPS per una comunicazione sicura tra client e server. Ottieni un certificato SSL/TLS (ad esempio, Let's Encrypt) e configura NGINX per utilizzarlo. Possiamo utilizzare Certbot per proteggere l'applicazione.

Per proteggere il tuo server web con SSL/TLS utilizzando Certbot, in genere è necessario un nome di dominio registrato. Certbot richiede un nome di dominio per emettere certificati SSL perché verifica la proprietà del dominio prima di emettere il certificato. Sebbene sia tecnicamente possibile utilizzare un indirizzo IP pubblico anziché un nome di dominio, non è consigliabile per diversi motivi. Uno è i requisiti dell'autorità di certificazione (CA): le autorità di certificazione (CA) come Let's Encrypt (utilizzato da Certbot) dispongono di politiche che richiedono la convalida del dominio. Non emetteranno certificati SSL per gli indirizzi IP.

Se vuoi proteggerlo, puoi usare sudo apt install python3-certbot-nginx e saperne di più nella sua documentazione.

Conclusione

In questo articolo abbiamo creato un'applicazione Flask di base all'interno di un ambiente virtuale Python. Abbiamo generato un punto di ingresso WSGI, consentendo la compatibilità con qualsiasi server applicativo compatibile con WSGI, quindi configurato Gunicorn per svolgere questo ruolo. Successivamente, abbiamo creato un file di servizio di sistema per avviare automaticamente il server delle applicazioni all'avvio del sistema. Inoltre, hai costruito un blocco server Nginx responsabile di indirizzare il traffico del client Web al server delle applicazioni, inoltrando in modo efficace le richieste esterne e salvaguardando il traffico del server con la crittografia Let's Encrypt.

spot_img

L'ultima intelligenza

spot_img

Copyright @ 2024 Plato Technologies Inc.