Configurare il server di sviluppo Flask in modo che sia visibile attraverso la rete

Non sono sicuro che si tratti di Flask specifico, ma quando eseguo un'app in modalità dev ( http://localhost:5000), non riesco ad accedervi da altre macchine sulla rete (con http://[dev-host-ip]:5000). Con Rails in modalità dev, ad esempio, funziona benissimo. Non sono riuscito a trovare alcun documento relativo alla configurazione del server di sviluppo Flask. Qualche idea su cosa dovrebbe essere configurato per abilitare questo?

Sebbene ciò sia possibile, non è necessario utilizzare il server di sviluppo Flask in produzione. Il server di sviluppo Flask non è progettato per essere particolarmente sicuro, stabile o efficiente. Consulta i documenti sulla distribuzione per le soluzioni corrette.

Aggiungi un parametro al tuo app.run(). Per impostazione predefinita, viene eseguito su localhost, modificarlo app.run(host= '0.0.0.0')per eseguirlo sull'indirizzo IP del computer.

Documentato sul sito Flask in "Server visibile esternamente" nella pagina Avvio rapido :

Server visibile esternamente

Se si esegue il server, si noterà che il server è disponibile solo dal proprio computer, non da qualsiasi altro nella rete. Questo è il valore predefinito perché in modalità debug un utente dell'applicazione può eseguire codice Python arbitrario sul tuo computer. Se il debug è disabilitato o gli utenti della rete sono affidabili, è possibile rendere il server pubblicamente disponibile.

Basta cambiare la chiamata del run()metodo per assomigliare a questo:

app.run(host='0.0.0.0')

Questo dice al tuo sistema operativo di ascoltare su un IP pubblico.

Se si utilizza l'eseguibile di pallone per avviare il server, è possibile utilizzare flask run --host=0.0.0.0per modificare il valore predefinito da 127.0.0.1 e aprirlo a connessioni non locali. I metodi config e app.run che descrivono le altre risposte sono probabilmente una pratica migliore, ma anche questo può essere utile.

Server visibile esternamente Se si esegue il server, si noterà che il server è accessibile solo dal proprio computer, non da qualsiasi altro nella rete. Questo è il valore predefinito perché in modalità debug un utente dell'applicazione può eseguire codice Python arbitrario sul tuo computer.

Se il debugger è disabilitato o si fidano degli utenti sulla rete, è possibile rendere il server pubblicamente disponibile semplicemente aggiungendo --host = 0.0.0.0 alla riga di comando:

flask run --host = 0.0.0.0 Questo dice al tuo sistema operativo di ascoltare su tutti gli IP pubblici.

Riferimento: http://flask.pocoo.org/docs/0.11/quickstart/

Prova questo se il metodo 0.0.0.0 non funziona

Roba noiosa

Personalmente ho lottato molto per rendere la mia app accessibile ad altri dispositivi (laptop e telefoni cellulari) attraverso un server locale. Ho provato il metodo 0.0.0.0, ma senza fortuna. Quindi ho provato a cambiare la porta, ma non ha funzionato. Quindi, dopo aver provato un sacco di combinazioni diverse, sono arrivato a questo e ho risolto il mio problema di distribuire la mia app su un server locale.

passi

1. Ottieni l'indirizzo IPv4 locale del tuo computer. Questo può essere fatto digitando ipconfigsu Windows e ifconfigsu Linux e Mac.

Nota: il passaggio sopra deve essere eseguito sul computer su cui stai offrendo l'app e non sul computer su cui accedi. Si noti inoltre che l'indirizzo IPv4 potrebbe cambiare se ci si disconnette e si riconnette alla rete.

