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à.
# Distribuzione di applicazioni Python con Elastic Beanstalk
Questo capitolo fornisce istruzioni per configurare e distribuire l'applicazione web Python su. AWS Elastic Beanstalk Elastic Beanstalk semplifica la distribuzione, la gestione e la scalabilità delle applicazioni Web Python utilizzando Amazon Web Services.
Puoi distribuire la tua applicazione in pochi minuti utilizzando l'Elastic Beanstalk Command Line Interface (EB CLI) o utilizzando la console Elastic Beanstalk. Dopo aver distribuito l'applicazione Elastic Beanstalk, è possibile continuare a utilizzare l'EB CLI per gestire l'applicazione e l'ambiente, oppure è possibile utilizzare la console Elastic Beanstalk o il. AWS CLI APIs
Segui i passaggi indicati nelle step-by-step istruzioni [QuickStart per Python](python-quickstart.md) per creare e distribuire un'applicazione web *Python Hello* World con l'EB CLI.
**Topics**
+ [QuickStart: distribuisci un'applicazione Python su Elastic Beanstalk](python-quickstart.md)
+ [Configurazione dell'ambiente di sviluppo Python per Elastic Beanstalk](python-development-environment.md)
+ [Utilizzo della piattaforma Python di Elastic Beanstalk](create-deploy-python-container.md)
+ [Implementazione di un'applicazione Flask in Elastic Beanstalk](create-deploy-python-flask.md)
+ [Distribuzione di un'applicazione Django in Elastic Beanstalk](create-deploy-python-django.md)
+ [Aggiungere un'istanza DB Amazon RDS al tuo ambiente Python Elastic Beanstalk](create-deploy-python-rds.md)
+ [Risorse e strumenti Python](create-deploy-python-tools-resources.md)
# QuickStart: distribuisci un'applicazione Python su Elastic Beanstalk
Questo QuickStart tutorial illustra il processo di creazione di un'applicazione Python e la sua distribuzione in un ambiente. AWS Elastic Beanstalk
**Non per uso in produzione**
Gli esempi sono solo a scopo dimostrativo. Non utilizzare applicazioni di esempio in produzione.
**Topics**
+ [Il tuo AWS account](#python-quickstart-aws-account)
+ [Prerequisiti](#python-quickstart-prereq)
+ [Fase 1: Creare un'applicazione Python](#python-quickstart-create-app)
+ [Passaggio 2: Esegui l'applicazione localmente](#python-quickstart-run-local)
+ [Passaggio 3: distribuisci la tua applicazione Python con l'EB CLI](#python-quickstart-deploy)
+ [Fase 4: Esegui l'applicazione su Elastic Beanstalk](#python-quickstart-run-eb-ap)
+ [Fase 5: rimozione](#go-tutorial-cleanup)
+ [AWS risorse per la tua applicazione](#python-quickstart-eb-resources)
+ [Fasi successive](#python-quickstart-next-steps)
+ [Esegui la distribuzione con la console Elastic Beanstalk](#python-quickstart-console)
## Il tuo AWS account
Se non sei già AWS cliente, devi creare un AWS account. La registrazione ti consente di accedere a Elastic Beanstalk AWS e ad altri servizi di cui hai bisogno.
Se hai già un AWS account, puoi passare a. [Prerequisiti](#python-quickstart-prereq)
### Crea un AWS account
#### Registrati per un Account AWS
Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno.
**Per iscriverti a un Account AWS**
1. Apri la [https://portal.aws.amazon.com/billing/registrazione.](https://portal.aws.amazon.com/billing/signup)
1. Segui le istruzioni online.
Nel corso della procedura di registrazione riceverai una telefonata o un messaggio di testo e ti verrà chiesto di inserire un codice di verifica attraverso la tastiera del telefono.
Quando ti iscrivi a un Account AWS, *Utente root dell'account AWS*viene creato un. L’utente root dispone dell’accesso a tutte le risorse e tutti i Servizi AWS nell’account. Come best practice di sicurezza, assegna l’accesso amministrativo a un utente e utilizza solo l’utente root per eseguire [attività che richiedono l’accesso di un utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. In qualsiasi momento, puoi visualizzare l'attività corrente del tuo account e gestirlo accedendo a [https://aws.amazon.com/](https://aws.amazon.com/)e scegliendo **Il mio account**.
#### Crea un utente con accesso amministrativo
Dopo esserti registrato Account AWS, proteggi Utente root dell'account AWS AWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane.
**Proteggi i tuoi Utente root dell'account AWS**
1. Accedi [Console di gestione AWS](https://console.aws.amazon.com/)come proprietario dell'account scegliendo **Utente root** e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password.
Per informazioni sull’accesso utilizzando un utente root, consulta la pagina [Accedere come utente root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) nella *Guida per l’utente di Accedi ad AWS *.
1. Abilita l’autenticazione a più fattori (MFA) per l’utente root.
Per istruzioni, consulta [Abilitare un dispositivo MFA virtuale per l'utente Account AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) nella Guida per l'*utente IAM*.
**Crea un utente con accesso amministrativo**
1. Abilita il Centro identità IAM.
Per istruzioni, consulta [Abilitazione del AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) nella *Guida per l’utente di AWS IAM Identity Center *.
1. Nel Centro identità IAM, assegna l’accesso amministrativo a un utente.
Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta [Configurare l'accesso utente con l'impostazione predefinita IAM Identity Center directory](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) nella *Guida per l'AWS IAM Identity Center utente*.
**Accesso come utente amministratore**
+ Per accedere come utente del Centro identità IAM, utilizza l’URL di accesso che è stato inviato al tuo indirizzo e-mail quando hai creato l’utente del Centro identità IAM.
Per informazioni sull'accesso utilizzando un utente IAM Identity Center, consulta [AWS Accedere al portale di accesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) nella *Guida per l'Accedi ad AWS utente*.
**Assegnazione dell’accesso ad altri utenti**
1. Nel Centro identità IAM, crea un set di autorizzazioni conforme alla best practice per l’applicazione di autorizzazioni con il privilegio minimo.
Segui le istruzioni riportate nella pagina [Creazione di un set di autorizzazioni](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) nella *Guida per l’utente di AWS IAM Identity Center *.
1. Assegna al gruppo prima gli utenti e poi l’accesso con autenticazione unica (Single Sign-On).
Per istruzioni, consulta [Aggiungere gruppi](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) nella *Guida per l’utente di AWS IAM Identity Center *.
## Prerequisiti
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 (\$1) 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](https://docs.microsoft.com/en-us/windows/wsl/install-win10) ottenere una versione integrata per Windows di Ubuntu e Bash.
### CLI EB
Questo tutorial utilizza l'interfaccia a riga di comando di Elastic Beanstalk (CLI EB). Per istruzioni dettagliate su come configurare e utilizzare la CLI EB, consulta [Installa EB CLI con lo script di configurazione (consigliato)](eb-cli3.md#eb-cli3-install) e [Configurazione dell'interfaccia a riga di comando EB](eb-cli3-configuration.md).
### Framework Python e Flask
Conferma di avere una versione di Python funzionante con `pip` installata eseguendo i seguenti comandi.
```
~$ python3 --version
Python 3.N.N
>~$ python3 -m pip --version
pip X.Y.Z from ... (python 3.N.N)
```
Se uno dei comandi precedenti restituisce «*Python was not found* «, esegui i seguenti comandi che use `python` invece di. `python3` La configurazione degli alias e dei collegamenti simbolici può variare in base al sistema operativo e alle singole personalizzazioni, pertanto il `python3` comando potrebbe non funzionare sul computer.
```
~$ python --version
Python 3.N.N
>~$ python -m pip --version
pip X.Y.Z from ... (python 3.N.N)
```
Se non hai Python installato sul tuo computer locale, puoi scaricarlo dalla pagina dei download di Python sul sito Web di [Python](https://www.python.org/downloads/). *Per un elenco delle versioni del linguaggio Python supportate da Elastic Beanstalk, [consulta Piattaforme Python supportate](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) nella guida Piattaforme.AWS Elastic Beanstalk * Il sito Web per i download di Python fornisce un collegamento alla *Python Developer's Guide*, dove troverai le istruzioni di installazione e configurazione.
**Nota**
Il `pip` pacchetto Python è incluso di default in Python 3.4 o versioni successive.
Se l'output indica che disponi di una versione supportata di Python, ma non lo è`pip`, consulta la pagina di [installazione](https://pip.pypa.io/en/stable/installation/) sul sito Web *pip.pypa.io*. Fornisce indicazioni per installare pip in un ambiente Python che non lo dispone.
Conferma se Flask è installato eseguendo il seguente comando:
```
~$ pip list | grep Flask
```
Se Flask non è installato, puoi installarlo con il seguente comando:
```
~$ pip install Flask
```
## Fase 1: Creare un'applicazione Python
Crea una directory di progetto.
```
~$ mkdir eb-python
~$ cd eb-python
```
Crea un esempio di «Hello Elastic Beanstalk\$1» Applicazione Python che distribuirai utilizzando Elastic Beanstalk.
Crea un file di testo denominato `application.py` nella directory appena creata con i seguenti contenuti.
**Example `~/eb-python/application.py`**
```
from flask import Flask
application = Flask(__name__)
@application.route('/')
def hello_elastic_beanstalk():
return 'Hello Elastic Beanstalk!'
```
Create un file di testo denominato `requirements.txt` con la riga seguente. Questo file contiene i `pip` pacchetti necessari per l'esecuzione dell'applicazione.
**Example `~/eb-python/requirements.txt`**
```
Flask
```
## Passaggio 2: Esegui l'applicazione localmente
Esegui il comando seguente per eseguire l'applicazione localmente.
```
~/eb-python$ export FLASK_APP=application.py && flask run --port 5000
```
Dovresti vedere un output simile al seguente
```
Serving Flask app 'application.py'
Debug mode: off
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
Running on http://127.0.0.1:5000
Press CTRL+C to quit
127.0.0.1 - - [01/Jan/1970 00:00:00] "GET / HTTP/1.1" 200 -
```
Accedi a `http://localhost:5000` nel tuo browser web. Il browser Web dovrebbe visualizzare «Hello Elastic Beanstalk\$1».
## Passaggio 3: distribuisci la tua applicazione Python con l'EB CLI
Esegui i seguenti comandi per creare un ambiente Elastic Beanstalk per questa applicazione.
**Per creare un ambiente e distribuire la tua applicazione Python**
1. Inizializza il repository della CLI EB con il comando **eb init**.
```
~/eb-python$ eb init -p python-3.9 python-tutorial --region us-east-2
```
Questo comando crea un'applicazione denominata `python-tutorial` e configura il repository locale per creare ambienti con la versione della piattaforma Python fornita.
1. (Facoltativo) Esegui nuovamente **eb init** per configurare una coppia di chiavi predefinite e connetterti all'istanza EC2 che esegue l'applicazione.
```
~/eb-python$ 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**.
1. Crea un ambiente e distribuisci in esso l'applicazione con **eb create**: Elastic Beanstalk crea automaticamente un file zip per l'applicazione e lo avvia sulla porta 5000.
```
~/eb-python$ eb create python-env
```
Elastic Beanstalk impiega circa cinque minuti per creare l'ambiente.
## Fase 4: Esegui l'applicazione su Elastic Beanstalk
Una volta completato il processo di creazione dell'ambiente, apri il sito Web con. **eb open**
```
~/eb-python$ eb open
```
Complimenti\$1 Hai distribuito un'applicazione Python con Elastic Beanstalk\$1 Si aprirà una finestra del browser che utilizza il nome di dominio creato per l'applicazione.
## Fase 5: rimozione
Puoi chiudere il tuo ambiente quando finisci di lavorare con l'applicazione. Elastic Beanstalk AWS interrompe tutte le risorse associate all'ambiente.
Per terminare l'ambiente Elastic Beanstalk con l'EB CLI, esegui il comando seguente.
```
~/eb-python$ eb terminate
```
## AWS risorse per la tua applicazione
Hai appena creato un'applicazione a istanza singola. Funge da semplice applicazione di esempio con una singola istanza EC2, quindi non richiede il bilanciamento del carico o la scalabilità automatica. Per le applicazioni a istanza singola Elastic Beanstalk crea le seguenti risorse: AWS
+ **Istanza EC2**: una macchina virtuale di Amazon EC2 configurata per eseguire applicazioni Web sulla piattaforma selezionata.
Ogni piattaforma esegue un insieme diverso di software, file di configurazione e script per supportare una versione della lingua, un framework, un container Web specifici o una determinata combinazione di tutti questi elementi. La maggior parte delle piattaforme utilizza Apache o nginx come proxy inverso che elabora il traffico web su cui viene eseguita l'app Web, inoltra le richieste all'app, fornisce asset statici e genera log degli accessi e di errore.
+ **Gruppo di sicurezza istanze**: un gruppo di sicurezza di Amazon EC2 configurato per abilitare il traffico in entrata sulla porta 80. Questa risorsa consente al traffico TTP proveniente dal load balancer di raggiungere l'istanza EC2 in esecuzione sull'app Web. Per impostazione predefinita, il traffico non è consentito su altre porte.
+ **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 vengono attivati se il carico è troppo alto o troppo basso. Quando viene attivato un allarme, il gruppo Auto Scaling aumenta o diminuisce di conseguenza.
+ **CloudFormation stack**: Elastic 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 CloudFormation](https://console.aws.amazon.com/cloudformation).
+ **Nome di dominio***: un nome di dominio che indirizza alla tua app Web nel modulo. *subdomain* *region*.elasticbeanstalk.com*.
Elastic Beanstalk gestisce tutte queste risorse. Quando arresti l'ambiente, Elastic Beanstalk termina tutte le risorse che contiene.
## Fasi successive
Quando disponi di un'applicazione in esecuzione in un ambiente, puoi distribuire una nuova versione dell'applicazione o un'applicazione diversa in qualsiasi momento. La distribuzione di una nuova versione dell'applicazione è molto veloce perché non richiede il provisioning o il riavvio delle istanze EC2. Puoi anche esplorare il tuo nuovo ambiente utilizzando la console Elastic Beanstalk. Per i passaggi dettagliati, consulta [Esplora il tuo ambiente](GettingStarted.md#GettingStarted.Explore) nel capitolo *Guida introduttiva* di questa guida.
**Prova altri tutorial**
Se desideri provare altri tutorial con diverse applicazioni di esempio, consulta i seguenti tutorial:
[Implementazione di un'applicazione Flask in Elastic Beanstalk](create-deploy-python-flask.md)
[Distribuzione di un'applicazione Django in Elastic Beanstalk](create-deploy-python-django.md)
Dopo aver distribuito una o due applicazioni di esempio e essere pronti per iniziare a sviluppare ed eseguire applicazioni Python localmente, vedi. [Configurazione dell'ambiente di sviluppo Python per Elastic Beanstalk](python-development-environment.md)
## Esegui la distribuzione con la console Elastic Beanstalk
Puoi anche utilizzare la console Elastic Beanstalk per avviare l'applicazione di esempio. Per i passaggi dettagliati, consulta [Creare un'applicazione di esempio](GettingStarted.md#GettingStarted.CreateApp) nel capitolo *Guida introduttiva* di questa guida.
# Configurazione dell'ambiente di sviluppo Python per Elastic Beanstalk
Questo argomento fornisce istruzioni per configurare un ambiente di sviluppo Python per testare l'applicazione localmente prima di distribuirla. AWS Elastic Beanstalk Fa inoltre riferimento a siti Web che forniscono istruzioni di installazione per strumenti utili.
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 (\$1) 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 è possibile [installare il sottosistema Windows per Linux per](https://docs.microsoft.com/en-us/windows/wsl/install-win10) ottenere una versione integrata per Windows di Ubuntu e Bash.
**Topics**
+ [Prerequisiti](#python-common-prereq)
+ [Uso di un ambiente virtuale](#python-common-setup-venv)
+ [Configurazione di un progetto Python per Elastic Beanstalk](#python-common-configuring)
## Prerequisiti
L'elenco seguente fornisce i prerequisiti comuni per lavorare con Elastic Beanstalk e le tue applicazioni Python:
+ **Linguaggio Python**: installa la versione del linguaggio Python inclusa nella versione della piattaforma Elastic Beanstalk Python scelta. *Per un elenco delle nostre versioni del linguaggio Python supportate, consulta Piattaforme [Python supportate nella guida Piattaforme](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python).AWS Elastic Beanstalk * Se non hai già configurato Python sulla tua macchina di sviluppo, consulta la pagina dei [download di Python sul sito Web di Python](https://www.python.org/downloads/).
+ **`pip`utility — L'`pip`utilità** è il programma di installazione dei pacchetti di Python. Installa ed elenca le dipendenze per il tuo progetto, in modo che Elastic Beanstalk sappia come configurare l'ambiente dell'applicazione. *Per ulteriori informazioni in merito`pip`, consulta la pagina [pip sul sito Web pip.pypa.io.](https://pip.pypa.io/en/stable/)*
+ **(Facoltativo) Elastic Beanstalk Command Line Interface (EB CLI): l'EB CLI** [può impacchettare l'applicazione](eb-cli3.md) con i file di distribuzione necessari. Può anche creare un ambiente Elastic Beanstalk e distribuirvi l'applicazione. Puoi anche effettuare distribuzioni tramite la console Elastic Beanstalk, quindi l'EB CLI non è strettamente necessaria.
+ **Un'`SSH`installazione funzionante**: puoi connetterti alle istanze in esecuzione con il protocollo SSH per esaminare o eseguire il debug di una distribuzione.
+ **`virtualenv`pacchetto**: questo `virtualenv` strumento crea un ambiente di sviluppo e test per l'applicazione. Elastic Beanstalk può replicare questo ambiente senza installare pacchetti aggiuntivi non richiesti dall'applicazione. [Per ulteriori informazioni, consulta il sito web virtualenv.](https://virtualenv.pypa.io/en/latest/) Dopo aver installato Python, puoi installare il `virtualenv` pacchetto con il seguente comando:
```
$ pip install virtualenv
```
## Uso di un ambiente virtuale
Dopo aver installato i prerequisiti, imposta un ambiente virtuale con `virtualenv` per l'installazione delle dipendenze dell'applicazione. Utilizzando un ambiente virtuale, è possibile distinguere esattamente quali pacchetti sono necessari all'applicazione in modo che i pacchetti richiesti vengano installati sulle EC2 istanze che eseguono l'applicazione.
**Per configurare un ambiente virtuale**
1. Apri una finestra a riga di comando e digita:
```
$ virtualenv /tmp/eb_python_app
```
*eb\$1python\$1app*Sostituitelo con un nome che abbia senso per l'applicazione (usare il nome dell'applicazione è una buona idea). Il comando `virtualenv` crea un ambiente virtuale per l'utente nella directory specificata e stampa i risultati delle operazioni:
```
Running virtualenv with interpreter /usr/bin/python
New python executable in /tmp/eb_python_app/bin/python3.12
Also creating executable in /tmp/eb_python_app/bin/python
Installing setuptools, pip...done.
```
1. Quando l'ambiente virtuale è pronto, avvialo eseguendo lo script `activate` che si trova nella directory `bin` dell'ambiente. Ad esempio, per avviare l'ambiente **eb\$1python\$1app** creato nella fase precedente, digita:
```
$ source /tmp/eb_python_app/bin/activate
```
L'ambiente virtuale stamperà il proprio nome, (ad esempio: `(eb_python_app)`) all'inizio di ogni prompt dei comandi, per ricordarti che sei in un ambiente Python virtuale.
1. Per interrompere l'utilizzo dell'ambiente virtuale e tornare all'interprete Python predefinito del sistema con tutte le relative librerie installate, eseguire il comando `deactivate`.
```
(eb_python_app) $ deactivate
```
**Nota**
Una volta creato, è possibile riavviare l'ambiente virtuale in qualsiasi momento eseguendo di nuovo lo script `activate`.
## Configurazione di un progetto Python per Elastic Beanstalk
È possibile utilizzare l'interfaccia a riga di comando di Elastic Beanstalk (CLI EB) per preparare le applicazioni Python alla distribuzione con Elastic Beanstalk.
**Per configurare un'applicazione Python per la distribuzione con Elastic Beanstalk**
1. Dall'interno del tuo [ambiente virtuale](#python-common-setup-venv), torna alla parte superiore della struttura ad albero della directory del progetto (`python_eb_app`) e digita:
```
pip freeze >requirements.txt
```
Questo comando copia i nomi e le versioni dei pacchetti installati nell'ambiente virtuale su `requirements.txt`. Ad esempio, se il pacchetto *PyYAML* versione *3.11* è installato nell'ambiente virtuale, il file conterrà la riga:
```
PyYAML==3.11
```
Ciò consente a Elastic Beanstalk di replicare l'ambiente Python dell'applicazione utilizzando gli stessi pacchetti e le stesse versioni che hai utilizzato per sviluppare e testare l'applicazione.
1. Configura il repository della CLI EB con il comando **eb init**. Segui le istruzioni per scegliere regione, piattaforma e altre opzioni.
Per impostazione predefinita, Elastic Beanstalk cerca un file denominato `application.py` per avviare l'applicazione. Se questo non esiste nel progetto Python creato, sono necessari alcuni aggiustamenti dell'ambiente della tua applicazione. Dovrai anche impostare le variabili di ambiente per consentire il caricamento dei moduli della tua applicazione. Per ulteriori informazioni, consultare [Utilizzo della piattaforma Python di Elastic Beanstalk](create-deploy-python-container.md).
# Utilizzo della piattaforma Python di Elastic Beanstalk
Questo argomento descrive come configurare, creare ed eseguire le applicazioni Python su Elastic Beanstalk.
AWS Elastic Beanstalk supporta una serie di rami di piattaforma per diverse versioni del linguaggio di programmazione Python. Vedi [Python](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) nel documento *AWS Elastic Beanstalk Piattaforme* per un elenco completo.
Le applicazioni web Python possono essere eseguite dietro un server proxy con WSGI. Elastic [Beanstalk](https://gunicorn.org/) fornisce Gunicorn come server WSGI predefinito.
È possibile aggiungere un `Procfile` al bundle di origine per specificare e configurare il server WSGI per l'applicazione. Per informazioni dettagliate, vedi [Configurazione del server WSGI con un profilo su Elastic Beanstalk](python-configuration-procfile.md).
È possibile utilizzare i file `Pipfile.lock` e `Pipfile` creati da Pipenv per specificare le dipendenze dei pacchetti Python e altri requisiti. Per informazioni dettagliate sulla definizione delle dipendenze, consulta [Specificazione delle dipendenze utilizzando un file dei requisiti su Elastic Beanstalk](python-configuration-requirements.md).
Elastic [Beanstalk offre](command-options.md) opzioni di configurazione che puoi utilizzare per personalizzare il software che viene eseguito EC2 sulle istanze nell'ambiente Elastic Beanstalk. Puoi configurare le variabili di ambiente necessarie per la tua applicazione, accedere alla rotazione dei log su Amazon S3 e mappare le cartelle nel codice sorgente dell'applicazione che contengono i file statici ai percorsi serviti dal server proxy.
Sono disponibili opzioni di configurazione specifiche della piattaforma nella console Elastic Beanstalk per la [modifica della configurazione di un ambiente in esecuzione](environment-configuration-methods-after.md). Per conservare la configurazione dell'ambiente una volta terminata, puoi utilizzare [configurazioni salvate](environment-configuration-savedconfig.md) per salvare le impostazioni e applicarle successivamente a un altro ambiente.
Per salvare le impostazioni nel codice sorgente, puoi includere i [file di configurazione](ebextensions.md). Le impostazioni nei file di configurazione vengono applicate ogni volta che crei un ambiente o distribuisci l'applicazione. Puoi inoltre utilizzare i file di configurazione per installare pacchetti, eseguire script o altre operazioni di personalizzazione delle istanze durante le distribuzioni.
Le impostazioni applicate nella console Elastic Beanstalk sostituiscono le stesse impostazioni nei file di configurazione, se esistenti. Ciò ti consente di disporre di impostazioni predefinite nei file di configurazione, sostituibili con impostazioni specifiche per l'ambiente nella console. Per ulteriori informazioni sulla precedenza e altri metodi di modifica delle impostazioni, consulta [Opzioni di configurazione](command-options.md).
Per i pacchetti Python disponibili in `pip`, puoi includere un file di requisiti nella radice del codice sorgente dell'applicazione. Elastic Beanstalk installa tutti i pacchetti delle dipendenze specificati in un file dei requisiti durante la distribuzione. Per informazioni dettagliate, vedi [Specificazione delle dipendenze utilizzando un file dei requisiti su Elastic Beanstalk](python-configuration-requirements.md).
Per informazioni dettagliate sui vari modi in cui è possibile estendere una piattaforma Elastic Beanstalk basata su Linux, consulta [Estensione delle piattaforme Elastic Beanstalk Linux](platforms-linux-extend.md).
## Configurazione dell'ambiente Python
Le impostazioni della piattaforma Python ti consentono di ottimizzare il comportamento delle tue istanze Amazon. EC2 Puoi modificare la configurazione dell'istanza Amazon dell'ambiente Elastic Beanstalk utilizzando EC2 la console Elastic Beanstalk.
Usa la console Elastic Beanstalk per configurare AWS X-Ray le impostazioni dei processi Python, abilitare, abilitare la rotazione dei log su Amazon S3 e configurare le variabili che l'applicazione può leggere dall'ambiente.
**Per configurare l'ambiente Python nella console Elastic Beanstalk**
1. Apri la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) e, **nell'elenco Regioni, seleziona la tua**. Regione AWS
1. Nel pannello di navigazione selezionare **Environments** (Ambienti), quindi selezionare il nome dell'ambiente dall'elenco.
1. Nel riquadro di navigazione, seleziona **Configuration** (Configurazione).
1. Nella categoria di configurazione **Monitoring** (Monitoraggio), scegli **Edit** (Modifica).
### Impostazioni Python
+ **Proxy server (Server proxy)**: il server proxy da utilizzare nelle istanze dell'ambiente. Per impostazione predefinita, viene utilizzato nginx.
+ **WSGI Path (Percorso WSGI)**: nome del file principale dell'applicazione o il relativo percorso. Ad esempio, `application.py` o `django/wsgi.py`.
+ **NumProcesses**— Il numero di processi da eseguire su ciascuna istanza dell'applicazione.
+ **NumThreads**— Il numero di thread da eseguire in ogni processo.
### AWS X-Ray impostazioni
+ Demone **X-Ray: esegue il demone** per elaborare i AWS X-Ray dati di traccia da. [SDK AWS X-Ray per Python](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html)
### Opzioni di log
La sezione Log Options (Opzioni di log) ha due impostazioni:
+ **Instance profile (Profilo dell'istanza)**: specifica il profilo dell'istanza che dispone dell'autorizzazione ad accedere al bucket Amazon S3 associato all'applicazione.
+ **Abilita la rotazione dei file di registro su Amazon S3**: specifica se i file di log per le EC2 istanze Amazon dell'applicazione vengono copiati nel bucket Amazon S3 associato all'applicazione.
### File statici
Per migliorare le prestazioni, la sezione **Static files** (File statici) consente di configurare il server proxy affinché fornisca file statici (ad esempio, HTML o immagini) da un set di directory all'interno dell'applicazione Web. Per ogni directory, è possibile impostare il percorso virtuale per la mappatura delle directory. Quando il server proxy riceve una richiesta da un file nel percorso specificato, questo serve il file direttamente anziché instradare la richiesta all'applicazione.
Per informazioni dettagliate sulla configurazione di file statici utilizzando file di configurazione o la console Elastic Beanstalk, consulta [Fornire i file statici](environment-cfg-staticfiles.md).
Per impostazione predefinita, il server proxy in un ambiente Python serve qualsiasi file in una cartella denominata `static` nel percorso `/static`. Ad esempio, se il codice sorgente dell'applicazione contiene un file con nome `logo.png` in una cartella chiamata `static`, il server proxy lo servirà agli utenti su `subdomain.elasticbeanstalk.com/static/logo.png`. È possibile configurare mappature aggiuntive come indicato in questa sezione.
### Proprietà dell'ambiente
Puoi utilizzare le proprietà dell'ambiente per fornire informazioni alla tua applicazione e configurare variabili di ambiente. Ad esempio, puoi creare una proprietà di ambiente denominata `CONNECTION_STRING` che specifica una stringa di connessione che la tua applicazione può utilizzare per connettersi a un database.
All'interno dell'ambiente Python in esecuzione in Elastic Beanstalk, questi valori sono accessibili tramite il dizionario `os.environ` di Python. [Per ulteriori informazioni, consulta http://docs.python. org/library/os.html](http://docs.python.org/library/os.html).
Puoi utilizzare un codice simile al seguente per accedere alle chiavi e ai parametri:
```
import os
endpoint = os.environ['API_ENDPOINT']
```
Le proprietà dell'ambiente sono inoltre in grado di fornire informazioni a un framework. Ad esempio, è possibile creare una proprietà denominata `DJANGO_SETTINGS_MODULE` per configurare Django in modo che utilizzi un modulo specifico di impostazioni. A seconda dell'ambiente, il valore potrebbe essere `development.settings`, `production.settings` e così via.
Per ulteriori informazioni, consultare [Variabili di ambiente e altre impostazioni software](environments-cfg-softwaresettings.md).
## Spazio dei nomi di configurazione di Python
È possibile utilizzare un [file di configurazione](ebextensions.md) per impostare le opzioni di configurazione ed eseguire alte attività di configurazione delle istanze durante le distribuzioni. Le opzioni di configurazione possono essere [specifiche della piattaforma](command-options-specific.md) o essere applicate a [tutte le piattaforme](command-options-general.md) del servizio Elastic Beanstalk nel suo complesso. *Le opzioni di configurazione sono organizzate in namespace.*
La piattaforma Python definisce le opzioni negli spazi dei nomi `aws:elasticbeanstalk:environment:proxy`, `aws:elasticbeanstalk:environment:proxy:staticfiles` e `aws:elasticbeanstalk:container:python`.
Il seguente file di configurazione di esempio specifica le impostazioni delle opzioni di configurazione per creare una proprietà di ambiente denominata `DJANGO_SETTINGS_MODULE`, scegliere il server proxy Apache, specificare due opzioni di file statici che mappano una directory denominata `statichtml` sul percorso `/html` e una directory denominata `staticimages` sul percorso `/images` e specificare le impostazioni aggiuntive nello spazio dei nomi `[aws:elasticbeanstalk:container:python](command-options-specific.md#command-options-python)`. Questo spazio dei nomi contiene le opzioni che consentono di specificare il percorso dello script WSGI nel tuo codice sorgente e il numero di thread e processi in esecuzione in WSGI.
```
option_settings:
aws:elasticbeanstalk:application:environment:
DJANGO_SETTINGS_MODULE: production.settings
aws:elasticbeanstalk:environment:proxy:
ProxyServer: apache
aws:elasticbeanstalk:environment:proxy:staticfiles:
/html: statichtml
/images: staticimages
aws:elasticbeanstalk:container:python:
WSGIPath: ebdjango.wsgi:application
NumProcesses: 3
NumThreads: 20
```
**Note**
Se stai utilizzando una versione di piattaforma Python in AMI Amazon Linux (precedente ad Amazon Linux 2), sostituisci il valore `WSGIPath` con `ebdjango/wsgi.py`. Il valore nell'esempio funziona con il server Gunicorn WSGI, che non è supportato nelle versioni della piattaforma AMI Amazon Linux.
Inoltre, queste versioni della piattaforma precedenti utilizzano uno spazio dei nomi diverso per la configurazione dei file statici, ovvero `aws:elasticbeanstalk:container:python:staticfiles`. Ha gli stessi nomi di opzioni e semantica dello spazio dei nomi dei file statici standard.
I file di configurazione, supportano inoltre diverse chiavi per [modificare ulteriormente il software delle istanze del tuo ambiente](customize-containers-ec2.md). Questo esempio utilizza la chiave [pacchetti](customize-containers-ec2.md#linux-packages) per installare Memcached con `yum` e i [comandi dei container](customize-containers-ec2.md#linux-container-commands) per eseguire comandi che consentono di configurare il server durante la distribuzione:
```
packages:
yum:
libmemcached-devel: '0.31'
container_commands:
collectstatic:
command: "django-admin.py collectstatic --noinput"
01syncdb:
command: "django-admin.py syncdb --noinput"
leader_only: true
02migrate:
command: "django-admin.py migrate"
leader_only: true
03wsgipass:
command: 'echo "WSGIPassAuthorization On" >> ../wsgi.conf'
99customize:
command: "scripts/customize.sh"
```
In Elastic Beanstalk sono disponibili varie opzioni di configurazione per la personalizzazione dell'ambiente. Oltre ai file di configurazione, puoi impostare le opzioni di configurazione tramite la console, le configurazioni salvate, la CLI EB o AWS CLI. Per ulteriori informazioni, consulta [Opzioni di configurazione](command-options.md).
## L'`python3`eseguibile
La versione dell'`python3`eseguibile disponibile nelle EC2 istanze negli ambienti Elastic Beanstalk Python non corrisponderà sempre alla stessa versione di Python utilizzata dalla piattaforma. Ad esempio, sulla piattaforma Python 3.12 AL2 023, punta `/usr/bin/python3` a Python 3.9. Questo perché Python 3.9 è il sistema *Python* su 023. AL2 Per ulteriori informazioni, consulta [Python in AL2 023 nella Guida](https://docs.aws.amazon.com/linux/al2023/ug/python.html) per l'utente di *Amazon Linux 2023*. È possibile accedere a un eseguibile corrispondente alla versione di Python utilizzata dalla piattaforma in una posizione con versione (ad esempio`/usr/bin/python3.12`) o nella `bin` directory dell'ambiente virtuale dell'applicazione (ad esempio). `/var/app/venv/staging-LQM1lest/bin/python3` La piattaforma utilizza l'eseguibile Python corretto che corrisponde al ramo della piattaforma.
# Configurazione del server WSGI con un profilo su Elastic Beanstalk
È possibile aggiungere un [`Procfile`](platforms-linux-extend.build-proc.md#platforms-linux-extend.proc) al bundle di origine per specificare e configurare il server WSGI per l'applicazione. È possibile specificare comandi di avvio ed esecuzione personalizzati in. `Procfile`
Quando utilizzi un `Procfile`, vengono sovrascritte le opzioni dello spazio dei nomi `aws:elasticbeanstalk:container:python` impostate utilizzando i file di configurazione.
Nell'esempio seguente viene utilizzato un `Procfile` per specificare uWSGI come server e configurarlo.
**Example Procfile**
```
web: uwsgi --http :8000 --wsgi-file application.py --master --processes 4 --threads 2
```
Nell'esempio seguente viene utilizzato un `Procfile` per configurare Gunicorn, il server WSGI predefinito.
**Example Procfile**
```
web: gunicorn --bind :8000 --workers 3 --threads 2 project.wsgi:application
```
**Note**
Se configuri un server WSGI diverso da Gunicorn, assicurati di specificarlo anche come dipendenza dell'applicazione, in modo che venga installato nelle istanze dell'ambiente. Per informazioni dettagliate sulla specifica delle dipendenze, consulta [Specificazione delle dipendenze utilizzando un file dei requisiti su Elastic Beanstalk](python-configuration-requirements.md).
La porta predefinita per il server WSGI è 8000. Se specifichi un numero di porta diverso nel comando `Procfile`, imposta anche la [proprietà `PORT` dell'ambiente](environments-cfg-softwaresettings.md) su questo numero di porta.
# Specificazione delle dipendenze utilizzando un file dei requisiti su Elastic Beanstalk
Questo argomento descrive come configurare l'applicazione per installare altri pacchetti Python richiesti. Un'applicazione Python tipica dispone di dipendenze da altri pacchetti Python di terze parti. Con la piattaforma Elastic Beanstalk Python, hai diversi modi per specificare i pacchetti Python da cui dipende la tua applicazione.
## Uso di `pip` e `requirements.txt`
Lo strumento standard per l'installazione di pacchetti Python è `pip`. Dispone di una funzionalità che consente di specificare tutti i pacchetti di cui hai bisogno (nonché le loro versioni) in un singolo file di requisiti. Per ulteriori informazioni sul file di requisiti, consulta [Formato del file di requisiti](https://pip.pypa.io/en/latest/reference/requirements-file-format/#requirements-file-format) sul sito Web della documentazione pip.
Crea un file denominato `requirements.txt` e inseriscilo nella directory di livello superiore del tuo bundle di origine. Di seguito è riportato un file `requirements.txt` di esempio per Django.
```
Django==2.2
mysqlclient==2.0.3
```
Nel tuo ambiente di sviluppo, puoi utilizzare il comando `pip freeze` per generare il tuo file di requisiti.
```
~/my-app$ pip freeze > requirements.txt
```
Per verificare che il tuo file di requisiti contenga solo i pacchetti che sono effettivamente utilizzati dall'applicazione, usa un [ambiente virtuale](python-development-environment.md#python-common-setup-venv) che contenga solo quei pacchetti installati. Al di fuori di un ambiente virtuale, l'output di `pip freeze` includerà tutti i pacchetti `pip` installati sul computer di sviluppo, inclusi quelli forniti con il sistema operativo.
**Nota**
Nelle versioni della piattaforma Python in AMI Amazon Linux, Elastic Beanstalk non supporta Pipenv o Pipfiles a livello nativo. Se utilizzi Pipenv per gestire le dipendenze dell'applicazione, esegui il comando seguente per generare un file `requirements.txt`.
```
~/my-app$ pipenv lock -r > requirements.txt
```
Per ulteriori informazioni, consulta [Generating a requirements.txt](https://pipenv.readthedocs.io/en/latest/advanced/#generating-a-requirements-txt) nella documentazione di Pipenv.
## Uso di Pipenv e `Pipfile`
Pipenv è uno strumento di creazione pacchetti Python moderno. Combina l'installazione del pacchetto con la creazione e la gestione di un file delle dipendenze e di un virtualenv per l'applicazione. Per ulteriori informazioni, consulta [Pipenv: Python Dev Workflow for Humans](https://pipenv.readthedocs.io/en/latest/).
Pipenv mantiene due file:
+ `Pipfile`: questo file contiene vari tipi di dipendenze e requisiti.
+ `Pipfile.lock`: questo file contiene uno snapshot della versione che abilita le build deterministiche.
Puoi crearli nell'ambiente di sviluppo e includerli nella directory di primo livello del bundle di origine che implementi in Elastic Beanstalk. Per ulteriori informazioni su questi due file, consulta [Esempio di Pipfile e PipFile.lock](https://pipenv.pypa.io/en/latest/basics/#).
Nell'esempio seguente viene utilizzato Pipenv per installare Django e il framework REST Django. Questi comandi creano i file `Pipfile` e `Pipfile.lock`.
```
~/my-app$ pipenv install django
~/my-app$ pipenv install djangorestframework
```
## Priorità
Se includi più di un file dei requisiti tra quelli descritti qui, Elastic Beanstalk ne utilizzerà uno solo. L'elenco seguente mostra la precedenza, in ordine decrescente.
1. `requirements.txt`
1. `Pipfile.lock`
1. `Pipfile`
**Nota**
A partire dalla versione della piattaforma Amazon Linux 2 del 7 marzo 2023, se fornisci più di uno di questi file, Elastic Beanstalk emetterà un messaggio sulla console indicando quale dei file di dipendenza è stato utilizzato durante una implementazione.
La seguente procedura descrive la logica seguita da Elastic Beanstalk per installare le dipendenze durante l'implementazione di un'istanza.
+ Se è presente un file `requirements.txt`, usiamo il comando `pip install -r requirements.txt`.
+ A partire dalla versione della piattaforma Amazon Linux 2 del 7 marzo 2023, se non è presente alcun file `requirements.txt` ma ce n'è uno `Pipfile.lock`, utilizziamo il comando `pipenv sync`. Prima di quella versione, usavamo `pipenv install --ignore-pipfile`.
+ Se non c'è né un file `requirements.txt` né un `Pipfile.lock`, ma è presente un `Pipfile`, usiamo il comando `pipenv install --skip-lock`.
+ Se non viene trovato nessuno dei tre file dei requisiti, non installiamo alcuna dipendenza dall'applicazione.
# 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:
+ [Configurazione di un ambiente virtuale Python con Flask](#python-flask-setup-venv)
+ [Creazione di un'applicazione Flask](#python-flask-create-app)
+ [Distribuzione del sito con la CLI EB](#python-flask-deploy)
+ [Pulizia](#python-flask-tutorial-cleanup)
## 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 [Scopri come iniziare a usare Elastic Beanstalk](GettingStarted.md) 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 (\$1) 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](https://docs.microsoft.com/en-us/windows/wsl/install-win10) ottenere una versione integrata con Windows di Ubuntu e Bash.
In questo tutorial utilizziamo Python 3.11 e la corrispondente versione della piattaforma Elastic Beanstalk. Installa Python seguendo la procedura descritta in [Configurazione dell'ambiente di sviluppo Python per Elastic Beanstalk](python-development-environment.md).
Il framework [Flask](http://flask.pocoo.org/) verrà installato nell'ambito di questo tutorial.
Questo tutorial utilizza anche l'interfaccia a riga di comando di Elastic Beanstalk (CLI EB). Per istruzioni dettagliate su come configurare e utilizzare la CLI EB, consulta [Installa EB CLI con lo script di configurazione (consigliato)](eb-cli3.md#eb-cli3-install) e [Configurazione dell'interfaccia a riga di comando EB](eb-cli3-configuration.md).
## 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
```
1. 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.
1. Installa Flask con `pip install`:
```
(virt)~/eb-flask$ pip install flask==3.0.3
```
1. Visualizza le librerie installate con `pip freeze`:
```
(virt)~/eb-flask$ pip freeze
blinker==1.8.2
click==8.1.7
Flask==3.0.3
importlib_metadata==8.5.0
itsdangerous==2.2.0
Jinja2==3.1.4
MarkupSafe==2.1.5
Werkzeug==3.0.4
zipp==3.20.2
```
Questo comando elenca tutti i pacchetti installati nell'ambiente virtuale. Poiché ti trovi in un ambiente virtuale, i pacchetti installati a livello globale come la CLI EB non vengono visualizzati.
1. 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](python-configuration-requirements.md).
## Creazione di un'applicazione Flask
Successivamente, crea un'applicazione che distribuirai utilizzando Elastic Beanstalk. Creeremo un servizio web «Hello World». RESTful
In questa directory, crea un nuovo file di testo denominato `application.py` con il seguente contenuto:
**Example `~/eb-flask/application.py`**
```
from flask import Flask
# print a nice greeting.
def say_hello(username = "World"):
return 'Hello %s!
\n' % username
# some bits of text for the page.
header_text = '''
\n EB Flask Test \n'''
instructions = '''
Hint: This is a RESTful web service! Append a username
to the URL (for example: /Thelonious) to say hello to
someone specific.
\n'''
home_link = 'Back
\n'
footer_text = '\n'
# 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('/', '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.\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/eb_flask_test_local.png)
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\$1C**.
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.
## Distribuzione del sito con la CLI EB
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 bundle di origine caricato durante la distribuzione, aggiungi un file [.ebignore](eb-cli3-configuration.md#eb-cli3-ebignore), che indica alla CLI EB di escludere la cartella `virt`.
**Example \$1/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 repository della CLI EB con il comando **eb init**:
```
~/eb-flask$ eb init -p python-3.11 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 l'ultima versione della piattaforma Python 3.11.
1. (opzionale) Esegui **eb init** nuovamente per configurare una coppia di chiavi predefinita in modo da poterti connettere all' EC2 istanza 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**.
1. 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:
+ **EC2 istanza**: una macchina virtuale Amazon Elastic Compute Cloud (Amazon EC2) 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 su cui viene eseguita l'app Web, inoltra le richieste all'app, fornisce asset statici e genera log degli accessi 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 traffico HTTP proveniente dal sistema di bilanciamento del carico di raggiungere l' EC2 istanza 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 HTTP consente al 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.
+ **CloudFormation stack**: Elastic 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 CloudFormation](https://console.aws.amazon.com/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).](https://publicsuffix.org/)
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](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) 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](AWSHowTo.S3.md).
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.\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/eb_flask_deployed.png)
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](troubleshooting.md#troubleshooting-deployments) 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 finito di utilizzare il codice demo, puoi chiudere il tuo ambiente. [Elastic Beanstalk elimina tutte le risorse AWS correlate, [come istanze EC2 Amazon](using-features.managing.ec2.md), [istanze di database, sistemi di bilanciamento del carico, gruppi](using-features.managing.db.md) di sicurezza e [allarmi](using-features.managing.elb.md).](using-features.alarms.md#using-features.alarms.title)
La rimozione delle risorse non elimina l'applicazione Elastic Beanstalk, quindi puoi creare nuovi ambienti per la tua applicazione in qualsiasi momento.
**Per terminare l'ambiente Elastic Beanstalk dalla console**
1. Apri la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) e, **nell'elenco Regioni, seleziona la tua**. Regione AWS
1. Nel pannello di navigazione selezionare **Environments** (Ambienti), quindi selezionare il nome dell'ambiente dall'elenco.
1. Seleziona **Actions** (Operazioni), quindi **Terminate environment** (Termina ambiente).
1. Utilizza la finestra di dialogo su schermo per confermare la terminazione dell'ambiente.
In alternativa, con la CLI EB:
```
~/eb-flask$ eb terminate flask-env
```
## Fasi successive
Per ulteriori informazioni su Flask, visita [flask.pocoo.org](http://flask.pocoo.org/).
Se vuoi provare un altro framework Web Python, consulta [Distribuzione di un'applicazione Django in Elastic Beanstalk](create-deploy-python-django.md).
# Distribuzione di un'applicazione Django in Elastic Beanstalk
In questo tutorial viene descritta la distribuzione di un sito Web [Django](https://www.djangoproject.com/) predefinito e autogenerato in un ambiente AWS Elastic Beanstalk in cui è in esecuzione Python. Questo tutorial illustra come ospitare un'app Web Python nel cloud utilizzando un ambiente Elastic Beanstalk.
In questo tutorial, verranno eseguite le operazioni seguenti:
+ [Configurazione di un ambiente virtuale Python e installazione di Django](#python-django-setup-venv)
+ [Creazione di un progetto Django](#python-django-create-app)
+ [Configurazione dell'applicazione Django per Elastic Beanstalk](#python-django-configure-for-eb)
+ [Distribuzione del sito con la CLI EB](#python-django-deploy)
+ [Aggiornamento di un'applicazione](#python-django-update-app)
+ [Eliminazione](#python-django-stopping)
## Prerequisiti
Per seguire questo tutorial, è necessario aver prima installato tutti i [prerequisiti comuni](python-development-environment.md) per Python, inclusi i seguenti pacchetti:
+ Python 3.7 o versioni successive
+ `pip`
+ `virtualenv`
+ `awsebcli`
Il framework [Django](https://www.djangoproject.com/) viene installato nell'ambito di questo tutorial.
**Nota**
La creazione di ambienti con CLI EB richiede un [ruolo del servizio](concepts-roles-service.md). Puoi creare un ruolo di servizio tramite la creazione di un ambiente nella console Elastic Beanstalk. Se non disponi di un ruolo del servizio, CLI EB tenta di crearne uno durante l'esecuzione di `eb create`.
## Configurazione di un ambiente virtuale Python e installazione di Django
Crea un ambiente virtuale con `virtualenv` e utilizzalo per installare Django e le relative dipendenze. Utilizzando un ambiente virtuale, puoi sapere esattamente di quali pacchetti ha bisogno la tua applicazione, in modo che i pacchetti richiesti vengano installati sulle EC2 istanze Amazon su cui è in esecuzione l'applicazione.
La procedura seguente illustra i comandi da immettere per i sistemi basati su Unix e Windows, mostrati su schede separate.
**Per configurare un ambiente virtuale**
1. Crea un ambiente virtuale denominato `eb-virt`.
------
#### [ Unix-based systems ]
```
~$ virtualenv ~/eb-virt
```
------
#### [ Windows ]
```
C:\> virtualenv %HOMEPATH%\eb-virt
```
------
1. Attiva l'ambiente virtuale.
------
#### [ Unix-based systems ]
```
~$ source ~/eb-virt/bin/activate
(eb-virt) ~$
```
------
#### [ Windows ]
```
C:\>%HOMEPATH%\eb-virt\Scripts\activate
(eb-virt) C:\>
```
------
Visualizzerai `(eb-virt)` anteposto al prompt dei comandi, a indicare che sei in un ambiente virtuale.
**Nota**
Il resto di queste istruzioni mostra il prompt dei comandi di Linux nella directory principale `~$`. Su Windows questo è`C:\Users\USERNAME>`, *USERNAME* dov'è il tuo nome di accesso a Windows.
1. Utilizza `pip` per installare Django.
```
(eb-virt)~$ pip install django==2.2
```
**Nota**
La versione Django che installi deve essere compatibile con la versione Python della configurazione Elastic Beanstalk Python scelta per distribuire l'applicazione. Per informazioni sulla distribuzione, consultare [Distribuzione del sito con la CLI EB](#python-django-deploy) in questo argomento.
Per ulteriori informazioni sulle versioni correnti della piattaforma Python, consulta [Python](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) nel documento *Piattaforme AWS Elastic Beanstalk *.
Per la compatibilità delle versioni Django con Python, consulta la domanda relativa a [quale versione di Python è necessario usare con Django?](https://docs.djangoproject.com/en/3.1/faq/install/#what-python-version-can-i-use-with-django)
1. Per verificare che Django sia installato, immetti quanto segue.
```
(eb-virt)~$ pip freeze
Django==2.2
...
```
Questo comando elenca tutti i pacchetti installati nell'ambiente virtuale. Successivamente, potrai utilizzare l'output di questo comando per configurare il progetto da utilizzare con Elastic Beanstalk.
## Creazione di un progetto Django
Ora è possibile creare un progetto Django ed eseguirlo sul tuo computer, utilizzando l'ambiente virtuale.
**Nota**
Questo tutorial utilizza SQLite, che è un motore di database incluso in Python. Il database viene distribuito con i tuoi file di progetto. Per gli ambienti di produzione, ti consigliamo di utilizzare Amazon Relational Database Service (Amazon RDS) e di separarlo dall'ambiente. Per ulteriori informazioni, consulta [Aggiungere un'istanza DB Amazon RDS al tuo ambiente Python Elastic Beanstalk](create-deploy-python-rds.md).
**Per generare un'applicazione Django**
1. Attiva il tuo ambiente virtuale.
------
#### [ Unix-based systems ]
```
~$ source ~/eb-virt/bin/activate
(eb-virt) ~$
```
------
#### [ Windows ]
```
C:\>%HOMEPATH%\eb-virt\Scripts\activate
(eb-virt) C:\>
```
------
Visualizzerai il prefisso `(eb-virt)` anteposto al prompt dei comandi, a indicare che sei in un ambiente virtuale.
**Nota**
Il resto di queste istruzioni mostra il prompt dei comandi di Linux `~$` nella directory principale e la directory principale Linux `~/`. Su Windows questi sono`C:\Users\USERNAME>`, *USERNAME* dov'è il tuo nome di accesso a Windows.
1. Utilizzare il comando `django-admin startproject` per creare un nuovo progetto Django denominato `ebdjango`:
```
(eb-virt)~$ django-admin startproject ebdjango
```
Questo comando crea un sito Django standard denominato **ebdjango** con la seguente struttura di directory:
```
~/ebdjango
|-- ebdjango
| |-- __init__.py
| |-- settings.py
| |-- urls.py
| `-- wsgi.py
`-- manage.py
```
1. Eseguire il sito Django in locale con `manage.py runserver`:
```
(eb-virt) ~$ cd ebdjango
```
```
(eb-virt) ~/ebdjango$ python manage.py runserver
```
1. Aprire `http://127.0.0.1:8000/` in un browser Web per visualizzare il sito:
1. Seleziona il log del server per visualizzare l'output dalla tua richiesta. Per arrestare il server Web e tornare all'ambiente virtuale, premere **Ctrl\$1C**.
```
Django version 2.2, using settings 'ebdjango.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.
[07/Sep/2018 20:14:09] "GET / HTTP/1.1" 200 16348
Ctrl+C
```
## Configurazione dell'applicazione Django per Elastic Beanstalk
Ora che disponi di un sito con tecnologia Django sul computer locale, puoi configurarlo per la distribuzione con Elastic Beanstalk.
Per impostazione predefinita, Elastic Beanstalk cerca un file denominato `application.py` per avviare l'applicazione. Poiché questo non esiste nel progetto Django creato, è necessario apportare alcune modifiche all'ambiente dell'applicazione. Dovrai anche impostare le variabili di ambiente per consentire il caricamento dei moduli dell'applicazione.
**Per configurare il sito per Elastic Beanstalk**
1. Attiva il tuo ambiente virtuale.
------
#### [ Unix-based systems ]
```
~/ebdjango$ source ~/eb-virt/bin/activate
```
------
#### [ Windows ]
```
C:\Users\USERNAME\ebdjango>%HOMEPATH%\eb-virt\Scripts\activate
```
------
1. Esegui `pip freeze`, quindi salva l'output in un file con nome `requirements.txt`:
```
(eb-virt) ~/ebdjango$ pip freeze > requirements.txt
```
Elastic `requirements.txt` Beanstalk lo utilizza per determinare quale pacchetto installare EC2 sulle istanze che eseguono l'applicazione.
1. Crea una directory denominata `.ebextensions`.
```
(eb-virt) ~/ebdjango$ mkdir .ebextensions
```
1. Nella directory `.ebextensions`, aggiungi un [file di configurazione](ebextensions.md) denominato `django.config` con il seguente testo:
**Example \$1/ebdjango/.ebextensions/django.config**
```
option_settings:
aws:elasticbeanstalk:container:python:
WSGIPath: ebdjango.wsgi:application
```
L'impostazione `WSGIPath` specifica la posizione dello script WSGI utilizzato da Elastic Beanstalk per avviare l'applicazione.
**Nota**
Se stai utilizzando una versione di piattaforma Python in AMI Amazon Linux (precedente ad Amazon Linux 2), sostituisci il valore `WSGIPath` con `ebdjango/wsgi.py`. Il valore nell'esempio funziona con il server Gunicorn WSGI, che non è supportato nelle versioni della piattaforma AMI Amazon Linux.
1. Disattiva l'ambiente virtuale con il comando `deactivate`.
```
(eb-virt) ~/ebdjango$ deactivate
```
Riattiva il tuo ambiente virtuale ogni volta che hai bisogno di aggiungere pacchetti alla tua applicazione o di eseguire l'applicazione in locale.
## Distribuzione del sito con la CLI EB
Hai aggiunto tutto ciò di cui hai bisogno per distribuire l'applicazione su Elastic Beanstalk. La directory del progetto dovrebbe ora apparire così.
```
~/ebdjango/
|-- .ebextensions
| `-- django.config
|-- ebdjango
| |-- __init__.py
| |-- settings.py
| |-- urls.py
| `-- wsgi.py
|-- db.sqlite3
|-- manage.py
`-- requirements.txt
```
Quindi, potrai creare l'ambiente applicativo e distribuire l'applicazione configurata con Elastic Beanstalk.
Subito dopo la distribuzione, potrai modificare la configurazione di Django per aggiungere il nome di dominio che Elastic Beanstalk ha assegnato all'applicazione per il valore `ALLOWED_HOSTS` di Django. Quindi ridistribuisci l'applicazione. Si tratta di un requisito di sicurezza di Django, progettato per evitare attacchi alle intestazioni di `Host` HTTP. Per ulteriori informazioni, consulta la pagina relativa alla [convalida dell'intestazione host](https://docs.djangoproject.com/en/2.2/topics/security/#host-headers-virtual-hosting).
**Creazione di un ambiente e distribuzione dell'applicazione Django**
**Nota**
Il tutorial utilizza la CLI EB come meccanismo di distribuzione, ma è anche possibile utilizzare la console Elastic Beanstalk per distribuire un file ZIP con i contenuti del progetto.
1. Inizializza il repository della CLI EB con il comando **eb init**.
```
~/ebdjango$ eb init -p python-3.7 django-tutorial
Application django-tutorial has been created.
```
Questo comando crea un'applicazione denominata `django-tutorial`. Configura inoltre il repository locale per creare ambienti con la versione più recente della piattaforma Python 3.7.
1. (Facoltativo) Esegui **eb init** nuovamente per configurare una coppia di key pair predefinita in modo da poter utilizzare SSH per connetterti all' EC2 istanza che esegue l'applicazione.
```
~/ebdjango$ 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**.
1. Crea un ambiente e distribuisci in esso l'applicazione con **eb create**:
```
~/ebdjango$ eb create django-env
```
**Nota**
Se visualizzi un messaggio di errore "service role required" (ruolo del servizio richiesto), esegui `eb create` interattivamente (senza specificare un nome dell'ambiente) ed CLI EB crea il ruolo per te.
Questo comando crea un ambiente Elastic Beanstalk con bilanciamento del carico denominato `django-env`. Per la creazione dell'ambiente sono necessari circa 5 minuti. Quando Elastic Beanstalk crea le risorse necessarie per l'esecuzione dell'applicazione, genera messaggi informativi che la CLI EB inoltra al terminale.
1. Al termine del processo di creazione dell'ambiente, puoi individuare il nome di dominio del tuo nuovo ambiente eseguendo **eb status**:
```
~/ebdjango$ eb status
Environment details for: django-env
Application name: django-tutorial
...
CNAME: eb-django-app-dev.elasticbeanstalk.com
...
```
Il nome di dominio del tuo ambiente è il valore della proprietà `CNAME`.
1. Aprire il file `settings.py` nella directory `ebdjango`. Individuare l'impostazione `ALLOWED_HOSTS` e quindi aggiungere al valore dell'impostazione il nome dominio dell'applicazione che hai trovato nella fase precedente. Se non trovi l'impostazione nel file, aggiungila a una nuova riga.
```
...
ALLOWED_HOSTS = ['eb-django-app-dev.elasticbeanstalk.com']
```
1. Salva il file, quindi distribuisci l'applicazione eseguendo **eb deploy**. Quando esegui **eb deploy**, la CLI EB integra i contenuti della tua directory di progetto in un bundle e li distribuisce al tuo ambiente.
```
~/ebdjango$ eb deploy
```
**Nota**
Se usi Git con il progetto, consulta [Utilizzo dell'interfaccia a riga di comando EB con Git](eb3-cli-git.md).
1. Al termine del processo di aggiornamento dell'ambiente, apri il sito Web con **eb open**.
```
~/ebdjango$ eb open
```
Si aprirà una finestra del browser che utilizza il nome di dominio creato per l'applicazione. Dovresti visualizzare lo stesso sito Web Django che hai creato e testato in locale.
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](troubleshooting.md#troubleshooting-deployments) per informazioni su come determinare la causa dell'errore.
Se *vedi* l'applicazione in esecuzione, significa che hai distribuito la tua prima applicazione Django con Elastic Beanstalk.
## Aggiornamento di un'applicazione
Ora che disponi di un'applicazione in esecuzione su Elastic Beanstalk, puoi aggiornare e ridistribuire l'applicazione o la sua configurazione ed Elastic Beanstalk si occuperà dell'aggiornamento delle istanze e dell'avvio della nuova versione dell'applicazione.
Per questo esempio, abilitiamo la console di amministrazione di Django e configuriamo qualche altra impostazione.
### Modifica delle impostazioni del sito
Per impostazione predefinita, il sito Web Django usa il fuso orario UTC per visualizzare l'ora. Per modificare questa opzione, è necessario specificare un fuso orario in `settings.py`.
**Per modificare il fuso orario del sito**
1. Modifica l'impostazione `TIME_ZONE` in `settings.py`.
**Example \$1/ .py ebdjango/ebdjango/settings**
```
...
# Internationalization
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'US/Pacific'
USE_I18N = True
USE_L10N = True
USE_TZ = True
```
Per un elenco dei fusi orari, visita [questa pagina](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones).
1. Distribuisci l'applicazione nell'ambiente Elastic Beanstalk.
```
~/ebdjango/$ eb deploy
```
### Creazione di un amministratore del sito
È possibile creare un amministratore del sito per l'applicazione Django per accedere alla console di amministrazione direttamente dal sito Web. I dettagli di accesso dell'amministratore vengono archiviati in modo sicuro nell'immagine locale del database inclusa nel progetto predefinito generato da Django.
**Per creare un amministratore del sito**
1. Inizializza il database locale dell'applicazione Django:
```
(eb-virt) ~/ebdjango$ python manage.py migrate
Operations to perform:
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 sessions.0001_initial... OK
```
1. Esegui `manage.py createsuperuser` per creare un amministratore:
```
(eb-virt) ~/ebdjango$ python manage.py createsuperuser
Username: admin
Email address: me@mydomain.com
Password: ********
Password (again): ********
Superuser created successfully.
```
1. Per indicare a Django dove archiviare i file statici, definisci `STATIC_ROOT` in `settings.py`:
**Example \$1/ .py ebdjango/ebdjango/settings**
```
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/2.2/howto/static-files/
STATIC_URL = '/static/'
STATIC_ROOT = 'static'
```
1. Esegui `manage.py collectstatic` per popolare la `static` directory con risorse statiche (JavaScriptCSS e immagini) per il sito di amministrazione.
```
(eb-virt) ~/ebdjango$ python manage.py collectstatic
119 static files copied to ~/ebdjango/static
```
1. Distribuisci l'applicazione.
```
~/ebdjango$ eb deploy
```
1. Visualizza la console di amministrazione aprendo il sito nel tuo browser e aggiungendo `/admin/` all'URL del sito, ad esempio:
```
http://djang-env.p33kq46sfh.us-west-2.elasticbeanstalk.com/admin/
```
![\[Inserisci il nome utente e la password creata al passo 2 per accedere alla console di amministrazione.\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/eb_django_admin_login.png)
1. Effettua il login con il nome utente e la password che hai configurato nella fase 2.
![\[Console di amministrazione Django per il sito Web Django distribuito con Elastic Beanstalk\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/eb_django_admin_console.png)
È possibile utilizzare una procedura simile a quella locale updating/testing seguita da**eb deploy**. Elastic Beanstalk si occupa di attività quali l'aggiornamento dei server in tempo reale, consentendoti di concentrarti sullo sviluppo delle applicazioni invece che sull'amministrazione dei server.
### Aggiunta di un file di configurazione di migrazione del database
È possibile aggiungere comandi al tuo script `.ebextensions` che vengono eseguiti quando il tuo sito è aggiornato. In questo modo è possibile generare automaticamente migrazioni di database.
**Per aggiungere una fase di migrazione durante la migrazione dell'applicazione**
1. Crea un nuovo [file di configurazione](ebextensions.md) denominato `db-migrate.config` con il seguente contenuto.
**Example \$1/ebdjango/.ebextensions/db-migrate.config**
```
container_commands:
01_migrate:
command: "source /var/app/venv/*/bin/activate && python3 manage.py migrate"
leader_only: true
option_settings:
aws:elasticbeanstalk:application:environment:
DJANGO_SETTINGS_MODULE: ebdjango.settings
```
Questo file di configurazione attiva l'ambiente virtuale del server ed esegue il comando `manage.py migrate` durante il processo di distribuzione, prima di avviare l'applicazione. Poiché è in esecuzione prima di avviare l'applicazione, è necessario anche configurare la variabile di ambiente `DJANGO_SETTINGS_MODULE` in modo esplicito (in genere `wsgi.py` si occupa di questo per te durante l'avvio). Se specifichi `leader_only: true` nel comando sei sicuro che viene eseguito solo una volta durante la distribuzione a più istanze.
1. Distribuisci l'applicazione.
```
~/ebdjango$ eb deploy
```
## Eliminazione
Per risparmiare ore di istanza e altre AWS risorse tra le sessioni di sviluppo, chiudi l'ambiente Elastic Beanstalk con. **eb terminate**
```
~/ebdjango$ eb terminate django-env
```
Questo comando termina l'ambiente e tutte le AWS risorse in esecuzione al suo interno. Tuttavia, non elimina l'applicazione, di conseguenza puoi sempre creare altri ambienti con la stessa configurazione eseguendo di nuovo **eb create**.
Se hai terminato con l'applicazione di esempio, puoi anche eliminare la cartella del progetto e l'ambiente virtuale:
```
~$ rm -rf ~/eb-virt
~$ rm -rf ~/ebdjango
```
## Fasi successive
Per ulteriori informazioni su Django, tra cui un tutorial dettagliato, consulta [la documentazione ufficiale](https://docs.djangoproject.com/en/2.2/).
Se vuoi provare un altro framework Web Python, consulta [Implementazione di un'applicazione Flask in Elastic Beanstalk](create-deploy-python-flask.md).
# Aggiungere un'istanza DB Amazon RDS al tuo ambiente Python Elastic Beanstalk
Questo argomento fornisce istruzioni per creare un Amazon RDS utilizzando la console Elastic Beanstalk. Puoi utilizzare un'istanza database Amazon Relational Database Service (Amazon RDS) per archiviare i dati raccolti e modificati dall'applicazione. Il database può essere accoppiato all'ambiente e gestito da Elastic Beanstalk oppure può essere creato e gestito esternamente da un altro servizio. In queste istruzioni il database è accoppiato all'ambiente e gestito da Elastic Beanstalk. Per ulteriori informazioni sull'integrazione di un Amazon RDS con Elastic Beanstalk, consulta [Aggiunta di un database all'ambiente Elastic Beanstalk](using-features.managing.db.md).
**Topics**
+ [Aggiunta di un'istanza database all'ambiente](#python-rds-create)
+ [Download di un driver](#python-rds-drivers)
+ [Connessione a un database](#python-rds-connect)
## Aggiunta di un'istanza database all'ambiente
**Per aggiungere un'istanza database al tuo ambiente**
1. Apri la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) e, **nell'elenco Regioni, seleziona la tua**. Regione AWS
1. Nel pannello di navigazione selezionare **Environments** (Ambienti), quindi selezionare il nome dell'ambiente dall'elenco.
1. Nel pannello di navigazione, selezionare **Configuration** (Configurazione).
1. Nella categoria di configurazione del **Database**, scegliere **Edit (Modifica)**.
1. Scegliere un motore di database e immettere un nome utente e una password.
1. Per salvare le modifiche scegli **Apply** (Applica) nella parte inferiore della pagina.
L'aggiunta di un'istanza database richiede circa 10 minuti. Quando l'aggiornamento dell'ambiente è completo, il nome host dell'istanza database e altre informazioni di connessione sono disponibili per la tua applicazione tramite le seguenti proprietà dell'ambiente:
| Nome proprietà | Descrizione | Valore proprietà |
| --- | --- | --- |
| `RDS_HOSTNAME` | Il nome host dell'istanza DB. | Nella scheda **Connectivity & security** (Connettività e sicurezza) della console Amazon RDS: **Endpoint**. |
| `RDS_PORT` | La porta su cui l'istanza database accetta le connessioni. Il valore predefinito varia tra i motori di database. | Nella scheda **Connectivity & security (Connettività e sicurezza)** della console Amazon RDS: **Port (Porta)**. |
| `RDS_DB_NAME` | Il nome del database, **ebdb**. | Nella scheda **Configuration (Configurazione)** della console Amazon RDS: **DB Name (Nome DB)**. |
| `RDS_USERNAME` | Il nome utente configurato per il database. | Nella scheda **Configuration (Configurazione)** della console Amazon RDS: **Master username (Nome utente master)**. |
| `RDS_PASSWORD` | La password configurata per il database. | Non disponibile per riferimento nella console Amazon RDS. |
Per ulteriori informazioni sulla configurazione di un'istanza di database accoppiata a un ambiente Elastic Beanstalk, consulta [Aggiunta di un database all'ambiente Elastic Beanstalk](using-features.managing.db.md).
## Download di un driver
Aggiungi il driver di database al [file di requisiti](python-configuration-requirements.md) del progetto.
**Example requirements.txt: Django con MySQL**
```
Django==2.2
mysqlclient==2.0.3
```
**Pacchetti di driver comuni per Python**
+ **MySQL** – `mysqlclient`
+ **PostgreSQL** – `psycopg2`
+ **Oracle**: `cx_Oracle`
+ **SQL Server** – `adodbapi`
Per ulteriori informazioni, vedere [Python DatabaseInterfaces](https://wiki.python.org/moin/DatabaseInterfaces) e [Django 2.2 -](https://docs.djangoproject.com/en/2.2/ref/databases) database supportati.
## Connessione a un database
Elastic Beanstalk fornisce informazioni di connessione per le istanze database collegate nelle proprietà dell'ambiente. Utilizza `os.environ['VARIABLE']` per leggere le proprietà e configurare una connessione di database.
**Example File di impostazioni Django: dizionario dei DATABASE**
```
import os
if 'RDS_HOSTNAME' in os.environ:
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': os.environ['RDS_DB_NAME'],
'USER': os.environ['RDS_USERNAME'],
'PASSWORD': os.environ['RDS_PASSWORD'],
'HOST': os.environ['RDS_HOSTNAME'],
'PORT': os.environ['RDS_PORT'],
}
}
```
# Risorse e strumenti Python
Vi sono diverse risorse in cui puoi trovare ulteriori informazioni durante lo sviluppo delle tue applicazioni Python:
****
| Risorsa | Description |
| --- | --- |
| [AWS SDK per Python (Boto3) su GitHub](https://github.com/boto/boto3) | Installa Boto3 proveniente da. GitHub |
| [AWS SDK per Python (Boto3) home page](https://aws.amazon.com//sdk-for-python/) | La AWS SDK per Python (Boto3) home page. |
| [Python Developer Center](https://aws.amazon.com/python/) | Punto di riferimento per il codice di esempio, la documentazione, gli strumenti e risorse aggiuntive. |