Nasazení Django + Python 3 + PostgreSQL do AWS Elastic Beanstalk

Následuje stručný návod, jak nastavit a nasadit aplikaci Django využívající Python 3 a PostgreSQL do Amazon Web Services (AWS), a to vše při zachování zdravého rozumu.

Použité nástroje/technologie:

Python v3.4.3
Django v1.9
Amazon Elastic Beanstalk, EC2, S3 a RDS
EB CLI 3.x
PostgreSQL

Box zdarma: Kliknutím sem získáte přístup k bezplatné příručce Django Learning Resources Guide (PDF), která vám ukáže tipy a triky a také běžné nástrahy, kterým je třeba se vyhnout při vytváření webových aplikací Python + Django.

Podívejte se na Python 2 verze tohoto článku zde.

Aktualizováno 21. 8. 2016: Aktualizováno nastavení globální konfigurace EB.

Elastic Beanstalk vs EC2

Elastic Beanstalk je platforma jako služba (PaaS), která zjednodušuje nastavení, nasazení a údržbu vaší aplikace na Amazon AWS. Je to spravovaná služba, která spojuje server (EC2), databázi (RDS) a vaše statické soubory (S3). Můžete rychle nasadit a spravovat svou aplikaci, která se automaticky přizpůsobuje růstu vašeho webu. Další informace naleznete v oficiální dokumentaci.

Začínáme

Budeme používat jednoduchou aplikaci „Obrázek dne“, kterou si můžete stáhnout z tohoto úložiště:

$ git clone https://github.com/realpython/image-of-the-day.git
$ cd image-of-the-day/
$ git checkout tags/start_here_py3

Po stažení kódu vytvořte virtualenv a nainstalujte požadavky pomocí pip:

$ pip install -r requirements.txt

Poté, s lokálně spuštěným PostgreSQL, nastavte novou databázi s názvem iotd . V závislosti na vaší místní konfiguraci Postgres může být také nutné aktualizovat DATABASES konfigurace v settings.py . Například jsem aktualizoval konfiguraci na:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'iotd',
        'USER': '',
        'PASSWORD': '',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

Nyní můžete nastavit schéma databáze, vytvořit superuživatele a spustit aplikaci:

$ python manage.py migrate
$ python manage.py createsuperuser
$ python manage.py runserver

Přejděte ve svém prohlížeči na stránku správce na adrese http://localhost:8000/admin a přidejte nový obrázek, který se poté zobrazí na hlavní stránce.

Aplikace nemá být příliš vzrušující; používáme pouze pro účely demo. Jediné, co umožňuje, je nahrát obrázek přes rozhraní správce a zobrazit jej na celé obrazovce na hlavní stránce. To znamená, že ačkoli se jedná o relativně základní aplikaci, stále nám umožní prozkoumat řadu „gotchas“, které existují při nasazení na Amazon Beanstalk a RDS.

Nyní, když máme web v provozu na našem místním počítači, začněme proces nasazení Amazonu.

CLI pro AWS Elastic Beanstalk

Pro práci s Amazon Elastic Beanstalk můžeme použít balíček nazvaný awsebcli. V době psaní tohoto článku je nejnovější verze 3.7.4 a doporučený způsob instalace je pomocí pip:

$ pip install awsebcli

Nyní otestujte instalaci, abyste se ujistili, že funguje:

$ eb --version

To by vám mělo poskytnout pěkné číslo verze 3.x:

EB CLI 3.7.4 (Python 3.4.3)

Chcete-li skutečně začít používat Elastic Beanstalk, budete potřebovat účet u AWS (překvapení!). Zaregistrujte se (nebo se přihlaste).

Konfigurace EB – Inicializace aplikace

Když AWS Elastic Beanstalk CLI funguje, první věc, kterou chceme udělat, je vytvořit prostředí Beanstalk pro hostování aplikace. Spusťte to z adresáře projektu („image-of-the-day“):

$ eb init

To vás vyzve k několika otázkám, které vám pomohou nakonfigurovat vaše prostředí.

Výchozí oblast

