Django Руководство часть 11: Разворачивание сайта на сервере
============================================================

* Назад
* Обзор: Django
* Далее

Теперь, когда вы создали (и протестировали) свой шикарный сайт LocalLibrary, у вас скорее всего, есть желание разместить его на публичном веб-сервере, чтобы он стал доступен через интернет персоналу и посетителям библиотеки. Данная статья даёт общее представление о том, каким образом подойти к поиску хостинга для размещения сайта, а также, что нужно сделать чтобы подготовить свой сайт к публикации.

| Требования: | Завершить изучение всех предыдущих частей руководства, включая Django Руководство часть 10: Тестирование веб-приложений в Django. |
| --- | --- |
| Цель: | Изучить, где и как вы можете развернуть приложение Django для публичного доступа. |

Обзор
-----

Даже когда разработка вашего сайта завершена (или "достаточно" завершена для начала публичного тестирования), то для публичного доступа вам надо его где-то разместить.

До сего момента вы работали в каком-то рабочем окружении - чтобы получать отладочную и другую частную информацию, вы использовали веб-сервер Django в локальной сети при этом запускали сайт с (небезопасными) настройками разработки. Перед тем как разместить сайт публично, вы должны сделать следующее:

* Сделать несколько изменений в настройках проекта.
* Выбрать/Настроить окружение для хостинга приложения Django.
* Выбрать/Настроить окружение для размещения статических файлов.
* В целях обслуживания сайта настроить инфраструктуру для его развёртывания.

Данное руководство предоставляет небольшой обзор выбора хостинга, приготовления сайта к публичному размещению, а также практический пример установки сайта LocalLibrary на облачный сервис Heroku.

Что такое окружение развёртывания?
----------------------------------

Окружение развёртывания - это среда, которое предоставляет сервер, на котором вы будете размещать свой веб-сайт для публичного запуска и доступа. Данное окружение включает в себя:

* Железо на котором будет запускаться сайт.
* Операционную систему (Linux, Windows).
* Языки программирования времени выполнения (скриптовые) и библиотеки, которые использует ваш сайт.
* Веб-сервер, используемый для обслуживания страниц и другого контента (Nginx, Apache).
* Сервер приложений, который передаёт "динамические" запросы между сайтом Django и веб-сервером.
* Базу данных, от которой зависит ваш сайт.

**Примечание:** У вас может быть потребность в обратном прокси, балансировщике загрузки и так далее.

Сервер может быть вашим собственным с подключением к интернету по скоростному каналу, но более общим подходом является применение "облачных решений". Что действительно имеет значение, так это то, что ваш код запускается на некотором удалённом компьютере (возможно и "виртуальном"), в хостинговом дата-центре. Удалённый сервер обычно предоставляет определённый доступ к компьютерным ресурсам (процессору, оперативной памяти, памяти на жёстких носителях и так далее) и соединение с интернетом за некоторую цену.

Такой тип удалённого доступа к вычислительному/сетевому железу называется *Инфраструктура как Сервис (Infrastructure as a Service - IaaS)*. Множество IaaS поставщиков предлагают услуги по предустановке какой-либо операционной системы, на которую вы можете установить необходимые для вашего рабочего окружения компоненты. Другие поставщики предлагают вам выбрать уже готовые полноценные рабочие окружения, возможно, включающие в себя Django и настроенный веб-сервер.

**Примечание:** Готовые окружения могут сделать настройку вашего веб-сайта очень простой задачей, поскольку они имеют минимальную конфигурацию, однако, либо количество доступных опций может быть недостаточным, или они будут соответствовать устаревшей операционной системе. Часто, более предпочтительно установить необходимые компоненты самостоятельно, таким образом вы получите то, что вам необходимо, а в последующем, при обновлении системы, уже будете знать что нужно делать!

Некоторые провайдеры поддерживают Django как часть своего предложения *Платформа как Сервис (Platform as a Service* - PaaS). При данном виде хостинга вам не нужно беспокоиться о большей части окружения (веб-сервере, сервере приложений, балансировщике загрузки), так как сама платформа берёт это на себя (включая все моменты, касающиеся роста и развития вашего приложения). В данном случае развёртывание приложения является достаточно простой задачей, - вам нужно сконцентрироваться только на вашем приложении, а не на инфраструктуре.

Некоторые разработчики выбирают более гибкое решение, предоставляемое IaaS, в то время как другие предпочитают иметь наименьшие накладные расходы и простое масштабирование, предоставляемое PaaS. Когда вы только начинаете, то система типа PaaS является предпочтительной и это именно то, что мы будем использовать в данном руководстве.

**Примечание:** Если вы выбираете хостинг с поддержкой Python/Django, то он должен иметь инструкцию по установке веб-сайта Django, учитывающую различные конфигурации веб-сервера, сервера приложений, обратного прокси и так далее (это не имеет значение, если вы выбрали PaaS). Например, существует множество инструкций "шаг-за-шагом" для различный конфигураций в Документации DigitalOcean по Django.

Выбор хостинг провайдера
------------------------