2. Ora, esegui semplicemente l'app di pallone con l'indirizzo IPv4 acquisito.

   flask run -h 192.168.X.X

   Ad esempio, nel mio caso (vedi l'immagine), l'ho eseguito come:

   flask run -h 192.168.1.100

Sul mio dispositivo mobile

Roba opzionale

Se si esegue questa procedura su Windows e si utilizza Power Shell come CLI e non si è ancora in grado di accedere al sito Web, provare un comando CTRL + C nella shell su cui è in esecuzione l'app. Power Shell si blocca a volte e ha bisogno di un pizzico per rianimarsi. In questo modo potrebbe anche terminare il server, ma a volte fa il trucco.

Questo è tutto. Dare un pollice in su se lo hai trovato utile. 😉

Altre cose opzionali

Ho creato uno script Powershell breve che ti fornirà il tuo indirizzo IP ogni volta che ne avrai bisogno:

$env:getIp = ipconfig
if ($env:getIp -match '(IPv4[\sa-zA-Z.]+:\s[0-9.]+)') {
    if ($matches[1] -match '([^a-z\s][\d]+[.\d]+)'){
        $ipv4 = $matches[1]
    }
}
echo $ipv4

Salvalo in un file con estensione .ps1 (per PowerShell) ed eseguilo prima di avviare l'app. Puoi salvarlo nella cartella del tuo progetto ed eseguirlo come:

.\getIP.ps1; flask run -h $ipv4

Nota: ho salvato il codice della shell sopra in getIP.ps1.

Cool.👌

Se tuo cool app ha la configurazione caricata da un file esterno, come nell'esempio seguente, non dimenticare di aggiornare il file di configurazione corrispondente con HOST = "0.0.0.0"

cool.app.run(
    host=cool.app.config.get("HOST", "localhost"),
    port=cool.app.config.get("PORT", 9000)
)            

Aggiungi le righe sottostanti al tuo progetto

if __name__ == '__main__':
    app.debug = True
    app.run(host = '0.0.0.0',port=5005)

Controllare se la porta particolare è aperta sul server per servire il client o no?

nella distribuzione Ubuntu o Linux

sudo ufw enable
sudo ufw allow 5000/tcp //allow the server to handle the request on port 5000

Configurare l'applicazione per gestire le richieste remote

app.run(host='0.0.0.0' , port=5000)


python3 app.py & #run application in background

Vai al percorso del tuo progetto su CMD (prompt dei comandi) ed esegui il comando seguente: -

impostare FLASK_APP = ABC.py

SET FLASK_ENV = sviluppo

flask run -h [yourIP] -p 8080

otterrai la seguente o / p su CMD: -

• Applicazione Flask "expirement.py" (caricamento lento)
  • Ambiente: sviluppo
  • Modalità debug: attiva
  • Riavvio con stat
  • Il debugger è attivo!
  • PIN di debugger: 199-519-700
  • In esecuzione su http: // [yourIP]: 8080 / (premi CTRL + C per uscire)

Ora puoi accedere all'app per matracci su un altro computer usando http: // [yourIP]: 8080 / url

Se riscontri problemi nell'accedere al tuo server Flask, distribuito utilizzando PyCharm , prendi in considerazione quanto segue:

PyCharm non esegue direttamente il tuo file .py principale, quindi if __name__ == '__main__':non verrà eseguito alcun codice in e qualsiasi modifica (come app.run(host='0.0.0.0', port=5000)) avrà effetto.

Invece, è necessario configurare il server Flask usando Run Configurations, in particolare, inserendolo --host 0.0.0.0 --port 5000nel campo Opzioni aggiuntive .

Ulteriori informazioni sulla configurazione del server Flask in PyCharm

Per me ho seguito la risposta sopra e l'ho modificata un po ':

1. Prendi il tuo indirizzo ipv4 usando ipconfig al prompt dei comandi
2. Vai al file in cui è presente il codice pallone
3. Nella funzione principale scrivi app.run (host = 'tuo indirizzo ipv4')

Per esempio:

Ho avuto lo stesso problema, utilizzo PyCharm come editor e quando ho creato il progetto, PyCharm ha creato un Flask Server. Quello che ho fatto è stato creare un server con Python nel modo seguente;

fondamentalmente quello che ho fatto è stato creare un nuovo server, ma pallone se non Python

Spero che ti aiuti

Questa risposta non è esclusivamente correlata al pallone, ma dovrebbe essere applicabile a tutti non è possibile connettere il servizio da un altro problema host .

1. uso netstat -ano | grep <port> per vedere se l'indirizzo è 0.0.0.0 o ::. Se è 127.0.0.1, è solo per le richieste locali.
2. usa tcpdump per vedere se manca qualche pacchetto. Se mostra uno squilibrio evidente, controlla le regole di routing per iptables.

Oggi eseguo la mia app di pallone come al solito, ma ho notato che non è possibile connettersi da un altro server. Quindi corro netstat -ano | grep <port>, e l'indirizzo locale è ::o 0.0.0.0(ho provato entrambi e so che 127.0.0.1 consente solo la connessione dall'host locale). Poi ho usato telnet host port, il risultato è come connect to .... Questo è molto strano. Quindi ho pensato di fare un controllo con tcpdump -i any port <port> -w w.pcap. E ho notato che è tutto così:

Quindi, controllando la iptables --listsezione OUTPUT, ho potuto vedere diverse regole:

queste regole vietano l'output di pacchetti vitali in stretta di mano. Eliminandoli, il problema scompare.

vai al percorso del progetto set FLASK_APP = ABC.py SET FLASK_ENV = sviluppo

flask run -h [yourIP] -p 8080 seguirai o / p su CMD: - * Fornisce l'app Flask "expirement.py" (caricamento lento) * Ambiente: sviluppo * Modalità debug: attiva * Riavvio con stat * Il debugger è attivo ! * PIN del debugger: 199-519-700 * In esecuzione http: // [tuoIP]: 8080 / (Premi CTRL + C per uscire)

È inoltre possibile impostare l'host (per esporlo su una rete con indirizzo IP) e la porta tramite variabili di ambiente.

$ export FLASK_APP=app.py
$ export FLASK_ENV=development
$ export FLASK_RUN_PORT=8000
$ export FLASK_RUN_HOST=0.0.0.0

$ flask run
 * Serving Flask app "app.py" (lazy loading)
 * Environment: development
 * Debug mode: on
 * Running on https://0.0.0.0:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 329-665-000

Vedi Come ottenere tutte le opzioni di comando disponibili per impostare le variabili di ambiente?

Crea file .flaskenv nella directory principale del progetto.

I parametri in questo file sono in genere:

FLASK_APP=app.py
FLASK_ENV=development
FLASK_RUN_HOST=[dev-host-ip]
FLASK_RUN_PORT=5000

Se si dispone di un ambiente virtuale, attivarlo e fare un pip install python-dotenv .

Questo pacchetto utilizzerà il .flaskenvfile e le dichiarazioni al suo interno saranno automaticamente importate nelle sessioni del terminale.

Quindi puoi farlo flask run