Distribuzione di un'applicazione Django in Elastic Beanstalk - AWS Elastic Beanstalk
PrerequisitiConfigurazione di un ambiente virtuale Python e installazione di DjangoCreazione di un progetto DjangoConfigurazione dell'applicazione Django per Elastic BeanstalkImplementa il tuo sito con l'EB CLIAggiornamento di un'applicazioneEliminazionePassaggi successivi

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

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:

Prerequisiti

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 l'EB CLI richiede un ruolo di servizio. Puoi creare un ruolo di servizio tramite la creazione di un ambiente nella console Elastic Beanstalk. Se non disponi di un ruolo di servizio, l'EB CLI tenta di crearne uno durante l'esecuzioneeb 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

  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 questo èC:\Users\USERNAME>, dove USERNAME è il tuo nome di accesso a 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 Implementa il tuo sito con l'EB CLI 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 utilizzaSQLite, 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 (RDSAmazon) e di separarlo dal tuo ambiente. Per ulteriori informazioni, consulta Aggiungere un'istanza Amazon RDS DB al tuo ambiente Python Elastic Beanstalk.

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 questi sonoC:\Users\USERNAME>, dove USERNAME è il tuo nome di accesso a 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 requirements.txt Beanstalk lo utilizza per determinare quale pacchetto installare EC2 sulle istanze 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

    Questa impostazione specifica WSGIPath la posizione dello WSGI script utilizzato da Elastic Beanstalk per avviare l'applicazione.

    Nota

    Se utilizzi una versione della piattaforma Amazon Linux AMI Python (precedente ad Amazon Linux 2), sostituisci il valore WSGIPath per con. ebdjango/wsgi.py Il valore nell'esempio funziona con il WSGI server Gunicorn, che non è supportato nelle versioni della AMI piattaforma 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.

Implementa il tuo sito con l'EB CLI

Hai aggiunto tutto ciò di cui hai bisogno per distribuire l'applicazione su Elastic Beanstalk. La directory del 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. Questo è un requisito di sicurezza di Django, progettato per prevenire gli attacchi di HTTP Host intestazione. Per ulteriori informazioni, consulta la pagina relativa alla convalida dell'intestazione host.

Creazione di un ambiente e distribuzione dell'applicazione Django
Nota

Questo tutorial utilizza l'EB CLI come meccanismo di distribuzione, ma puoi anche utilizzare la console Elastic Beanstalk per distribuire un file.zip contenente i contenuti del progetto.

  1. Inizializza il tuo repository EB con il comando. CLI 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 eb init nuovamente per configurare una coppia di key pair predefinita SSH da utilizzare per connetterti all'EC2istanza 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 viene visualizzato il messaggio di errore «ruolo di servizio richiesto», esegui in eb create modo interattivo (senza specificare un nome di ambiente) e l'EB CLI creerà 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 eseguire l'applicazione, emette messaggi informativi che l'EB inoltra al terminale. CLI

  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 si esegueeb deploy, l'EB CLI raggruppa il contenuto della directory del progetto e lo distribuisce nell'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 tuo sito web Django utilizza il fuso UTC orario 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: me@mydomain.com
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 popolare la static directory con risorse statiche (JavaScripte immagini) per il sito di amministrazione. CSS

    (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 browser e /admin/ aggiungendolo al sitoURL, come segue.

    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.

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

È 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

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. Per ulteriori informazioni sui CLI comandi EB, vedereGestione 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

Passaggi successivi

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.