Существует более 100 хорошо известных хостинг провайдеров, которые либо активно поддерживают, или работают с Django (их список можно увидеть в Django-дружественные хостинги). Данные поставщики предоставляют различные типы окружений (IaaS, PaaS), и различные уровни доступа к вычислительным и сетевым ресурсам, за разную цену.

Некоторые вещи на которые надо обратить внимание при выборе хостинга:

* Насколько требовательным к вычислительным ресурсам является ваш сайт.
* Уровень поддержки горизонтального (добавление большего количества машин) и вертикального масштабирования (переход на более мощное железо), а также стоимость всего этого.
* Где расположены дата-центры и, следовательно, откуда будет более быстрый доступ.
* Время непрерывной работы хостинга, а также время и количество простоя.
* Инструменты, которые предоставляются для управления сайтом — простота и безопасность их использования (SFTP и FTP).
* Встроенные фреймворки для мониторинга вашего сервера.
* Ограничения. Некоторые хостинги могут блокировать некоторые сервисы (например, электронную почту) . Другие предлагают только определённое количество часов "живого времени" за определённую цену, или небольшое количество места для данных.
* Преимущества. Некоторые провайдеры могут предложить бесплатные доменные имена и поддержку сертификатов SSL, которые, в других случаях, должны были бы купить.
* Что будет при истечении времени использования "бесплатного" хостинга, какова "стоимость" миграции на более "дорогие" тарифы и так далее?

Хорошей новостью является то, что для того, чтобы начать существует достаточное количество компаний, которые предоставляют пробные "бесплатные" тарифы типа "evaluation" (для пробы), "developer" (разработка), или "hobbyist" (хобби). Всегда существуют ресурсы с ограниченным окружением, при использовании которых вам надо беспокоиться лишь о том, что они могут быть доступны лишь в течении определённого периода времени. Тем не менее, они являются отличным решением для тестирования сайтов с небольшим трафиком в реальном окружении, а также могут предоставлять простой доступ к платным ресурсам, в случае необходимости. Наиболее популярными провайдерами являются Heroku, Python Anywhere, Amazon Web Services, Microsoft Azure и так далее.

Многие провайдеры имеют "basic" (базовый) тариф, предоставляющий достаточный уровень вычислительной мощности с небольшим количеством ограничений. Digital Ocean и Python Anywhere являются примерами провайдеров, которые предлагают относительно недорогой базовый тариф (от $5 до $10USD в месяц).

**Примечание:** Необходимо помнить, что цена не является единственным критерием выбора. Если ваш сайт успешен, то может так случиться, что масштабирование станет самым важным элементом вашего внимания при выборе услуг хостинга.

Подготовка веб-сайта к публикации
---------------------------------

Скелет сайта был создан при помощи инструментов *django-admin* и *manage.py*, которые настроены таким образом, чтобы сделать разработку проще. Многие настройки файла проекта (определённых в **settings.py**) должны быть изменены перед публикацией сайта, либо из-за вопросов безопасности, либо производительности.

**Примечание:** Общепринятым решением является иметь отдельный файл **settings.py** для публикации, который импортирует важные настройки из внешних файлов, или из переменных окружения. Доступ к данному файлу должен быть ограничен, даже если остальная часть исходного кода доступна в публичном репозитории.

Критически важные настройки файла **settings.py**:

* `DEBUG`. При развёртывании сайта должен быть установлен в `False` (`DEBUG = False`). Тем самым, прекратится вывод важной отладочной информации.
* `SECRET_KEY`. Это большое случайное число, применяемое для защиты от CSRF. Важно, чтобы ключ, используемый в продакшене, не указывался в исходном коде, и/или не запрашивался с другого сервера. Django рекомендует размещать значение ключа либо в переменной окружения, или в файле с доступом только на чтение.
```

# Чтение SECRET_KEY из переменной окружения
import os
SECRET_KEY = os.environ['SECRET_KEY']

#ИЛИ

#Чтение ключа из файла
with open('/etc/secret_key.txt') as f:
    SECRET_KEY = f.read().strip()
```


Давайте изменим приложение *LocalLibrary* таким образом, чтобы читать `SECRET_KEY` и `DEBUG` из переменных окружения, если те определены, иначе использовать значения по умолчанию.

Откройте **/locallibrary/settings.py**, закомментируйте исходное значение `SECRET_KEY` и добавьте новые строки, как указано ниже **жирным**. В течении разработки, никаких переменных окружения определено не было, таким образом будут использоваться значения по умолчанию (не имеет значения какой ключ вы используете в процессе разработки, поскольку при развёртывании проекта вы будете использовать другой).


```python
# SECURITY WARNING: keep the secret key used in production secret!
# SECRET\_KEY = 'cg#p$g+j9tax!#a3cup@1$8obt2\_+&k3q+pmu)5%asj6yjpkag'
import os
SECRET_KEY = os.environ.get('DJANGO\_SECRET\_KEY', 'cg#p$g+j9tax!#a3cup@1$8obt2\_+&k3q+pmu)5%asj6yjpkag')
```


Затем закомментируйте строку с настройкой `DEBUG`, а затем, добавьте новую, указанную ниже.


