Distribuzione di un'applicazione Django in Elastic Beanstalk

In questo tutorial viene descritta la distribuzione di un sito Web Django 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

• Creazione di un progetto Django

• Configurazione dell'applicazione Django per Elastic Beanstalk

• Distribuzione del sito con la CLI EB

• Aggiornamento di un'applicazione

• Elimina

Prerequisiti

Per utilizzare qualsiasi servizio AWS, incluso Elastic Beanstalk, è necessario disporre di un account AWS e delle credenziali. Per ulteriori informazioni e per registrarsi, visita il sito https://aws.amazon.com/.

Per seguire questo tutorial, è necessario aver prima installato tutti i prerequisiti comuni per Python, inclusi i seguenti pacchetti:

• Python 3.7 o versioni successive

• pip

• virtualenv

• awsebcli

Il framework Django viene installato nell'ambito di questo tutorial.

Nota

La creazione di ambienti con CLI EB richiede un ruolo del servizio. 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, è possibile individuare esattamente i pacchetti necessari per l'applicazione, in modo che i pacchetti necessari vengano installati sulle istanze Amazon EC2 che eseguono 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

2. 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 ~$. In Windows, è C:\Users\USERNAME>, dove USERNAME è il nome di accesso di Windows.

3. 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 in questo argomento.

   Per ulteriori informazioni sulle versioni correnti della piattaforma Python, consulta 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?

4. 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, un motore di database semplice 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 . Aggiunta di un'istanza database Amazon RDS all'ambiente applicativo Python.

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 ~/. In Windows, sono C:\Users\USERNAME>, dove USERNAME è il nome di accesso di Windows.

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

3. Eseguire il sito Django in locale con : manage.py runserver.

   (eb-virt) ~$ cd ebdjango

   (eb-virt) ~/ebdjango$ python manage.py runserver

4. Aprire http://127.0.0.1:8000/ in un browser Web per visualizzare il sito:

5. Seleziona il log del server per visualizzare l'output dalla tua richiesta. Per arrestare il server Web e tornare all'ambiente virtuale, premere Ctrl+C.

   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

2. Esegui pip freeze, quindi salva l'output in un file con nome requirements.txt:

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

   Elastic Beanstalk utilizza requirements.txt per determinare quale pacchetto installare nelle istanze EC2 che eseguono l'applicazione.

3. Crea una directory denominata .ebextensions.

   (eb-virt) ~/ebdjango$ mkdir .ebextensions

4. Nella directory .ebextensions, aggiungi un file di configurazione denominato django.config con il seguente testo:

   Esempio ~/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.

5. 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 di Django ALLOWED_HOSTS. 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.

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.

2. (Facoltativo) Esegui nuovamente eb init per configurare una coppia di chiavi predefinite e connetterti all'istanza EC2 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.

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

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

5. 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']

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

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

   Esempio ~/ebdjango/ebdjango/settings.py

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

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

2. Esegui manage.py createsuperuser per creare un amministratore:

   (eb-virt) ~/ebdjango$ python manage.py createsuperuser
   Username: admin
   Email address: [e-mail]
   Password: ********
   Password (again): ********
   Superuser created successfully.

3. Per indicare a Django dove archiviare i file statici, definisci STATIC_ROOT in settings.py:

   Esempio ~/ebdjango/ebdjango/settings.py

   # Static files (CSS, JavaScript, Images)
   # https://docs.djangoproject.com/en/2.2/howto/static-files/
   STATIC_URL = '/static/'
   STATIC_ROOT = 'static'

4. Esegui manage.py collectstatic per compilare la directory static con asset statici (JavaScript, CSS e immagini) per il sito dell'amministratore.

   (eb-virt) ~/ebdjango$ python manage.py collectstatic
   119 static files copied to ~/ebdjango/static
             

5. Distribuisci l'applicazione.

   ~/ebdjango$ eb deploy

6. 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/

   

7. Effettua il login con il nome utente e la password che hai configurato nella fase 2.

   

È possibile utilizzare una procedura simile di aggiornamento/testi locale 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 denominato db-migrate.config con il seguente contenuto.

   Esempio ~/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.

2. Distribuisci l'applicazione.

   ~/ebdjango$ eb deploy

Elimina

Per salvare le ore di istanza e altre risorse AWS tra le sessioni di sviluppo, termina l'ambiente Elastic Beanstalk con eb terminate.

~/ebdjango$ eb terminate django-env

Questo comando termina l'ambiente e tutte le risorse AWS 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. Per ulteriori informazioni sulla CLI EB, consulta Gestione degli ambienti Elastic Beanstalk con l'interfaccia a riga di comando EB.

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.

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