Implementazione di un'applicazione Flask in Elastic Beanstalk - AWS Elastic Beanstalk
PrerequisitiConfigurazione di un ambiente virtuale Python con FlaskCreazione di un'applicazione FlaskImplementa il tuo sito con l'EB CLIPuliziaPassaggi successivi

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Implementazione di un'applicazione Flask in Elastic Beanstalk

Questo tutorial illustra il processo di generazione di un'applicazione Flask e la sua distribuzione in un ambiente. AWS Elastic Beanstalk Flask è un framework di applicazione Web open source per Python.

In questo tutorial, verranno eseguite le operazioni seguenti:

Prerequisiti

Questo tutorial presuppone determinate conoscenze sulle operazioni di base di Elastic Beanstalk e della console Elastic Beanstalk. Se non lo hai già fatto, segui le istruzioni in Guida introduttiva a Elastic Beanstalk per avviare il tuo primo ambiente Elastic Beanstalk.

Per seguire le procedure in questa guida, devi usare un terminale a riga di comando o una shell per eseguire i comandi. I comandi vengono visualizzati in elenchi preceduti da un simbolo di prompt ($) e dal nome della directory corrente, se appropriato.

~/eb-project$ this is a command
this is output

Su Linux e macOS usa la tua shell e il tuo programma di gestione dei pacchetti preferiti. Su Windows puoi installare il sottosistema Windows per Linux per ottenere una versione integrata con Windows di Ubuntu e Bash.

Flask richiede Python 3.7 o versioni successive. In questo tutorial usiamo Python 3.7 e la corrispondente versione della piattaforma Elastic Beanstalk. Installa Python seguendo la procedura descritta in Configurazione dell'ambiente di sviluppo Python per Elastic Beanstalk.

Il framework Flask verrà installato nell'ambito di questo tutorial.

Questo tutorial utilizza anche l'Elastic Beanstalk Command Line Interface (EB). CLI Per i dettagli sull'installazione e la configurazione dell'EBCLI, consulta e. Installazione dell'interfaccia a riga di comando di Elastic Beanstalk Configurazione dell'interfaccia a riga di comando EB

Configurazione di un ambiente virtuale Python con Flask

Crea una directory di progetto e l'ambiente virtuale per la tua applicazione, quindi installa Flask.

Per configurare l'ambiente di progetto

  1. Crea una directory di progetto.

    ~$ mkdir eb-flask
~$ cd eb-flask

  2. Crea e attiva un ambiente virtuale denominato virt:

    ~/eb-flask$ virtualenv virt
~$ source virt/bin/activate
(virt) ~/eb-flask$

    Visualizzerai (virt) anteposto al prompt dei comandi, a indicare che sei in un ambiente virtuale. Utilizza l'ambiente virtuale per le restanti operazioni di questo tutorial.

  3. Installa Flask con pip install:

    (virt)~/eb-flask$ pip install flask==2.0.3

  4. Visualizza le librerie installate con pip freeze:

    (virt)~/eb-flask$ pip freeze
click==8.1.1
Flask==2.0.3
itsdangerous==2.1.2
Jinja2==3.1.1
MarkupSafe==2.1.1
Werkzeug==2.1.0

    Questo comando elenca tutti i pacchetti installati nell'ambiente virtuale. Poiché ci si trova in un ambiente virtuale, i pacchetti installati a livello globale come l'EB non CLI vengono visualizzati.

  5. Salva l'output da pip freeze in un file denominato requirements.txt.

    (virt)~/eb-flask$ pip freeze > requirements.txt

    Questo file indica a Elastic Beanstalk di installare le librerie durante la distribuzione. Per ulteriori informazioni, consulta Specificazione delle dipendenze utilizzando un file dei requisiti su Elastic Beanstalk.

Creazione di un'applicazione Flask

Successivamente, crea un'applicazione che distribuirai utilizzando Elastic Beanstalk. Creeremo un servizio RESTful web «Hello World».

In questa directory, crea un nuovo file di testo denominato application.py con il seguente contenuto:

Esempio ~/eb-flask/application.py
from flask import Flask

# print a nice greeting.
def say_hello(username = "World"):
    return '<p>Hello %s!</p>\n' % username

# some bits of text for the page.
header_text = '''
    <html>\n<head> <title>EB Flask Test</title> </head>\n<body>'''
instructions = '''
    <p><em>Hint</em>: This is a RESTful web service! Append a username
    to the URL (for example: <code>/Thelonious</code>) to say hello to
    someone specific.</p>\n'''
home_link = '<p><a href="/">Back</a></p>\n'
footer_text = '</body>\n</html>'

# EB looks for an 'application' callable by default.
application = Flask(__name__)

# add a rule for the index page.
application.add_url_rule('/', 'index', (lambda: header_text +
    say_hello() + instructions + footer_text))