Výběr oblasti nejblíže vašim koncovým uživatelům obecně poskytne nejlepší výkon. Pokud si nejste jisti, kterou vybrat, podívejte se na tuto mapu.

Přihlašovací údaje

Dále vás požádá o vaše přihlašovací údaje AWS.

Zde budete pravděpodobně chtít nastavit uživatele IAM. Viz tento návod, jak jej nastavit. Pokud nastavíte nového uživatele, budete se muset ujistit, že má příslušná oprávnění. Nejjednodušší způsob, jak toho dosáhnout, je přidat k uživateli „Přístup správce“. (To však pravděpodobně není skvělá volba z bezpečnostních důvodů.) Konkrétní zásady/role, které uživatel potřebuje k vytvoření/správě aplikace Elastic Beanstalk, naleznete zde.

Název aplikace

Toto bude výchozí název adresáře. Jen s tím.

Verze Pythonu

Dále by CLI mělo automaticky zjistit, že používáte Python, a požádat o potvrzení. Říkat ano. Poté musíte vybrat verzi platformy. Pro Python 3 zde máte 2 různé možnosti:

Python 3.4
Python 3.4 (předkonfigurovaný – Docker)

Pokud jste hipster, vyberte volbu ‚Předkonfigurováno – Docker‘, jinak použijte normální ‚Python 3.4‘. Ne, jen škádlení; základní rozdíl je tento:

Python 3.4

Získáte tak obraz EC2 na 64bitovém Amazon Linuxu s předinstalovaným Pythonem 3.4. Přední webový server je apache s nainstalovaným mod_wsgi. Toto je „standardní“ nebo „tradiční“ způsob, jakým Beanstalk funguje. Jinými slovy, s touto možností Beanstalk vytvoří obrázky EC2 a můžete použít ebextension soubory, o kterých si povíme později, abychom přizpůsobili obraz EC2.

Python 3.4 (předkonfigurovaný – Docker)

Získáte tak obraz EC2, na kterém běží Docker, s již nastaveným obrazem Dockeru. Obraz Dockeru běží na 64bitovém Debianu Jessie s Pythonem 3.4, nginx 1.8 a uWSGI 2.0.8. Protože v zásadě komunikujete s obrazem Docker přímo, pokud zvolíte tuto cestu, použijete standardní konfigurační techniky Dockeru (tj. „Dockerfile“), a pak nemusíte dělat mnoho, co je specifické pro AWS Beanstalk, protože Beanstalk ví, jak za vás spravovat image Docker.

V tomto článku se zaměříme na „standardní“ nebo „tradiční“ způsob použití obrázku EC2, takže vyberte možnost ‚Python 3.4‘ a pojďme dál.

SSH

Řekněte ano nastavení SSH pro vaše instance.

Klíčový pár RSA

Dále musíte vygenerovat pár klíčů RSA, který bude přidán do vašeho ~/.ssh složka. Tento pár klíčů bude také nahrán do veřejného klíče EC2 pro oblast, kterou jste zadali v prvním kroku. To vám umožní SSH do vaší instance EC2 později v tomto tutoriálu.

Co jsme dokázali?

Jednou eb init je dokončena, uvidíte novou skrytou složku s názvem .elasticbeanstalk v adresáři vašeho projektu:

├── .elasticbeanstalk
│   └── config.yml
├── .gitignore
├── README.md
├── iotd
│   ├── images
│   │   ├── __init__.py
│   │   ├── admin.py
│   │   ├── migrations
│   │   │   ├── 0001_initial.py
│   │   │   └── __init__.py
│   │   ├── models.py
│   │   ├── tests.py
│   │   └── views.py
│   ├── iotd
│   │   ├── __init__.py
│   │   ├── settings.py
│   │   ├── urls.py
│   │   └── wsgi.py
│   ├── manage.py
│   ├── static
│   │   ├── css
│   │   │   └── bootstrap.min.css
│   │   └── js
│   │       ├── bootstrap.min.js
│   │       └── jquery-1.11.0.min.js
│   └── templates
│       ├── base.html
│       └── images
│           └── home.html
├── requirements.txt
└── www
    └── media
        └── sitelogo.png