```python
# SECURITY WARNING: don't run with debug turned on in production!
# DEBUG = True
DEBUG = bool( os.environ.get('DJANGO\_DEBUG', True) )
```


Значение `DEBUG` будет `True` по умолчанию и станет `False`, в том случае, если переменная окружения `DJANGO_DEBUG` будет проинициализирована пустой строкой, то есть, `DJANGO_DEBUG=''`.

**Примечание:** Было бы более понятным, если бы мы могли просто установить и снять с `DJANGO_DEBUG` непосредственно на `True` и `False` , напрямую, а не использовать «любую строку» или «пустую строку» (соответственно). К сожалению, значения переменных среды хранятся как строки Python и единственная строка, которая оценивается как `False` является пустой строкой (например, `bool('')==False`).

Весь перечень настроек для разворачивания вашего сайта находится по ссылке Deployment checklist (Django docs). Кроме того, вы можете получить список настроек, выполнив в терминале команду:


```python
python3 manage.py check --deploy
```

Пример: Установка LocalLibrary на Heroku
----------------------------------------

Данный раздел предоставляет демонстрацию того, как установить *LocalLibrary* на Heroku PaaS cloud.

### Почему Heroku?

Heroku - один из самых продолжительных и популярных облачных сервисов PaaS. Первоначально он поддерживал только приложения Ruby, но теперь его можно использовать для размещения приложений из многих сред программирования, включая Django!

Мы выбираем для использования Heroku по нескольким причинам:

* У Heroku есть свободный уровень, который *действительно* свободен (хотя и с некоторыми ограничениями)
* Как PaaS, Heroku заботится о большой веб-инфраструктуре для нас. Это значительно облегчает работу, потому что вы не беспокоитесь о серверах, балансирах нагрузки, обратных прокси или любой другой веб-инфраструктуре, которую Heroku предоставляет нам под капотом.
* Хотя у этого есть некоторые ограничения, это не повлияет на это конкретное приложение. Например:
    + Heroku предоставляет только недолговечное хранилище, поэтому загруженные пользователем файлы нельзя безопасно хранить на самом Heroku.
    + Свободный уровень будет спать с неактивным веб-приложением, если в течение получаса не будет запросов.После этого сайт может занять несколько секунд, чтобы ответить, когда он проснулся.
    + Свободный уровень ограничивает время, в течение которого ваш сайт работает до определённого количества часов каждый месяц (не включая время, когда сайт «спит»).Это нормально для сайта с низким уровнем использования / демонстрации, но не подходит, если требуется 100% время безотказной работы.
    + Другие ограничения перечислены в Limits (документы Heroku).
* В основном это просто работает, и если вы в конечном итоге полюбите его, масштабирование вашего приложения будет очень простым.

Хотя Heroku идеально подходит для проведения этой демонстрации, она может быть не идеальна для вашего реального сайта. Heroku упрощает настройку и масштабирование за счёт меньшей гибкости и, возможно, обойдётся намного дороже, когда вы выходите из свободного уровня.

### Как работает Heroku?

Heroku запускает сайты Django внутри одного, или более, изолированных друг от друга "Dynos", которые являются виртуальными Unix-контейнерами, предоставляющими необходимое окружение для вашего приложения. Данные dynos полностью изолированы и имеют *эфемерную* файловую систему ("короткоживущая" файловая система, которая полностью очищается и обновляется каждый раз, когда dyno перезапускается). Единственной сущностью, которую предоставляет dynos по умолчанию, является приложение по конфигурации переменных. Heroku внутри себя применяет балансировщик загрузки для распределения веб-трафика среди всех "веб"-dynos. Поскольку dynos изолированы, Heroku может масштабировать приложение горизонтально, просто добавляя больше dynos (хотя, конечно, у вас может появиться необходимость расширить базу данных для обработки дополнительных соединений).

Файловая система эфемерна, поэтому вы не можете напрямую установить необходимые для вашего приложения сервисы (то есть, базы данных, очереди, системы кеширования, хранения, сервисы электронной почты и так далее). Взамен этого, Heroku предоставляет сервисы, доступные как независимые "дополнения" ("add-ons") либо от самой Heroku, или от сторонних разработчиков. В тот момент когда ваше приложение запускается в системе, dynos получает доступ к сервисам, используя информацию, содержащуюся в переменных настройки вашего приложения.

Для того, чтобы выполнить ваше приложение Heroku необходимо иметь возможность установить соответствующее окружение и зависимости, а также понимать как его (приложение) запустить. В случае приложений Django мы предоставляем соответствующую информацию в нескольких текстовых файлах:

* **runtime.txt**: язык программирования и его версию.
* **requirements.txt**: необходимые для Python компоненты, включая Django.
* **Procfile**: Список процессов, которые будут выполнены для старта веб-приложения. Для Django это обычно сервер веб-приложений Gunicorn (скрипт `.wsgi`).
* **wsgi.py**: конфигурация WSGI для вызова нашего приложения Django в окружении Heroku.