# add a rule when the page is accessed with a name appended to the site
# URL.
application.add_url_rule('/<username>', 'hello', (lambda username:
    header_text + say_hello(username) + home_link + footer_text))

# run the app.
if __name__ == "__main__":
    # Setting debug to True enables debug output. This line should be
    # removed before deploying a production app.
    application.debug = True
    application.run()

Questo esempio stampa un saluto personalizzato che varia in base al percorso utilizzato per accedere al servizio.

Nota

Se aggiungi application.debug = True prima di eseguire l'applicazione, l'output di debug viene attivato in caso di problemi. È una buona prassi per lo sviluppo, ma è necessario rimuovere le istruzioni di debug dal codice di produzione in quanto l'output di debug può rivelare aspetti interni dell'applicazione.

Utilizzando application.py come nome di file e fornendo un oggetto application richiamabile (l'oggetto Flask, in questo caso), Elastic Beanstalk trova facilmente il codice dell'applicazione.

Esegui application.py con Python:

(virt) ~/eb-flask$ python application.py
 * Serving Flask app "application" (lazy loading)
 * Environment: production
   WARNING: Do not use the development server in a production environment.
   Use a production WSGI server instead.
 * Debug mode: on
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 313-155-123

Apri http://127.0.0.1:5000/ nel tuo browser Web. L'applicazione dovrebbe essere in esecuzione e visualizzare la pagina di indice:

Web browser displaying "Hello World!" message and a hint about RESTful web service usage.

Seleziona il log del server per visualizzare l'output dalla tua richiesta. Puoi arrestare il server Web e tornare al tuo ambiente virtuale premendo CTRL+C.

Se invece hai ricevuto l'output di debug, correggi gli errori e accertati che l'applicazione venga eseguita localmente prima di configurarla per Elastic Beanstalk.

Implementa il tuo sito con l'EB CLI

Hai aggiunto tutto ciò di cui hai bisogno per distribuire l'applicazione su Elastic Beanstalk. La directory del tuo progetto dovrebbe ora apparire così:

~/eb-flask/
|-- virt
|-- application.py
`-- requirements.txt

La cartella virt, tuttavia, non è necessaria affinché l'applicazione sia eseguita su Elastic Beanstalk. Quando si esegue la distribuzione, Elastic Beanstalk crea un nuovo ambiente virtuale sulle istanze server e installa le librerie elencate in requirements.txt. Per ridurre al minimo le dimensioni del pacchetto sorgente che carichi durante la distribuzione, aggiungi un file.ebignore che dica CLI all'EB di escludere la cartella. virt

Esempio ~/eb-flask/.ebignore
virt

Quindi, potrai creare l'ambiente applicativo e distribuire l'applicazione configurata con Elastic Beanstalk.

Creazione di un ambiente e distribuzione dell'applicazione Flask

  1. Inizializza il tuo CLI repository EB con il comando: eb init

    ~/eb-flask$ eb init -p python-3.7 flask-tutorial --region us-east-2
Application flask-tutorial has been created.

    Questo comando crea una nuova applicazione denominata flask-tutorial e configura il repository locale per creare ambienti con la versione della piattaforma Python 3.7 più recente.

  2. (opzionale) Esegui eb init nuovamente per configurare una coppia di chiavi predefinita in modo da poterti connettere all'EC2istanza che esegue l'applicazione con: SSH

    ~/eb-flask$ eb init
Do you want to set up SSH for your instances?
(y/n): y
Select a keypair.
1) my-keypair
2) [ Create new KeyPair ]

    Seleziona una coppia di chiavi se ne hai già una, oppure segui le istruzioni per creare una nuova. Se il prompt non è visualizzato o devi modificare le impostazioni in seguito, esegui eb init -i.

  3. Crea un ambiente e distribuisci l'applicazione nello stesso con eb create:

    ~/eb-flask$ eb create flask-env

Occorrono circa cinque minuti per creare l'ambiente e le seguenti risorse:

  • EC2istanza: una macchina virtuale Amazon Elastic Compute Cloud (AmazonEC2) configurata per eseguire app Web sulla piattaforma scelta.

    Ogni piattaforma esegue un insieme specifico di software, file di configurazione e script per supportare una versione della lingua, un framework, un container Web specifici o una determinata combinazione di essi. La maggior parte delle piattaforme utilizza Apache o NGINX come proxy inverso che si trova davanti all'app Web, inoltra le richieste, fornisce risorse statiche e genera log di accesso e di errore.

  • Gruppo di sicurezza dell'istanza: un gruppo EC2 di sicurezza Amazon configurato per consentire il traffico in entrata sulla porta 80. Questa risorsa consente al HTTP traffico proveniente dal sistema di bilanciamento del carico di raggiungere l'EC2istanza su cui è in esecuzione la tua app web. Per impostazione predefinita, il traffico non è consentito su altre porte.

  • Sistema di bilanciamento del carico: un sistema di bilanciamento del carico Elastic Load Balancing configurato per distribuire richieste alle istanze in esecuzione sull'applicazione. Un sistema di bilanciamento del carico inoltre elimina la necessità di esporre le proprie istanze direttamente in Internet.

  • Gruppo di sicurezza Load Balancer: un gruppo EC2 di sicurezza Amazon configurato per consentire il traffico in entrata sulla porta 80. Questa risorsa consente al HTTP traffico proveniente da Internet di raggiungere il sistema di bilanciamento del carico. Per impostazione predefinita, il traffico non è consentito su altre porte.

  • Gruppo Auto Scaling: un gruppo Auto Scaling configurato per sostituire un'istanza se viene terminata o diventa non disponibile.

  • Bucket Amazon S3: posizione di storage per il codice sorgente, i log e altri artefatti creati quando si utilizza Elastic Beanstalk.

  • CloudWatch Allarmi Amazon: due CloudWatch allarmi che monitorano il carico sulle istanze nel tuo ambiente e che vengono attivati se il carico è troppo alto o troppo basso. Quando viene attivato un allarme, il gruppo Auto Scaling aumenta o diminuisce di conseguenza.

  • AWS CloudFormation stack: Elastic AWS CloudFormation Beanstalk utilizza per avviare le risorse nell'ambiente e propagare le modifiche alla configurazione. Le risorse sono definite in un modello, visualizzabile nella console AWS CloudFormation.

  • Nome di dominio: un nome di dominio che indirizza alla tua app Web nel modulo subdomain.region.elasticbeanstalk.com.

    Sicurezza del dominio

    Per aumentare la sicurezza delle tue applicazioni Elastic Beanstalk, il dominio elasticbeanstalk.com è registrato nella Public Suffix List (). PSL

    Se hai bisogno di impostare cookie sensibili nel nome di dominio predefinito per le tue applicazioni Elastic Beanstalk, ti consigliamo di utilizzare i cookie __Host- con un prefisso per una maggiore sicurezza. Questa pratica difende il tuo dominio dai tentativi di falsificazione delle richieste tra siti (). CSRF Per ulteriori informazioni, consulta la pagina Impostazione cookie nella pagina Mozilla Developer Network.

Tutte queste risorse sono gestite da Elastic Beanstalk. Quando arresti l'ambiente, Elastic Beanstalk termina tutte le risorse che contiene.

Nota

Il bucket Amazon S3 creato da Elastic Beanstalk è condiviso tra gli ambienti e non viene eliminato quando l'ambiente viene terminato. Per ulteriori informazioni, consulta Utilizzo di Elastic Beanstalk con Amazon S3.

Al termine del processo di creazione dell'ambiente, apri il sito Web con eb open:

~/eb-flask$ eb open

Si aprirà una finestra del browser che utilizza il nome di dominio creato per l'applicazione. Dovresti visualizzare lo stesso sito Web Flask che hai creato e testato in locale.

Browser window displaying a Flask web application with a "Hello World!" message and usage hint.

Se non vedi l'applicazione in esecuzione, oppure viene visualizzato un messaggio di errore, consulta la sezione relativa alla risoluzione di problemi relativi alle distribuzioni per informazioni su come determinare la causa dell'errore.

Se vedi l'applicazione in esecuzione, significa che hai distribuito la tua prima applicazione Flask con Elastic Beanstalk.

Pulizia

Dopo aver usato Elastic Beanstalk, puoi terminare l'ambiente. Elastic Beanstalk AWS interrompe tutte le risorse associate all'ambiente, come istanze EC2 Amazon, istanze di database, sistemi di bilanciamento del carico, gruppi di sicurezza e allarmi.

Per terminare l'ambiente Elastic Beanstalk dalla console

  1. Apri la console Elastic Beanstalk e, nell'elenco Regioni, seleziona la tua. Regione AWS

  2. Nel pannello di navigazione selezionare Environments (Ambienti), quindi selezionare il nome dell'ambiente dall'elenco.

    Nota

    Se si dispone di molti ambienti, utilizzare la barra di ricerca per filtrare l'elenco degli ambienti.

  3. Seleziona Actions (Operazioni), quindi Terminate environment (Termina ambiente).

  4. Utilizza la finestra di dialogo su schermo per confermare la terminazione dell'ambiente.

Con Elastic Beanstalk puoi creare facilmente un nuovo ambiente per l'applicazione in qualsiasi momento.

Oppure, con l'EB: CLI

~/eb-flask$ eb terminate flask-env

Passaggi successivi

Per ulteriori informazioni su Flask, visita flask.pocoo.org.

Se vuoi provare un altro framework Web Python, consulta Distribuzione di un'applicazione Django in Elastic Beanstalk.