Uvnitř tohoto adresáře je config.yml file, což je konfigurační soubor, který se používá k definování určitých parametrů pro vaši nově vytvořenou aplikaci Beanstalk.

V tomto okamžiku, pokud napíšete eb console otevře se váš výchozí prohlížeč a přejděte do konzoly Elastic Beanstalk. Na stránce byste měli vidět jednu aplikaci (nazvanou image-of-the-day pokud přesně sledujete), ale žádná prostředí.

Aplikace představuje vaši kódovou aplikaci a je to, co eb init vytvořené pro nás. S Elastic Beanstalk může mít aplikace více prostředí (tj. vývoj, testování, příprava, produkce). Je zcela na vás, jak chcete tato prostředí konfigurovat/spravovat. Pro jednoduché aplikace Django mám rád vývojové prostředí na svém notebooku a poté vytvořím testovací a produkční prostředí na Beanstalku.

Pojďme nastavit testovací prostředí…

Konfigurace EB – vytvoření prostředí

Vraťme se k terminálu, v adresáři projektu zadejte:

$ eb create

Stejně jako eb init , tento příkaz vás vyzve k sérii otázek.

Název prostředí

Měli byste použít podobnou konvenci pojmenování, jakou navrhuje Amazon – např. application_name-env_name – zvláště když/pokud začnete hostovat více aplikací pomocí AWS. Použil jsem - iod-test .

Předpona DNS CNAME

Když nasadíte aplikaci do Elastic Beanstalk, automaticky získáte název domény jako xxx.elasticbeanstalk.com. DNS CNAME prefix je to, co chcete použít místo xxx . Výchozí nastavení pravděpodobně nebude fungovat, pokud jej sledujete, protože jej již použil někdo jiný (názvy jsou globální pro AWS), takže vyberte něco jedinečného a pokračujte.

Co se stane teď?

V tomto bodě eb skutečně vytvoří vaše prostředí pro vás. Buďte trpěliví, protože to může chvíli trvat.

Pokud se při vytváření prostředí objeví chyba, například - aws.auth.client.error.ARCInstanceIdentityProfileNotFoundException - zkontrolujte, zda přihlašovací údaje, které používáte, mají příslušná oprávnění k vytvoření prostředí Beanstalk, jak bylo uvedeno dříve v tomto příspěvku.

Také vás může vyzvat zprávou o Platform requires a service role . Pokud ano, řekněte ano a nechte ho vytvořit roli za vás.

Ihned po vytvoření prostředí eb se pokusí nasadit vaši aplikaci zkopírováním veškerého kódu z vašeho projektového adresáře do nové instance EC2 spuštěním pip install -r requirements.txt v procesu.

Na obrazovce byste měli vidět spoustu informací o nastavovaném prostředí a také informace o eb snaží nasadit. Uvidíte také některé chyby. Konkrétně byste měli vidět tyto řádky pohřbené někde ve výstupu:

ERROR: Your requirements.txt is invalid. Snapshot your logs for details.

Nebojte se - není to opravdu neplatné. Podrobnosti najdete v protokolech:

$ eb logs

To stáhne všechny poslední soubory protokolu z instance EC2 a odešle je do vašeho terminálu. Je to spousta informací, takže možná budete chtít přesměrovat výstup do souboru (eb logs -z ). Když si prohlédnete protokoly, uvidíte jeden soubor protokolu s názvem eb-activity.log :

Error: pg_config executable not found.

Problém je v tom, že jsme se pokusili nainstalovat psycopy2 (vazby Postgres Python), ale potřebujeme, aby byly nainstalovány také klientské ovladače Postgres. Protože nejsou standardně nainstalovány, musíme je nejprve nainstalovat. Pojďme to napravit…

Přizpůsobení procesu nasazení

eb přečte vlastní .config soubory ze složky nazvané „.ebextensions“ na kořenové úrovni vašeho projektu (adresář „image-of-the-day“). Tyto .config soubory umožňují instalovat balíčky, spouštět libovolné příkazy a/nebo nastavovat proměnné prostředí. Soubory v adresáři „.ebextensions“ by měly odpovídat buď JSON nebo YAML syntaxe a jsou prováděny v abecedním pořadí.