Разработчики Developers взаимодействуют с Heroku при помощи специального клиентского приложения/терминала, который сильно похож на bash-скрипт Unix. Оно позволяет вам загружать код, находящийся в git-репозитории, контроллировать выполняемые процессы, смотреть логи, устанавливать конфигурационные переменные и многое другое!

Для того, чтобы заставить ваше приложение работать с Heroku, нам нужно разместить наше веб-приложение в git-репозитории, добавить, перечисленные ранее, файлы, подключить дополнение (add-on) базы данных и выполнить настройки для правильной работы со статическими файлами.

Когда мы выполним все, что необходимо для нашего сайта мы можем создать аккаунт Heroku, получить доступ к клиенту Heroku и использовать его, для установки нашего веб-сайта.

**Примечание:** Инструкции, перечисленные ниже, соответствуют процессу работы с Heroku во время написания данной статьи (английской версии - прим. перев.). Если Heroku значительно изменит этот процесс, вы можете воспользоваться соответствующим описанием: Heroku начало работы с Django.

На этом завершается краткий обзор начала работы с Heroku (более подробное руководство Как работает Heroku).

### Создание репозитория приложения на Github

Heroku тесно интегрирована с системой управления версиями исходного кода **git**, используя её для загрузки / синхронизации любых изменений, которые вы вносите в живую систему. Он делает это, добавляя новый «удалённый» репозиторий heroku с именем heroku, указывающий на репозиторий для вашего источника в облаке Heroku. Во время разработки вы используете **git** для хранения изменений в вашем «master» репозитории. Когда вы хотите развернуть свой сайт, вы синхронизируете свои изменения в репозитории Heroku.

**Примечание:** Если вы привыкли следовать хорошей практике разработки программного обеспечения, вы, вероятно, уже используете git или какую-либо другую систему SCM. Если у вас уже есть git-репозиторий, вы можете пропустить этот шаг.

Существует множество способов работы с git, но одним из самых простых является создание учётной записи в Github, создание репозитория там, а затем синхронизация с ним локально:

