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 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).