Instalace balíčků

První věc, kterou musíme udělat, je nainstalovat nějaké balíčky, aby naše pip install příkaz bude úspěšně dokončen. Chcete-li to provést, nejprve vytvořte soubor s názvem .ebextensions/01_packages.config :

packages:
  yum:
    git: []
    postgresql93-devel: []
    libjpeg-turbo-devel: []

Na instancích EC2 běží Amazon Linux, což je varianta Redhat, takže můžeme použít yum k instalaci balíčků, které potřebujeme. Prozatím se chystáme nainstalovat tři balíčky – git, klienta Postgres a libjpeg pro Pillow.

Po vytvoření tohoto souboru pro opětovné nasazení aplikace musíme provést následující:

$ git add .ebextensions/
$ git commit -m "added eb package configuration"

Změny musíme potvrdit, protože příkaz nasazení eb deploy pracuje s nejnovějším odevzdáním, a proto bude vědět o našich změnách v souborech až poté, co je odevzdáme do git. (Všimněte si však, že nemusíme tlačit; pracujeme z naší místní kopie…)

Jak jste pravděpodobně uhodli, další příkaz je:

$ eb deploy

Nyní byste měli vidět pouze jednu chybu:

INFO: Environment update is starting.
INFO: Deploying new version to instance(s).
ERROR: Your WSGIPath refers to a file that does not exist.
INFO: New application version was deployed to running EC2 instances.
INFO: Environment update completed successfully.

Pojďme zjistit, co se děje…

Konfigurace našeho prostředí Python

Instance EC2 v Beanstalku spouští Apache a Apache najde naši aplikaci Python podle WSGIPATH, který jsme nastavili. Ve výchozím nastavení eb předpokládá, že se náš soubor wsgi jmenuje application.py . Existují dva způsoby, jak to opravit-

Možnost 1:Použití nastavení konfigurace specifické pro prostředí

$ eb config

Tento příkaz otevře váš výchozí editor upravující konfigurační soubor s názvem .elasticbeanstalk/iod-test.env.yml . Tento soubor ve skutečnosti lokálně neexistuje; eb stáhl jej ze serverů AWS a předložil vám jej, abyste v něm mohli změnit nastavení. Pokud v tomto pseudosouboru provedete nějaké změny a poté jej uložíte a ukončíte, eb aktualizuje odpovídající nastavení ve vašem prostředí Beanstalk.

Pokud v souboru hledáte výrazy „WSGI“ a měli byste najít konfigurační sekci, která vypadá takto:

aws:elasticbeanstalk:container:python:
  NumProcesses: '1'
  NumThreads: '15'
  StaticFiles: /static/=static/
  WSGIPath: application.py

Aktualizujte WSGIPath:

 aws:elasticbeanstalk:container:python:
   NumProcesses: '1'
   NumThreads: '15'
   StaticFiles: /static/=static/
   WSGIPath: iotd/iotd/wsgi.py

A pak budete mít správně nastavenou cestu WSGIPath. Pokud pak soubor uložíte a ukončíte, eb automaticky aktualizuje konfiguraci prostředí:

Printing Status:
INFO: Environment update is starting.
INFO: Updating environment iod-test's configuration settings.
INFO: Successfully deployed new configuration to environment.
INFO: Environment update completed successfully.

Výhoda použití eb config způsob změny nastavení spočívá v tom, že můžete zadat různá nastavení pro každé prostředí. Ale můžete také aktualizovat nastavení pomocí stejného .config soubory, které jsme dříve používali. To použije stejné nastavení pro každé prostředí jako .config soubory budou použity při nasazení (po nastavení z eb config byly použity).

Možnost 2:Použití globálního nastavení konfigurace

Chcete-li použít .config file option, pojďme vytvořit nový soubor s názvem /.ebextensions/02_python.config :