1. Посетите https://github.com/ и создайте аккаунт.
2. После входа в систему нажмите ссылку + в верхней панели инструментов и выберите **Новый репозиторий**.
3. Заполните все поля на этой форме. Хотя они не являются обязательными, они настоятельно рекомендуются.
    * Введите имя нового репозитория (например *django\_local\_library*), и комментарий к репозиторию (например "Local Library website written in Django".
    * Нажмите на кнопку **Add .gitignore** и в появившемся списке выберите **Python**.
    * Выберите подходящую вам лицензию из списка **Add license.** Если не знаете для чего это - оставьте как было.
    * Установите галочку напротив ***Initialize this repository with a README**.*
4. Нажмите кнопку **Create repository**, тем самым создав ваш репозиторий.
5. Перейдите на страницу вашего репозитория. Там нажмите на зелёную кнопку **Clone or download**. Скопируйте URL из текстового поля из появившегося диалогового окна (Это будет похоже на: `https://github.com/<your_git_user_id>/django_local_library.git`). Здесь **`<your_git_user_id>`** - это будет ваш id пользователя git.

Когда ваш репозиторий будет создан - загрузите его себе на компьютер, следуя инструкции, описанной ниже:

1. Установите git себе на компьютер (Вы можете найти версию для своей платформы здесь).
2. Откройте командную строку (или терминал) и выполните в нём следующую команду, используя ссылку, которую вы получили с github:

```bash
git clone https://github.com/<your_git_user_id>/django_local_library.git
```

Это создаст подпапку (с содержанием вашего репозитория и именем вашего репозитория) внутри папки, в которой выполнялась команда.
3. Перейдите в эту папку:

```bash
cd django_local_library.git
```


Последний шаг. Нужно скопировать ваше Django-приложение и добавить его файлы в новый репозиторий, используя git:

1. Скопируйте ваше приложение в папку репозитория (все файлы с таким же уровнем, как у **manage.py**, **БЕЗ** папки проекта, в которой эти файлы находятся).
2. Откройте файл с расширением **.gitignore** в текстовом редакторе, вставьте в самый его конец строки, приведённые ниже, а затем сохраните (этот файл "говорит" о файлах, которые не должны быть загружены в git по умолчанию).
```

# Text backup files
*.bak

#Database
*.sqlite3
```

3. Откройте командную строку или терминал и используйте `add` команду с флагом `-A`. Эта команда сохранит изменения в репозиторий:

```bash
git add -A
```

4. Используйте команду `status`, что бы убедиться, что все файлы, которые вы собираетесь добавить верны (вы хотите включить исходные файлы, а не бинарные файлы, временные файлы и т. д.). В консоль выведется что то вроде этого:
```

> git status
On branch master
Your branch is up-to-date with 'origin/master'.
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

        modified:   .gitignore
        new file:   catalog/__init__.py
        ...
        new file:   catalog/migrations/0001_initial.py
        ...
        new file:   templates/registration/password_reset_form.html
```

5. Теперь, зафиксируйте файлы в локальном репозитории:

```bash
git commit -m "First version of application moved into github"
```

6. Синхронизируете свой локальный репозиторий с сайтом Github:
```

git push origin master
```


Когда эти операции завершатся, вернитесь на страницу Github где вы создали свой репозиторий, обновите страницу, и убедитесь, что ваше приложение полностью загружено. При надобности обновить файлы на репозитории - повторите цикл ввода команд add/commit/push.

**Примечание:** Это хороший момент для создания резервной копии вашего «ванильного» проекта — в то время как некоторые изменения, которые мы собираемся сделать в следующих разделах, могут быть полезны для развёртывания на любой платформе (или разработке), которые другие могут не использовать.

*Лучший способ* сделать это - использовать *git* для управления вашими изменениями. С *git* вы можете не только вернуться к определённой старой версии, но и сохранить её в отдельной «ветке» ваших производственных изменений, and cherry-pick - выбрать любые изменения для перемещения между ветвями производства и развития. Изучение Git будет стоить усилий, но это выходит за рамки данной темы. Самый простой способ сделать это - просто скопировать файлы в другое место. Используйте тот подход, который наилучшим образом соответствует вашим знаниям git!

### Обновить приложение для Heroku

В этой части говорится об изменениях, которые мы должны сделать на нашем приложении *LocalLibrary*, что бы оно работало на Heroku. В то время как документация "начало работы с Heroku с инструкциями Django" предполагает, что вы будете использовать Heroku client для запуска локальной среды разработки, наши изменения здесь совместимы с существующим сервером разработки Django и способами работы, которые мы уже узнали.

#### Procfile

Создайте файл с именем `Procfile` (без расширения) в корне нашего GitHub репозитории объявить типы процессов и точки входа приложения. Скопируйте в него следующий текст:
```

web: gunicorn locallibrary.wsgi --log-file -
```


«web:» сообщает Heroku, что это веб динамический и может быть отправлен HTTP-трафик. Процесс, который начнётся в этом динамически, - это gunicorn, который является популярным сервером веб-приложений, который рекомендует Heroku. Мы запускаем Gunicorn, используя конфигурационную информацию в модуле locallibrary.wsgi (созданный с помощью нашего скелета приложения: /locallibrary/wsgi.py).

#### Gunicorn

Gunicorn рекомендуемый http сервер с Django на Heroku (Как указано в Procfile выше). Это чистый python http сервер для WSGI приложений которые могут запускать множество параллельных python процессов в пределах одного динамического (посмотрите Deploying Python applications with Gunicorn для получения большей информации).

Также нам не понадобится *Gunicorn* для обслуживания нашей LocalLibrary приложения в течение разработки, мы установим это так, чтобы он стал частью наших требований к Heroku для настройки на удалённом сервере.

Установка *Gunicorn* локально в командной строке используя пакетный менеджер *pip* (которые мы установили когда настраивали среду разработки):


```bash
pip3 install gunicorn
```


#### Настройка Базы Данных

Мы не можем использовать базу данных SQLite по умолчанию на Heroku, потому что она основана на файлах, и она будет удалена из эфемерной файловой системы каждый раз, когда приложение перезагружается (обычно один раз в день и каждый раз, когда изменяется приложение или его переменные конфигурации ).

Механизм Heroku для обработки этой ситуации заключается в использовании надстройки базы данных и настройке веб-приложения с использованием информации из переменной конфигурации среды, установленной надстройкой. Существует множество опций базы данных, но мы будем использовать hobby уровень в базе данных *postgres Heroku*, поскольку это бесплатно, поддерживается Django и автоматически добавляется в наши новые приложения Heroku при использовании бесплатного уровня динамического плана для хобби.

Информация о подключении базы данных предоставляется на web dyno, используя конфигурационную переменную с именем `DATABASE_URL`. Вместо того, чтобы жёстко кодировать эту информацию в Django, Heroku рекомендует разработчикам использовать dj-database-url пакет для анализа `DATABASE_URL` переменную окружения и автоматически преобразовать её в желаемый формат конфигурации Django. В дополнение к установке пакета *dj-database-url* нам также потребуется установить psycopg2, поскольку Django нуждается в этом, чтобы взаимодействовать с базами данных Postgres.

##### dj-database-url (Django конфигурации базы данных из переменной окружения)

Установите dj-database-url локально, чтобы он стал частью наших требований к настройке Heroku на удалённом сервере:
```

pip3 install dj-database-url
```


##### settings.py

Откройте /locallibrary/settings.py и скопируйте следующую конфигурацию в нижнюю часть файла:
```

# Heroku: Update database configuration from $DATABASE_URL.
import dj_database_url
db_from_env = dj_database_url.config(conn_max_age=500)
DATABASES['default'].update(db_from_env)
```


**Примечание:**

* Мы все ещё будем использовать SQLite во время разработки, поскольку `DATABASE_URL` переменная среды не будет установлена на нашем компьютере разработки.
* Значение `conn_max_age=500` делает соединение постоянным, что намного эффективнее, чем воссоздавать соединение в каждом цикле запросов. Однако это необязательно и при необходимости можно удалить.

##### psycopg2 (Python Postgres database support)

Django нуждается в psycopg2 для работы с базами данных Postgres, и вам нужно будет добавить это в файл требований.txt для Heroku, чтобы установить это на удалённом сервере (как описано в разделе требований ниже).

Django будет использовать нашу базу данных SQLite локально по умолчанию, поскольку переменная среды DATABASE\_URL не задана в нашей локальной среде. Если вы хотите полностью перейти на Postgres и использовать нашу бесплатную базу данных Heroku для разработки и производства, то вы можете. Например, чтобы установить psycopg2 и его зависимости локально в системе на базе Linux, вы должны использовать следующие команды bash / terminal:


```bash
sudo apt-get install python-pip python-dev libpq-dev postgresql postgresql-contrib
pip3 install psycopg2
```


Инструкции по установке для других платформ можно найти на веб-сайте psycopg2.

Однако вам не нужно это делать - вам не нужно, чтобы PostGreSQL был активным на локальном компьютере, если вы передаёте его в Heroku в качестве требования в файле требований.txt (см. Ниже).

#### Обслуживание статических файлов в производстве

Во время разработки мы использовали Django и веб-сервер разработки Django для обслуживания наших статических файлов (CSS, JavaScript и т. Д.). В производственной среде вместо этого мы обычно обслуживаем статические файлы из сети доставки контента (CDN) или веб-сервера.

**Примечание:** Обслуживание статических файлов через Django / веб-приложение неэффективно, потому что запросы должны проходить через ненужный дополнительный код (Django), а не обрабатываться непосредственно веб-сервером или полностью отдельным CDN. Хотя это не имеет значения для местного использования во время разработки, это будет иметь значительное влияние на производительность, если мы будем использовать тот же подход в производстве.

Чтобы упростить размещение статических файлов отдельно от веб-приложения Django, Django предоставляет средство сбора данных для сбора этих файлов для развёртывания (имеется переменная параметров, определяющая, где файлы должны собираться при запуске collectstatic). Шаблоны Django относятся к месту размещения статических файлов относительно переменной параметров (STATIC\_URL), так что это можно изменить, если статические файлы перемещаются на другой хост / сервер.

Соответствующими параметрами настройки являются:

 STATIC\_URL: это базовое расположение URL, из которого будут загружены статические файлы, например, на CDN. Это используется для переменной статического шаблона, доступ к которой осуществляется в нашем базовом шаблоне (см. Учебник по Django Part 5: Создание нашей домашней страницы).
 STATIC\_ROOT: Это абсолютный путь к каталогу, в котором инструмент «collectstatic» Django будет собирать любые статические файлы, упомянутые в наших шаблонах. После их сбора они затем могут быть загружены в группу, где бы файлы не размещались.
 STATICFILES\_DIRS: В этом списке перечислены дополнительные каталоги, в которых инструмент коллективного поиска Django должен искать статические файлы.

##### settings.py

Откройте /locallibrary/settings.py и скопируйте следующую конфигурацию в нижнюю часть файла. BASE\_DIR уже должен быть определён в вашем файле (STATIC\_URL, возможно, уже был определён в файле, когда он был создан. В то время как это не причинит вреда, вы также можете удалить дублируемую предыдущую ссылку).
```

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.10/howto/static-files/

# The absolute path to the directory where collectstatic will collect static files for deployment.
STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')

# The URL to use when referring to static files (where they will be served from)
STATIC_URL = '/static/'
```


Фактически мы будем делать файл, используя библиотеку WhiteNoise, которую мы устанавливаем и настраиваем в следующем разделе.

Для получения дополнительной информации см. Django и Static Assets (документы Heroku).

#### WhiteNoise

Существует множество способов обслуживания статических файлов на производстве (мы видели соответствующие настройки Django в предыдущих разделах). Heroku рекомендует использовать проект WhiteNoise для обслуживания статических активов непосредственно из Gunicorn в производстве.

**Примечание:** Heroku автоматически вызывает collectstatic и готовит ваши статические файлы для использования WhiteNoise после того, как он загрузит ваше приложение. Посмотрите WhiteNoise документацию для объяснения того, как она работает, и почему реализация является относительно эффективным методом для обслуживания этих файлов.

Шаги по настройке *WhiteNoise* для использования в проекте:

##### Установка WhiteNoise

Установите *WhiteNoise* локально, используя следующую команду:
```

pip3 install whitenoise
```


##### settings.py

Чтобы установить WhiteNoise в приложение Django, откройте /locallibrary/settings.py, найдите параметр MIDDLEWARE и добавьте WhiteNoiseMiddleware в верхней части списка, чуть ниже SecurityMiddleware:
```

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'whitenoise.middleware.WhiteNoiseMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
```


При желании вы можете уменьшить размер статических файлов при их обслуживании (это более эффективно). Просто добавьте следующее в конец /locallibrary/settings.py:
```

# Simplified static file serving.
# https://warehouse.python.org/project/whitenoise/
STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'
```


#### Requirements

Требования Python вашего веб-приложения должны храниться в файле requirements.txt в корневом каталоге вашего репозитория. После этого Heroku автоматически установит их при восстановлении вашей среды. Вы можете создать этот файл с помощью pip в командной строке (запустите в корне repo):


```bash
pip3 freeze > requirements.txt
```


После установки всех разных зависимостей выше, файл requirements.txt должен иметь *по меньшей мере* эти перечисленные элементы (хотя номера версий могут отличаться). Удалите любые другие зависимости, не перечисленные ниже, если вы явно не добавили их для этого приложения.
```

dj-database-url==0.4.1
Django==1.10.2
gunicorn==19.6.0
psycopg2==2.6.2
whitenoise==3.2.2
```


**Примечание:** Убедитесь, что строка **psycopg2**, подобная приведённой выше, присутствует! Даже если вы не установили это локально, вы должны добавить это в **requirements.txt**.

#### Среда выполнения

Файл **runtime.txt**, если определён, говорит Heroku, какой язык программирования использовать. Создайте файл в корне репо и добавьте следующий текст:
```

python-3.5.2
```


**Примечание:** Heroku поддерживает только небольшое количество Python runtimes. (на момент написания статьи, в том числе и выше). Heroku будет использовать поддерживаемую среду выполнения независимо от значения, указанного в этом файле.

#### Сохраните изменения в Github и перепроверьте

Далее мы сохраним все наши изменения в Github. В терминале (whist внутри нашего репозитория) введите следующие команды:


```python
git add -A
git commit -m "Added files and changes required for deployment to heroku"
git push origin master
```


Прежде чем продолжить, дайте возможность проверить сайт снова локально и убедиться, что это не повлияло ни на одно из наших изменений выше. Запустите веб-сервер разработки как обычно, а затем проверьте, работает ли сайт, как вы ожидаете в своём браузере.


```bash
python3 manage.py runserver
```


Теперь мы должны быть готовы начать развёртывание LocalLibrary на Heroku.

### Получить аккаунт в heroku

Чтобы начать использовать Heroku, вам сначала нужно создать учётную запись:

* Перейдите www.heroku.com и нажмите **SIGN UP FOR FREE** кнопку.
* Введите ваши данные, а затем нажмите **CREATE FREE ACCOUNT**. Вам будет предложено проверить свою учётную запись по адресу электронной почты для регистрации.
* Нажмите ссылку активации учётной записи в электронной почте для регистрации. Вы вернётесь в свою учётную запись в веб-браузере.
* Введите свой пароль и нажмите **SET PASSWORD AND LOGIN**.
* Затем вы войдёте в систему и попадёте в приборную панель Heroku: https://dashboard.heroku.com/apps.
### Установка клиента

Загрузите и установите клиент Heroku, следуя инструкциям Heroku здесь.

После установки клиента вам будут доступны команды. Например, чтобы получить справку о клиенте:


```bash
heroku help
```

### Создание и загрузка веб-сайта

Чтобы создать приложение, мы запускаем команду «create» в корневом каталоге нашего репозитория. Это создаёт git remote («указатель на удалённый репозиторий»), названный heroku в нашей локальной среде git.


```bash
heroku create
```


**Примечание:** вы можете назвать удалённый, если хотите, указав значение после «create». Если вы этого не сделаете, вы получите случайное имя. Имя используется в URL-адресе по умолчанию.

Затем мы можем подтолкнуть наше приложение в репозиторий heroku как показано ниже. Это позволит загрузить приложение, упаковать его в dyno, запустить collectstatic, и запустить сам сайт.


```bash
git push heroku master
```


Если нам повезёт, приложение «заработает» на сайте, но оно не будет работать должным образом, потому что мы не настроили таблицы базы данных для использования нашим приложением. Для этого нам нужно использовать команду `heroku run` и запустить "one off dyno" для выполнения операции переноса. Введите в терминал следующую команду:


```bash
heroku run python manage.py migrate
```


Мы также должны будем иметь возможность добавлять книги и авторов, поэтому давайте также создадим суперпользователя, снова используя одноразовый динамический режим:


```bash
heroku run python manage.py createsuperuser
```


Как только это будет завершено, мы можем посмотреть сайт. Он должен работать, хотя в нем ещё нет книг. Чтобы открыть браузер на новом веб-сайте, используйте команду:


```bash
heroku open
```


Создайте несколько книг на сайте администратора и проверьте, работает ли сайт, как вы ожидаете.

### Управление аддонами

Вы можете проверить дополнения в своём приложении, используя `heroku addons` команду. Это будет список всех аддонов, их ценовая категория и состояние.


```bash
>heroku addons

Add-on                                     Plan       Price  State
─────────────────────────────────────────  ─────────  ─────  ───────
heroku-postgresql (postgresql-flat-26536)  hobby-dev  free   created
 └─ as DATABASE
```


Здесь мы видим, что у нас есть только одна надстройка, база данных postgres SQL. Это бесплатно и автоматически создаётся при создании приложения. Вы можете открыть веб-страницу, чтобы более подробно изучить надстройку базы данных (или любое другое дополнение), используя следующую команду:


```bash
heroku addons:open heroku-postgresql
```


Другие команды позволяют создавать, уничтожать, обновлять и понижать аддоны (используя аналогичный синтаксис для открытия). Для получения дополнительной информации см. Managing Add-ons (Heroku docs).

### Настройка переменных конфигурации

Вы можете проверить конфигурационные переменные для сайта, используя команду `heroku config`. Ниже вы можете видеть, что у нас есть только одна переменная `DATABASE_URL` , используемая для настройки нашей базы данных.


```bash
>heroku config

=== locallibrary Config Vars
DATABASE_URL: postgres://uzfnbcyxidzgrl:j2jkUFDF6OGGqxkgg7Hk3ilbZI@ec2-54-243-201-144.compute-1.amazonaws.com:5432/dbftm4qgh3kda3
```


Если вы вспомните из раздела, посвящённого getting the website ready to publish, мы должны установить переменные среды для `DJANGO_SECRET_KEY` и `DJANGO_DEBUG`. Давайте сделаем это сейчас.

**Примечание:** Секретный ключ должен быть действительно секретным! Один из способов генерации нового ключа - создать новый проект Django (`django-admin startproject someprojectname`) а затем получить ключ, который генерируется для вас в его **settings.py**.

Мы устанавливаем `DJANGO_SECRET_KEY` используя команду `config:set` (как показано ниже). Не забудьте использовать свой секретный ключ!


```bash
>heroku config:set DJANGO\_SECRET\_KEY=eu09(ilk6@4sfdofb=b_2ht@vad*$ehh9-)3u_83+y%(+phh&=

Setting DJANGO_SECRET_KEY and restarting locallibrary... done, v7
DJANGO_SECRET_KEY: eu09(ilk6@4sfdofb=b_2ht@vad*$ehh9-)3u_83+y%(+phh
```


Аналогично мы устанавливаем `DJANGO_DEBUG`:


```bash
>heroku config:set DJANGO\_DEBUG=''

Setting DJANGO_DEBUG and restarting locallibrary... done, v8
```


Если вы посетите веб-сайт сейчас, вы получите ошибку "Bad request" , потому что в ALLOWED\_HOSTS надо внести параметры, если у вас `DEBUG=False` (в качестве меры безопасности). Откройте **/locallibrary/settings.py** и измените `ALLOWED_HOSTS` для включения вашего базового URL-адреса приложения (например, 'locallibrary1234.herokuapp.com') URL, который вы обычно используете на локальном сервере разработки.


```python
ALLOWED_HOSTS = ['<your app URL without the https:// prefix>.herokuapp.com','127.0.0.1']
# For example:
# ALLOWED\_HOSTS = ['fathomless-scrubland-30645.herokuapp.com','127.0.0.1']
```


Затем сохраните настройки и передайте их в репозиторий Github и в Heroku:


```bash
git add -A
git commit -m 'Update ALLOWED\_HOSTS with site and development server URL'
git push origin master
git push heroku master
```


**Примечание:** После завершения обновления сайта на Heroku введите URL-адрес, который не существует (например, **/catalog/doesnotexist/**). Раньше это отображало бы подробную страницу отладки, но теперь вы должны просто увидеть простую страницу «Не найдено».

### Отладка

Клиент Heroku предоставляет несколько инструментов для отладки:


```bash
heroku logs  # Show current logs
heroku logs --tail # Show current logs and keep updating with any new results
heroku config:set DEBUG\_COLLECTSTATIC=1 # Add additional logging for collectstatic (this tool is run automatically during a build)
heroku ps   #Display dyno status
```


Если вам нужно больше информации, предоставленной здесь, вам нужно будет начать изучать Django Logging.

Итоги
-----

 Это конец этого руководства по настройке и развёртывании приложений Django, а также серия руководств по работе с Django. Надеемся, вы нашли их полезными. Вы можете проверить полностью проработанную версию по исходникам на Github.
 Следующий шаг - прочитать наши последние несколько статей, а затем завершить оценочную задачу.

Смотрите также
--------------

* Развёртывание Django (Django docs)
    + Контрольный список развёртывания (Django docs)
    + Развёртывание статических файлов (Django docs)
    + Как развернуть с WSGI (Django docs)
    + Как использовать Django с Apache и mod\_wsgi (Django docs)
    + Как использовать Django с Gunicorn (Django docs)
* Heroku
    + Настройка Django приложений для Heroku (Heroku docs)
    + Начало работы в Heroku с Django (Heroku docs)
    + Django and Static Assets (Heroku docs)
    + Параллелизм и подключение к базе данных в Django (Heroku docs)
    + Как Heroku работает (Heroku docs)
    + Dynos and the Dyno Manager (Heroku docs)
    + Настройка и Config Vars (Heroku docs)
    + Ограничения (Heroku docs)
    + Развёртывание Python applications с Gunicorn (Heroku docs)
    + Развёртывание Python и Django apps в Heroku (Heroku docs)
    + Ещё о Heroku Django docs
* Digital Ocean
    + Как обслуживать Django Applications вместе с uWSGI и Nginx в Ubuntu 16.04
    + Другие документы Digital Ocean Django
* Назад
* Обзор: Django
* Далее