option_settings:
  "aws:elasticbeanstalk:application:environment":
    DJANGO_SETTINGS_MODULE: "iotd.settings"
    "PYTHONPATH": "/opt/python/current/app/iotd:$PYTHONPATH"
  "aws:elasticbeanstalk:container:python":
    WSGIPath: iotd/iotd/wsgi.py
    NumProcesses: 3
    NumThreads: 20
  "aws:elasticbeanstalk:container:python:staticfiles":
    "/static/": "www/static/"

Co se děje?

DJANGO_SETTINGS_MODULE: "iotd.settings" - přidá cestu k modulu nastavení.
"PYTHONPATH": "/opt/python/current/app/iotd:$PYTHONPATH" - aktualizuje náš PYTHONPATH takže Python může najít moduly v naší aplikaci. Tato cesta se může lišit v závislosti na vašem nastavení! Další podrobnosti naleznete v tomto komentáři. (Upozorňujeme, že je nutné použít úplnou cestu.)
WSGIPath: iotd/iotd/wsgi.py nastavuje naši cestu WSGI.
NumProcesses: 3 a NumThreads: 20 - aktualizuje počet procesů a vláken používaných ke spuštění naší aplikace WSGI.
"/static/": "www/static/" nastaví cestu ke statickým souborům.

Opět můžeme provést git commit pak eb deploy pro aktualizaci těchto nastavení.

Dále přidáme databázi.

Konfigurace databáze

Zkuste si prohlédnout nasazenou webovou stránku:

$ eb open

Tento příkaz zobrazí nasazenou aplikaci ve vašem výchozím prohlížeči. Měla by se zobrazit chyba odmítnutí připojení:

OperationalError at /
could not connect to server: Connection refused
    Is the server running on host "localhost" (127.0.0.1) and accepting
    TCP/IP connections on port 5432?

Je to proto, že jsme ještě nevytvořili databázi. V tomto bodě eb nastaví vaše prostředí Beanstalk, ale nenastaví RDS (databázová vrstva). Musíme to nastavit ručně.

Nastavení databáze

Opět použijte eb console otevřete konfigurační stránku Beanstalk.

Odtud proveďte následující:

Klikněte na odkaz „Konfigurace“.
Posuňte se úplně na konec stránky a potom v části „Data Tier“ klikněte na odkaz „vytvořit novou databázi RDS“.
Na stránce nastavení RDS změňte „DB Engine“ na „postgres“.
Přidejte „Hlavní uživatelské jméno“ a „Hlavní heslo“.
Uložte změny.

Beanstalk pro vás vytvoří RDS. Nyní potřebujeme získat naši aplikaci Django pro připojení k RDS. Beanstalk nám zde pomůže tím, že nám zpřístupní řadu proměnných prostředí na instancích EC2, které podrobně popisují, jak se připojit k serveru Postgres. Takže vše, co musíme udělat, je aktualizovat naše settings.py soubor, abyste využili těchto proměnných prostředí. Potvrďte, že DATABASES konfigurační parametr odráží následující v settings.py :

if 'RDS_DB_NAME' in os.environ:
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.postgresql_psycopg2',
            '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'],
        }
    }
else:
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.postgresql_psycopg2',
            'NAME': 'iotd',
            'USER': 'iotd',
            'PASSWORD': 'iotd',
            'HOST': 'localhost',
            'PORT': '5432',
        }
    }

To jednoduše říká:„použijte nastavení proměnné prostředí, pokud existuje, jinak použijte naše výchozí nastavení vývoje.“ Jednoduché.

Zpracování migrací databáze

Při nastavení naší databáze se stále musíme ujistit, že migrace běží tak, aby byla struktura databázové tabulky správná. Můžeme to udělat úpravou .ebextensions/02_python.config a přidáním následujících řádků na začátek souboru:

container_commands:
  01_migrate:
    command: "source /opt/python/run/venv/bin/activate && python iotd/manage.py migrate --noinput"
    leader_only: true

container_commands umožňují spouštět libovolné příkazy poté, co byla aplikace nasazena na instanci EC2. Protože je instance EC2 nastavena pomocí virtuálního prostředí, musíme toto virtuální prostředí nejprve aktivovat, než spustíme náš příkaz migrace. Také leader_only: true nastavení znamená, „při nasazení do více instancí spusťte tento příkaz pouze v první instanci.“

Nezapomeňte, že naše aplikace využívá Django's admin, takže budeme potřebovat superuživatele…

Vytvořte administrátora

Bohužel createsuperuser neumožňuje zadat heslo při použití --noinput možnost, takže budeme muset napsat vlastní příkaz. Naštěstí Django velmi usnadňuje vytváření vlastních příkazů.

Vytvořte soubor iotd/images/management/commands/createsu.py :

from django.core.management.base import BaseCommand
from django.contrib.auth.models import User


class Command(BaseCommand):

    def handle(self, *args, **options):
        if not User.objects.filter(username="admin").exists():
            User.objects.create_superuser("admin", "[email protected]", "admin")

Ujistěte se, že jste přidali odpovídající __init__.py soubory také:

└─ management
    ├── __init__.py
    └── commands
        ├── __init__.py
        └── createsu.py

Tento soubor vám umožní spustit python manage.py createsu a vytvoří superuživatele bez výzvy k zadání hesla. Nebojte se příkaz rozšířit tak, aby používal proměnné prostředí nebo jiné prostředky, které vám umožní změnit heslo.

Jakmile budete mít příkaz vytvořen, můžeme přidat další příkaz do našich container_commands sekce v .ebextensions/02_python.config :

02_createsu:
  command: "source /opt/python/run/venv/bin/activate && python iotd/manage.py createsu"
  leader_only: true

Než to otestujete, ujistěte se, že jsou všechny naše statické soubory umístěny na správné místo…

Statické soubory

Přidejte jeden další příkaz pod container_commands :

03_collectstatic:
  command: "source /opt/python/run/venv/bin/activate && python iotd/manage.py collectstatic --noinput"

Celý soubor tedy vypadá takto:

container_commands:
  01_migrate:
    command: "source /opt/python/run/venv/bin/activate && python iotd/manage.py migrate --noinput"
    leader_only: true
  02_createsu:
    command: "source /opt/python/run/venv/bin/activate && python iotd/manage.py createsu"
    leader_only: true
  03_collectstatic:
    command: "source /opt/python/run/venv/bin/activate && python iotd/manage.py collectstatic --noinput"

option_settings:
  "aws:elasticbeanstalk:application:environment":
    DJANGO_SETTINGS_MODULE: "iotd.settings"
    "PYTHONPATH": "/opt/python/current/app/iotd:$PYTHONPATH"
    "ALLOWED_HOSTS": ".elasticbeanstalk.com"
  "aws:elasticbeanstalk:container:python":
    WSGIPath: iotd/iotd/wsgi.py
    NumProcesses: 3
    NumThreads: 20
  "aws:elasticbeanstalk:container:python:staticfiles":
    "/static/": "www/static/"

Nyní se musíme ujistit, že STATIC_ROOT je správně nastaven v settings.py soubor:

STATIC_ROOT = os.path.join(BASE_DIR, "..", "www", "static")
STATIC_URL = '/static/'

Ujistěte se, že jste potvrdili www adresář do git, aby bylo možné vytvořit statický dir. Poté spusťte eb deploy znovu a nyní byste měli podnikat:

INFO: Environment update is starting.
INFO: Deploying new version to instance(s).
INFO: New application version was deployed to running EC2 instances.
INFO: Environment update completed successfully.

V tomto okamžiku byste měli být schopni přejít na http://your_app_url/admin, přihlásit se, přidat obrázek a poté vidět tento obrázek zobrazený na hlavní stránce vaší aplikace.

Úspěch!

Použití S3 pro ukládání médií

S tímto nastavením při každém dalším nasazení ztratíme všechny naše nahrané obrázky. Proč? Když spustíte eb deploy , je pro vás připravena nová instance. To není to, co chceme, protože pak budeme mít záznamy v databázi pro obrázky, ale žádné související obrázky. Řešením je uložit mediální soubory ve službě Amazon Simple Storage Service (Amazon S3) namísto v samotné instanci EC2.

Budete potřebovat:

Vytvořte bucket
Získejte ARN (Amazon Resource Name) svého uživatele
Přidat oprávnění k segmentu
Nakonfigurujte svou aplikaci Django tak, aby používala S3 k poskytování statických souborů

Vzhledem k tomu, že o tom již existují dobré zápisy, nasměruji vás na své oblíbené:Používání Amazon S3 k ukládání statických a mediálních souborů Django

Konfigurace Apache

Protože používáme Apache s Beanstalk, pravděpodobně chceme nastavit Apache tak, aby (mimo jiné) povolil kompresi gzip, takže klienti stahují soubory rychleji. To lze provést pomocí container_commands . Vytvořte nový soubor .ebextensions/03_apache.config a přidejte následující:

container_commands:
  01_setup_apache:
    command: "cp .ebextensions/enable_mod_deflate.conf /etc/httpd/conf.d/enable_mod_deflate.conf"

Poté musíte vytvořit soubor .ebextensions/enable_mod_deflate.conf :

# mod_deflate configuration
<IfModule mod_deflate.c>
  # Restrict compression to these MIME types
  AddOutputFilterByType DEFLATE text/plain
  AddOutputFilterByType DEFLATE text/html
  AddOutputFilterByType DEFLATE application/xhtml+xml
  AddOutputFilterByType DEFLATE text/xml
  AddOutputFilterByType DEFLATE application/xml
  AddOutputFilterByType DEFLATE application/xml+rss
  AddOutputFilterByType DEFLATE application/x-javascript
  AddOutputFilterByType DEFLATE text/javascript
  AddOutputFilterByType DEFLATE text/css
  # Level of compression (Highest 9 - Lowest 1)
  DeflateCompressionLevel 9
  # Netscape 4.x has some problems.
  BrowserMatch ^Mozilla/4 gzip-only-text/html
  # Netscape 4.06-4.08 have some more problems
  BrowserMatch ^Mozilla/4\.0[678] no-gzip
  # MSIE masquerades as Netscape, but it is fine
  BrowserMatch \bMSI[E] !no-gzip !gzip-only-text/html
<IfModule mod_headers.c>
  # Make sure proxies don't deliver the wrong content
  Header append Vary User-Agent env=!dont-vary
</IfModule>
</IfModule>

Tím povolíte kompresi gzip, která by měla pomoci s velikostí souborů, které stahujete. Stejnou strategii byste také mohli použít k automatickému minifikování a kombinování vašich CSS/JS a k provedení jakéhokoli dalšího předběžného zpracování, které potřebujete.

Odstraňování problémů

Nezapomeňte na velmi užitečné eb ssh příkaz, který vás dostane do instance EC2, takže se můžete porozhlédnout a zjistit, co se děje. Při odstraňování problémů existuje několik adresářů, kterých byste si měli být vědomi:

/opt/python :Kořen toho, kam vaše aplikace skončí.
/opt/python/current/app :Aktuální aplikace, která je hostována v prostředí.
/opt/python/on-deck/app :Aplikace je nejprve umístěna na palubě a poté, co je kompletní nasazení dokončeno, bude přesunuta do current . Pokud dochází k chybám v container_commands , podívejte se na on-deck složku a ne current složka.
/opt/python/current/env :Všechny proměnné env, které eb pro vás nastaví. Pokud se pokoušíte reprodukovat chybu, možná budete muset nejprve source /opt/python/current/env aby byly věci nastaveny tak, jak by byly, když běží eb deploy.
opt/python/run/venv :Virtuální prostředí používané vaší aplikací; budete také muset spustit source /opt/python/run/venv/bin/activate pokud se pokoušíte reprodukovat chybu.

Závěr

Nasazení na Elastic Beanstalk může být zpočátku trochu skličující, ale jakmile pochopíte, kde jsou všechny části a jak věci fungují, je to vlastně docela snadné a extrémně flexibilní. Poskytuje vám také prostředí, které se bude automaticky škálovat s rostoucím využitím. Doufejme, že teď už máte dost na to, abyste byli nebezpeční! Hodně štěstí při dalším nasazení Beanstalk.

Chybělo nám něco? Máte nějaké další tipy nebo triky? Prosím komentujte níže.