Heroku как запустить приложение

7

Heroku — облачная платформа для хостинга приложений

Heroku — удобная платформа для разворачивания контейнерных приложений. Что такое облачная платформа и что такое контейнеры — далее.

Что такое облачная платформа. Как это работает?

Что такое облако? Облако — много-много железных серверов, находящихся где-то не важно где, и ухаживают за ними какие-то другие люди.

Но нам то важно то, как мы можем этим пользоваться, а пользоваться можно вот как:

Хостер виртуальную машину и даёт нам доступ к ней. Мы можем туда установить операционную систему и делать в этой операционной системе всё что захотим.

То есть нам дают собаку, но кормить её не надо, её кормят другие.

Пример такого хостинга: RU VDS. Оплата по количеству часов

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

Теперь мы оставляем инструкции — какого веса должна быть собака, какой длинны шерсть, насколько весёлая мордашка. А мы теперь можем сами выгуливать и играть с ней, когда захотим.

Пример: Heroku. Оплата по часам, есть бесплатный тариф

Хостер уже имеет у себя какие-то маленькие приложения и компоненты. Всё, что остаётся сделать нам — правильно из всего этого конструктора собрать своё приложение.

Мы составляем список игр, в которые мы хотим поиграть с собакой и нам под каждую игру дают отдельную собаку.

Пример: Firebase. Оплата по количеству запросов, есть бесплатный тариф

Почему Heroku?

1. Бесплатно: 570 часов работы каждый месяц (19 часов/день), 10k строчек в БД (PostgreSQL) и кое-что ещё — достаточно неплохо для небольшого проекта
2. Нам не надо думать об операционной системе, о всяких страшных вещах настройках
3. Очень простая настройка контейнеров. Мы можем написать приложение на почти любом языке, и одной строчкой в Procfile рассказать, как конкретно ваше приложение нужно запустить
4. Можно спокойно запустить приложение на своём компьютере или другом сервере, ведь всё, что относится к Heroku — Procfile , всё остальное — ваше приложение
5. Можно настроить так, что приложение само будет обновляться, нам останется только код писать
6. При регистрации не нужно никаких кредитных карточек

Для какого рода приложений хорошо:

• Боты
• Чаты
• Что-то, что будет работать не часто и по запросу

Для чего можно использовать, но не рекомендуется:

• Блоги или статические сайты — тут можно использовать какой-нибудь uCoz или Tilda
• Бекэнд для мобильных приложений — тут лучше посмотреть в сторону Firebase, там для мобилок много интересного
• Сервер для чего-то, что должно работать 24/7, например стриминговый сервис для хомячков — тот же RU VDS. Специально для python приложений есть такая вещь как PythonAnywhere

Некоторые тонкости работы

И так, как же работает Heroku.

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

Плюсы такого подхода для хостера — экономия времени работы железных серверов, плюсы для нас — можно растянуть удовольствие чуть дольше)

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

Так же платформа имеет buildpack для разных языков (Node.js, Python, Ruby, PHP, Java, Clojure, Scala, Go). Это всё из бесплатных buildpack’ов, так же вы можете “докупить” под что-то относительно экзотическое, например MySQL базу данных или RabbitMQ очередь для своего проекта. Ну или, например, C++ среду для какой-то своей очень очень ресурсоёмкой задачи.

Buildpack — полуфабрикат для какого-то контейнера. В хероку в этих buildpack’ах спрятана разная магия по установке интерпретаторов языков, установке зависимостей и разного интересного. Всё, что нам нужно знать — что они бесплатные и делают грязную работу за нас, нам нужно только подкинуть туда свои исходники и немного настроить с помощью файла Procfile .

Но часто вполне хватает Python + PostgreSQL.

Перейдём к развёртыванию!

Для примера возьмём вот такое сферическое приложение в вакууме:

• Наше приложение наприсано на Python
• Мы используем Flask
• Нам нужна БД
• Приложение является ботом
• Все исходники приложения хранятся на GitHub

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

Для начала потренеруемся на кошечках

Давайте сначала определимся, где мы находимся. Все последующие инструкции работают в 2 разных средах: сайт Heroku, консоль. Консоль может быть либо стандартная в Linux, либо PowerShell, если Вы работаете из под Windows.

1. Запустите свою консоль
2. Введите pip3 —version

Если система сказала что-то плохое, а не pip X.X.X from XXX , то есть несколько вариантов развития событий. Давайте пройдёмся по каждому:

1. У вас в системе есть просто pip => команда должна быть pip —version
2. У вас в системе только python установлен “глобально” => команда должна быть такая: python -m pip —version
3. У вас в системе в принципе python установлен неправильно => обратитесь к хелпдеску

Регистрация

Для того, чтобы воспользоваться чем-то, нужно зарегистрироваться.

1. Заходим на страницу регистрации
2. Первые 3 поля — обязательные для честного заполнения. Остальное — для статистики внутри хероку. Но компанией вы можете назвать свою команду, себя представить студентом, а любимый язык выбрать по вкусу.
3. Не забудьте прочитать Правила!

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

После регистрации и подтверждения email адреса нас должно впустить в Dashboard. Это панель управления. Тут будут находится все наши приложения.

1. Теперь мы можем нажать на кнопку “New” и выбрать “Create New App”
2. Каким-то образом называем наше приложение. Это нужно потому, что потом наше приложение будет доступно по адресу https://<appname>.herokuapp.com , ну и приложение должно иметь какое-то уникальное имя.
3. Страна развёртывания — где будет ваше приложение храниться, в каком датацентре. На самом деле интернет не такой уж и большой, но от нас ближе Европа, так что давайте выберем её.

Нас сразу перекинуло на вкладку “Deploy”. Так что продолжим

Развёртывание

Способов передачи приложения серверам хероку очень много — и ручные, и специальные git репозитории, и Docker образы. Нам всё это не интересно, потому что это всё сложные технологии для бородатых дядек, которые едят на завтрак материнские платы, запивая смуззи из пива.

Мы люди простые, нам хочется чтобы всё делалось автоматом, поэтому мы привяжем GitHub-репозиторий!

1. Выбираем вкладку “GitHub”
2. Проходим процесс “привязки” GitHub-аккаунта
3. Находим свой репозиторий с помощью специального поля поиска
4. Нажимаем кнопку “Connect”

Теперь давайте включим автоматическое развёртывание. Для этого в секции “Automatic deploys” нажимаем кнопку “Enable Automatic Deploys”.

Всё! Теперь когда мы даем какой-то коммит в master ветку нашего репозитория хероку автоматически будет забирать все исходники из репозитория и разворачивать приложение.

Инструкции к разворачиванию

— А какой язык ты используешь, расскажи?

На самом деле сейчас Heroku не сможет ничего развернуть. Потому что он даже не знает, как к нашему приложению подойти: может это Ruby приложение, может вообще Java!

Как я уже говорил, у Heroku есть разные buildpack’и для разных языков и платформ. Чтобы узнать, какой из этих buildpack’ов использовать, Heroku полагается на файлы-идикаторы.

Для Ruby таким файлом будет Gemfile , для Node.js — package.json . А в нашем случае (Python) файлом-индикатором является requirements.txt

Давайте сделаем файл-индикатор. В файле requirements.txt по договорённости всех разработчиков должны храниться названия и версии всех пакетов, которые необходимы для работы приложения. Создать этот файл очень просто:

Теперь если мы захотим запустить наш сервер на другом компьютере, мы выполним следующую команду и pip сам установит все необходимое.

И всё, у него теперь всё на месте и всё должно работать.

Пример файла requirements.txt можете посмотреть здесь.

— А как мне теперь всё это запустить?

Теперь хероку знает как к этому делу подступиться, но он не знает, как запустить наше приложение. Да и вообще, об этом пока знаем только мы.

Для начала нам нужно установить сервер, который будет запускать наше Flask приложение. Для этого мы установим специальный сервер gunicorn:

Теперь осталось рассказать, как конкретно запускать наш сервер.

1. Создадим файл Procfile с вот таким содержимым:
2. Закомитим и запушим этот файл в GitHub

А теперь немного о том, что содержится в нашем Procfile:

• web: — мы говорим, что эта команда должна запускаться при запросе на сайт https://<appname>.herokuapp.com
• gunicorn — запускаем uWSGI сервер
• app:flask_app — в python-модуле app в переменной flask_app хранится наше приложение
• —log-level=debug —log-file=- — настройки логирования. Чтобы в случае падения хоть где-то было написано почему упало.

А как же БД?

Теперь давайте к нашему приложению подключим базу данных.

1. Зайдём во вкладку “Resources”
2. Введём там в поле поиска “heroku”
3. Выбираем “Heroku Postgres”
4. Подтверждаем подключение модуля к нашему приложению

Всё, круть! Нам доступна БД на 10k строк!

Но нам нужно, чтобы наше приложение подключилось к ней. Если мы перейдём во вкладку “Settings” и нажмём на кнопочку “Reveal Config Vars”, то увидим там строчку

Эта строчка может меняться. В зависимости от того как захочет Heroku, может через день, может через неделю, а может им понадобится менять её хоть каждые 5 минут. Поэтому нам не важна сама строчка, нам эта строчка нужна внутри приложения.

Всё! Теперь мы умеем забирать настройки для приложения из переменных окружения. Вот как это делается у нас.

Теперь мы каким-то магическим образом по этому адресу подключаемся к БД. Например вот так.

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

Что же теперь?

А теперь вот вам несколько советов: 1.Все настройки (токены, пароли администраторов, любые данные для входа куда-нибудь) храните в переменных окуржения, а не в коде.

1. Поиграйтесь немного с тем, что найдёте в интерфейсе Heroku. Например, вы можете полностью удалить все данные в БД, посмотреть логи своего приложения, использовать вместо appname.herokuapp.com свой собственный домен, вручную достать исходники из GitHub или принудительно перезапустить приложение.
2. Не нажимайте на что-то, где не написано “free” или “0 $/month”. Конечно ничего сильно страшного не случится, ведь они сначала потребуют деньги, но отключать потом все эти платные функции — дело не очень приятное.

Ещё немного о возможностях платформы

Можно выполнять какие-то команды по расписанию. Вещь работает достаточно стабильно, хотя сами разработчики предупреждают, что иногда может давать осечки… Работает она так же как и простое приложение — как только запустилось, начались вычитываться месячные часы работы, как только закончило что-то выполнять — всё, списываться ничего не будет.

Ещё можно запускать “worker” процессы — которые будут работать постоянно. Но эти процессы будут так же есть часы в месяц, которые можно было использовать для работы основного приложения. Поэтому эта фича просто достойна упоминаний.

Как развернуть проект на Heroku

O днажды, когда вы закончите разработку проекта, вам понадобится отправить его на продакшн. То есть, найти хостинг, залить туда файлы, добавить настройки, запустить сайт и так далее. Чтобы вы потом не бегали с горящей задницей, не зная что делать, я подготовил полноценную инструкцию, которая решит все эти проблемы.

Сегодня мы будем деплоить проект, написанный на Svelte, в облачную PaaS-платформу – Heroku. Будем называть её просто “хостинг”.

Начнем с создания базовой структуры, то есть с чистого листа.

За основу возьмем этот бойлерплейт: svelte-boilerplate

Склонируем проект в нужную папку.

Перейдем в директорию svelte и запустим команду для установки зависимостей

Если всё прошло успешно, сайт будет доступен по ссылке, откроем её в браузере.

Теперь попробуем собрать проект. По идее у нас должна создаться папка public, в которой будут html, css и js файлы, они будут сжаты и оптимизированы, их мы и будем использовать на продакшне.

Команда для сборки проекта

Итог должен быть таким:

Подготовка сервера

Скажу сразу: запускать проект на хостинге через команду npm run start:dev плохая идея. Вот почему:

1. Файлы и картинки не будут оптимизированы и сжаты
2. Сервер для разработки не стабилен и не предназначен для больших нагрузок
3. Нет возможности добавить настройки для сервера
4. И куча других проблем.

Мы же сделаем всё как надо и запустим наш проект на простеньком Express.js сервере.

В корне проекта создадим файл server.js, в него поместим код ниже

Главное – указать переменную с портом, чтобы Heroku мог подставить нужный порт при старте.

А так сервер очень простой, при запуске он всего лишь будет рендерить index.html из папки public. Проверим

В консоли должно появиться сообщение об успешном старте

И если перейти по ссылке, мы увидим стартовую страницу сайта.

С файлами для продакшна разобрались, сервер подготовили, далее займемся настройкой Heroku CLI.

Установка и настройка Heroku CLI

Heroku CLI – это консольная утилита для удаленной работы с Heroku.

Начнем с установки. У них на сайте есть подробная инструкция . Идём читать.

Обычно раздела “Download and install” достаточно

Пробуем установить. Если всё нормально, наберём в консоли команду heroku. Результат должен быть примерно таким

Это говорит нам о том, что Heroku доступен и готов к работе. Попробуем с помощью него запустить наш сервер. Так же в корне проекта, где находится файл server.js, запустим команду

У меня результат такой. Сайт работает

Далее в корне проекта нужно создать Procfile. Он поможет определить, как запустить приложение. Heroku в первую очередь будет искать именно его. Если в проекте отсутствует этот файл, heroku попытается запустить веб-сервер с помощью стартового скрипта (npm start) в вашем package.json.

Вставим кусок кода в Procfile

И попытаемся снова запустить сайт

На этот раз никаких ошибок в консоли нет.

Ну и последним шагом добавим в package.json команду для сборки проекта на стороне heroku

Подготовка проекта

Ну вот мы и подошли к самому главному – будем отправлять всё, что получилось, на хостинг heroku.

Для этого есть два способа:

1. Залить проект в репозиторий heroku, и он уже сам добавит нужные настройки
2. Залить на github и в настройках heroku указать ссылку

Мы пойдем по второму пути.

Надеюсь, рассказывать, как заливать проект на github, не нужно?
Я залил сюда.

Если вам всё же интересно почитать про первый способ, вот ссылка. Он особо ничем не отличается, разве что тем, что код будет храниться на стороне heroku.

Возможно, у вас нет аккаунта на github, и этот способ окажется даже проще. Пробуйте.

Настройка хостинга

Когда залили проект на github, переходим в дашборду heroku , чтобы создать новый проект.

На этой странице будут находиться все ваши проекты. Чтобы создать новый, сверху справа нажмите на кнопку New, далее на Create new app. Откроется новая страница, на которой нужно ввести данные о новом проекте.

После завершения проект будет создан и нас перенаправит во вкладку Deploy. Там сразу перейдем в настройки github

Находим нужный нам репозиторий и коннектим

Далее выберем ветку, за которой будет наблюдать heroku, и нажмём на большую тёмную кнопку.

Теперь, когда вы зальёте что-то в ветку master, heroku будет подтягивать изменения и обновлять сайт.

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

После того как сборка завершится (процесс можно отслеживать во вкладке Activity), нажимаем на кнопку Open app

Откроется новая вкладка, и мы снова увидим стартовую страницу нашего сайта, но уже на хостинге heroku. Сайт готов к продакшну, осталось только купить домен. Купить можно тут.
Поменять во вкладке Settings, в секции Domains

В этой же вкладке вы можете настраивать env переменные, устанавливать различные плагины и т.д. Советую изучить все вкладки, чтобы иметь полное представление о возможностях этого хостинга.

Я считаю, что цель статьи была выполнена и можно заканчивать. По всем остальным вопросам обращайтесь в официальную документацию.

Мега-Учебник Flask, Часть XVIII: Развертывание на Heroku

Туда Сюда

Это восемнадцатая часть серии Мега-учебников Flask, в которой я собираюсь развернуть микроблог на облачной платформе Heroku.

Под спойлером приведен список всех статей этой серии 2018 года.

Примечание 1: Если вы ищете старые версии данного курса, это здесь.

Примечание 2: Если вдруг Вы захотели бы выступить в поддержку моей(Мигеля) работы, или просто не имеете терпения дожидаться статьи неделю, я (Мигель Гринберг)предлагаю полную версию данного руководства(на английском языке) в виде электронной книги или видео. Для получения более подробной информации посетите learn.miguelgrinberg.com.

В предыдущей статье я показал вам «традиционный» способ размещения приложения Python, и представил вам два реальных примера развертывания на Linux-серверах. Если вы не на «ТЫ» системой Linux, то вероятно вам показалось, что объем затраченных усилий на такое развертывание был слегка больше ожидаемого, и, безусловно, должен быть более простой способ.

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

Многие облачные хостинг-провайдеры предлагают управляемую платформу, на которой можно запускать веб-приложения. Все, что вам нужно предоставить, чтобы ваше приложение было развернуто на этих платформах, — это фактическое приложение, потому что аппаратное обеспечение, операционная система, интерпретаторы языка сценариев, база данных и т.д. управляются службой. Этот тип сервиса называется Platform as a Service или PaaS.

Звучит слишком хорошо, чтобы быть правдой, не так ли?

Я буду развертывать Microblog на Heroku, популярном облачном сервисе, который также очень удобен для приложений Python. Я выбрал Heroku не только потому, что он популярен, но и потому, что у него есть бесплатный уровень обслуживания, который позволит вам следовать за мной и выполнять полное развертывание, не тратя никаких денег.

Хостинг на Heroku

Heroku, одна из первых облачных платформ, которая появилась в июне 2007 года и изначально поддерживала только язык программирования Ruby, но на данный момент список поддерживаемых языков также включает в себя Java, Node.js, Scala, Clojure, Go, PHP и конечно Python.

Развертывание веб-приложения в Heroku выполняется с помощью средства управления версиями git , поэтому приложение должно находиться в репозитории git. Heroku ищет файл под названием Procfile в корневом каталоге приложения для получения инструкций о том, как запустить приложение. Для проектов Python, Heroku потребуется файл requirements.txtфайл со списком всех зависимостей модулей, которые необходимо установить. После того, как приложение будет загружено на серверы Heroku через git, вы, по сути всё сделали, и нужно просто подождать несколько секунд, пока приложение появится в сети. Это действительно так просто.

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

Готовы попробовать Heroku? Давайте начнем!

Создание учетной записи Heroku

Прежде чем вы сможете завершить развертывание в Heroku, вам нужно получить учетную запись. Поэтому посетите сайт heroku.com и создайте бесплатную учетную запись. После того, как зарегестрируетесь и войдёте в Heroku, вы получите доступ к панели мониторинга, где будут перечислены все ваши приложения.

Установка Heroku CLI

Heroku предоставляет командную строку для взаимодействия с службой под названием Heroku CLI, доступной для Windows, Mac OS X и Linux. Документация содержит инструкции по установке для всех поддерживаемых платформ. Установите его в своей системе, если вы планируете развертывать приложение для тестирования службы.

Первое, что вы должны сделать после установки CLI, это войти в ваш Heroku аккаунт:

Heroku CLI попросит вас ввести свой адрес электронной почты и пароль учетной записи. Ваш аутентифицированный статус будет сохранен в последующих командах.

Настройка Git

Инструмент git является основой для развертывания приложений в Heroku, поэтому вы должны установить его в своей системе, если у вас его еще нет. Если у вас нет пакета, доступного для вашей операционной системы, вы можете посетить сайт git для загрузки установщика.

Есть множество причин использовать git для ваших проектов. Если вы планируете развертывание в Heroku, то у вас появилась еще одна, потому что для развертывания в Heroku ваше приложение должно быть в репозитории git . Если вы собираетесь выполнить тестовое развертывание для Микроблога, вы можете клонировать приложение из GitHub:

Команда git checkout выбирает конкретную точку фиксации приложения в его истории, соответствующей этой главе.

Если вы предпочитаете работать с собственным кодом, а не с моим, вы можете преобразовать свой собственный проект в репозиторий git , запустив git init . в каталоге верхнего уровня (обратите внимание на точку после init , которая является инструкцией для git, что вы хотите создать репозиторий в текущем каталоге).

Создание приложения Heroku

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

Heroku требует, чтобы приложения имели уникальное имя. Имя flask-microblog , которое я использовал выше, не будет вам доступно, потому что я уже использую его, поэтому вам нужно будет выбрать другое для вашего развертывания.

На выходе этой команды мы получим URL, который Heroku назначил приложению, а также его репозиторий git. Ваш локальный репозиторий git уже будет иметь настройку связи с внешним(remote), называемым heroku . Вы можете убедиться, что он существует с помощью команды git remote :

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

Эфемерная файловая система

Платформа Heroku отличается от других платформ развертывания тем, что в ней реализована ephemeral файловая система, работающая на виртуальной платформе. Что это значит? Это означает, что в любое время Heroku может сбросить виртуальный сервер, что приведет к возврату вашего сервера в чистое состояние. Нельзя предположить, что любые данные, которые вы сохраняете в файловой системе, будут сохраняться, и на самом деле, Heroku очень часто перерабатывает серверы.

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

• Компонент SQLite database engine по умолчанию записывает данные в файл на диске
• Журналы для приложения записываются в файловую систему
• Скомпилированные хранилища языковых переводов также хранятся в локальных файлах

В следующих разделах будут рассмотрены эти три направления.

Работа с базой данных Heroku Postgres

Чтобы решить первую проблему, я перейду на другой механизм базы данных. В главе 17 вы видели, как я использую базу данных MySQL, чтобы повысить надежность развертывания Ubuntu. У Heroku есть собственное предложение базы данных, основанное на Postgres, поэтому я собираюсь переключиться на него, чтобы избежать проблемы хранения SQLite на основе файлов.

Базы данных для приложений Heroku снабжаются одним и тем же CLI Heroku. В этом случае я собираюсь создать базу данных на бесплатном(free) уровне:

URL-адрес вновь созданной базы данных хранится в переменной среды DATABASE_UR L, которая будет доступна при запуске приложения. Это очень удобно, так как приложение уже ищет URL базы данных в этой переменной.

Ведение журнала в stdout

Heroku ожидает, что приложения будут совершать ввод/вывод непосредственно в stdout . Все, что приложение печатает в стандартном выводе сохраняется и возвращается при использовании команды heroku logs . Поэтому я собираюсь добавить переменную конфигурации, которая указывает, нужно ли мне вести записи в stdout или в файл, как я это делал ранее. Вот изменение в конфигурации:

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

Поэтому теперь мне нужно определить переменную среды LOG_TO_STDOUT , если приложение работает в Heroku, но не в других конфигурациях. CLI Heroku делает это легко, поскольку предоставляет возможность устанавливать переменные среды, которые будут использоваться во время выполнения:

Скомпилированные переводы

Третьим аспектом микроблога, основанного на локальных файлах, является скомпилированный языковой перевод файлов. Самый простой вариант, чтобы гарантировать, что эти файлы никогда не исчезнут из эфемерной файловой системы, — это добавить скомпилированные языковые файлы в репозиторий Git, чтобы они стали частью начального состояния приложения после его развертывания в Heroku.

Более элегантный вариант, на мой взгляд, заключается в том, чтобы включить команду flask translate compile в команду start up, предоставленную Heroku, так что каждый раз, когда сервер перезапустится эти файлы скомпилируются снова. Я собираюсь пойти этим путём, так как я знаю, что моя процедура запуска будет требовать более одной команды в любом случае, так как мне ещё нужно запустить миграцию базы данных. Поэтому сейчас я отложу эту проблему в сторону и вернусь к ней позже, когда напишу Procfile.

Хостинг Elasticsearch

Elasticsearch является одним из многих сервисов, которые могут быть добавлены к проекту Heroku, но в отличие от Postgres, это не услуга, предоставляемая Heroku, а третья сторона, которая сотрудничают с Heroku, чтобы обеспечить дополнения. На сегодняшний день(когда я пишу эти строки) есть три разных провайдеров комплексной службы elasticsearch.

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

Из вариантов Elasticsearch, которые доступны в качестве дополнений, я решил попробовать SearchBox, который поставляется с бесплатным стартовым планом. Чтобы добавить SearchBox в свою учетную запись, вы должны выполнить следующую команду во время входа в Heroku:

Эта команда развернет службу Elasticsearch и разместит URL-адрес подключения для службы в переменной среды SEARCHBOX_URL , связанной с приложением. Еще раз напомню, что эта команда не будет выполнена, если Вы не добавите свою кредитную карту в свой аккаунт Heroku.

Если вы вспомните из главы 16, мое приложение ищет URL-адрес подключения Elasticsearch в переменной ELASTICSEARCH_URL , поэтому мне нужно добавить эту переменную и установить ее в URL-адрес подключения, назначенный SearchBox:

Здесь я сначала попросил Heroku напечатать значение SEARCHBOX_URL , а затем я добавил новую переменную среды с именем ELASTICSEARCH_URL , установленным в то же значение.

Обновление Requirements

Heroku ожидает, что зависимости будут в файле requirements.txt, точно так же, как я определил в главе 15. Но для запуска приложения на Heroku мне нужно добавить две новые зависимости к этому файлу.

Heroku не предоставляет собственный веб-сервер. Вместо этого он ожидает, что приложение запустит свой собственный веб-сервер по номеру порта, указанному в переменной среды $PORT . Поскольку Веб-сервер разработки flask недостаточно надежен для использования в работе, я собираюсь снова использовать gunicorn, сервер, рекомендованный Heroku для приложений Python.

Приложение также будет подключаться к базе данных Postgres, и для этого SQLAlchemy требует установки пакета psycopg2 .

И gunicorn и psycopg2 нужно быть добавленным в файл requirements.txt.

Профайл

Heroku должен знать, как выполнить приложение, и для этого он использует файл с именем Procfile в корневом каталоге приложения. Формат этого файла прост, каждая строка содержит имя процесса, двоеточие, а затем команду, которая запускает процесс. Наиболее распространенным типом приложения, который работает на Heroku, является веб-приложение, и для этого типа приложений имя процесса должно быть web . Ниже вы можете увидеть Procfile для Microblog:

Здесь я определил команду для запуска веб-приложения как последовательность трёх команд. Сначала я запускаю обновление миграции базы данных, затем компилирую переводы языков и, наконец, запускаю сервер.

Поскольку первые две подкоманды основаны на команде flask , мне нужно добавить переменную среды FLASK_APP :

Команда gunicorn проще, чем то, что я использовал для развертывания Ubuntu, потому что этот сервер имеет очень хорошую интеграцию со средой Heroku. Например, переменная среды $PORT учитывается по умолчанию, и вместо того, чтобы использовать параметр -w для задания числа процессов, heroku рекомендует добавить переменную WEB_CONCURRENCY , которую gunicorn использует, когда -w не предоставляется, что дает вам гибкость для управления числом процессов без необходимости изменять Procfile.

Развертывание приложения

Все подготовительные шаги завершены, поэтому пришло время запуска развертывания. Для загрузки приложения на серверы Heroku для развертывания используется команда git push . Это похоже на отправку изменений в локальном репозитории git на GitHub или другой удаленный сервер git.

И теперь я достиг самой интересной части, где я отправляю приложение на свой хостинг-аккаунт Heroku. Это на самом деле довольно просто, я просто должен использовать git , чтобы подтолкнуть приложение к главной ветви репозитория Heroku git. Существует несколько вариантов того, как это сделать, в зависимости от того, как вы создали свой репозиторий git. Если вы используете мой код v0.18 , то вам нужно создать ветвь на основе этого тега, и отправить её к удаленной ветви master, следующим образом:

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

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

Независимо от того, как вы отправляете ветку, вы должны увидеть следующий вывод из Heroku:

Метка heroku , которую мы использовали в команде git push , — это удаленный репозиторий, который был автоматически добавлен HEROKU CLI при создании приложения. Аргумент deploy:master означает, что я перемещаю код из локального репозитория, на который ссылается ветвь deploy , в главную ветвь master репозитория Heroku. Когда вы работаете с вашими собственными проектами, вы, вероятно, будете проталкивать изменения с помощью команды git push heroku master , которая протолкнет(запушит) вашу локальную ветку master . Из-за того, как этот проект структурирован, я отправляю ветку, которая не является master , но ветка назначения на стороне Heroku всегда должна быть master , поскольку это единственная ветвь, которую Heroku принимает для развертывания.

И вот теперь приложение должно быть развернуто по URL-адресу, указанному в выходных данных команды, создавшей приложение. В моем случае URL был https://flask-microblog.herokuapp.com, так что это то, что мне нужно ввести, чтобы получить доступ к приложению.

Если вы хотите видеть записи журнала для работающего приложения, используйте команду heroku logs . Это может быть полезно, если по какой-либо причине приложение не запускается. Если были какие-либо ошибки, они будут в журналах.

Развертывание обновлений приложений

Чтобы развернуть новую версию приложения, вам просто нужно выполнить команду git push с новым кодом. Это повторит процесс развертывания, отключит старое развертывание и заменит его новым кодом. Команды в Procfile будут запускаться снова как часть нового развертывания, поэтому любые новые миграции или переводы базы данных будут обновляться во время процесса.

Туда Сюда

Getting Started on Heroku with Java

If you’d prefer to use Gradle instead of Maven, see the Getting Started with Gradle on Heroku guide.

We recommend using our low-cost plans to complete this tutorial. Eligible students can apply for platform credits through our new Heroku for GitHub Students program.

Set Up

The Heroku CLI requires Git, the popular version control system. If you don’t already have Git installed, complete the following before proceeding:

In this step, you install the Heroku Command Line Interface (CLI). You use the CLI to manage and scale your applications, provision add-ons, view your recent application logs, and run your application locally.

Download and run the installer for your platform:

Download the appropriate installer for your Windows installation:

After installation completes, you can use the heroku command from your terminal.

Use the heroku login command to log in to the Heroku CLI:

This command opens your web browser to the Heroku login page to complete authentication. If your browser is already logged in to Heroku, click the Log in button displayed on the page.

Both the heroku and git commands require this authentication to work correctly.

If you’re behind a firewall that requires a proxy to connect with external HTTP/HTTPS services, set the HTTP_PROXY or HTTPS_PROXY environment variables in your local development environment before running the heroku command.

Prepare the App

In this step, you clone a sample application and prepare to deploy it to Heroku.

If you’re new to Heroku, it’s recommended to complete this tutorial using the Heroku-provided sample application.

If you have your own application that you want to deploy instead, see Preparing a Codebase for Heroku Deployment.

Create a local copy of the sample app by executing the following commands in your local command shell or terminal:

This functioning Git repository contains a simple Java application. The application includes a Procfile , a special plaintext file used by Heroku apps. You explicitly declare the processes and commands used to start your app in this file.

The Procfile in the example app source code looks like this:

This file declares a single process type, web , and the command needed to run it. The name web is important. It declares that this process type attaches to Heroku’s HTTP routing stack, and is able to receive web traffic.

Procfiles can contain additional process types. For example, you can declare a background worker that processes items off a queue. This tutorial doesn’t cover other processes but you can refer to The Procfile and The Process Model for more info.

The example app also includes a pom.xml file which is used by Maven, a Java build tool. The next step covers how to use this file to declare dependencies.

Declare App Dependencies

Heroku automatically identifies an app as a Java app if it contains a pom.xml file in the root directory. When a Java app is detected, Heroku adds the official Java buildpack to your app, which installs the dependencies for your application.

The example app you deployed already has a pom.xml (see it here).

When deploying an app, Heroku reads this file and installs the dependencies by running ./mvnw clean install . Take a look at the dependencies listed in your pom.xml .

Another file, system.properties , indicates the version of Java to use. The contents of this optional file look like:

Heroku supports many different versions. You can push your own apps using a different version of Java.

Deploy the App

In this step you will deploy the app to Heroku.

Using a dyno and a database to complete this tutorial counts towards your usage. Delete your app and database as soon as you are done experimenting to control costs.

The Java buildpack auto-provisions a Mini Heroku Postgres database for your app. By default, apps use Eco dynos if you are subscribed to Eco. Otherwise, it defaults to Basic dynos. The Eco dynos plan is shared across all Eco dynos in your account and is recommended if you plan on deploying many small apps to Heroku. Learn more here. Eligible students can apply for platform credits through our Heroku for GitHub Students program.

Create an app on Heroku to prepare it to receive your source code for deployment:

This command both creates an app and a Git remote (named heroku ) associated with your local Git repository.

By default, Heroku generates a random name for your app. You can pass a parameter to specify your own app name.

If you create your app via the Heroku Dashboard instead of using the CLI command, add a remote to your local repo with heroku git:remote —app example-app .

Now deploy your code:

By default, your app deploys on a eco dyno. A dyno is a lightweight Linux container that runs the command specified in your Procfile . After deployment, ensure that you have one web dyno running the app. You can check how many dynos are running using the heroku ps command:

The running web dynos serve requests. Visit the app at the URL generated by its app name. As a handy shortcut, you can open the website with:

Eco dynos sleep after thirty minutes of inactivity (for example, if they don’t receive any traffic). This behavior causes a delay of a few seconds for the first request upon waking. Subsequent requests perform normally. Eco dynos consume from a monthly, account-level quota of eco dyno hours. As long as you haven’t exhausted the quota, your apps can continue to run.

To avoid dyno sleeping, upgrade to a Basic or Professional dyno type as described in Dyno Types.

Scale the App

Horizontal scaling an application on Heroku is equivalent to changing the number of running dynos.

Scale the number of web dynos to zero:

Access the app again by refreshing your browser or running heroku open . You get an error message because your app no longer has any web dynos available to serve requests.

Scale it up again:

You can also vertically scale your app by upgrading to larger dynos. See Dyno Types and Scaling Your Dyno Formation for more info.

View Logs

Heroku aggregates all output streams from both your app and the platform’s components into a single channel of time-ordered logs.

View information about your running app using the heroku logs —tail command:

Visit your application in the browser again to generate another log message.

Press CTRL+C to stop streaming logs.

By default, Heroku stores your app’s 1500 most recent log lines. You can provision a logging add-on or implement your own log drain for long-term storage. In the next step, you add a logging add-on to your app.

Provision Add-ons

Add-ons are cloud services that provide additional services for your application, such as databases, logging, and monitoring.

Several logging add-ons are available that provide features such as log persistence, search, and alerting. Papertrail is one such add-on with a free plan.

Provision the add-on like so:

This command provisions the add-on and configures it for your application. To see this particular add-on in action, visit your application’s Heroku URL a few times. Each visit generates more log messages, which routes to the Papertrail add-on. Visit the Papertrail console to see the log messages:

Your browser opens up a Papertrail web console that shows the latest log events. The interface lets you search and set up alerts.

You can list all of your app’s active add-ons like so:

Running this command for your sample app lists its Papertrail and Heroku Postgres add-ons. Heroku automatically provisions a Postgres database add-on with all Java app deploys. You learn how to use this database in the next step.

Use a Database

Heroku provides managed data services for Postgres and Redis, and the add-on marketplace provides additional data services, including MongoDB and MySQL.

Heroku provisions a Heroku Postgres add-on on the mini plan automatically with all Java app deploys that include Postgres drivers.

Use the heroku addons command for an overview of the database provisioned for your app:

Listing your app’s config vars displays the URL that your app uses to connect to the database ( DATABASE_URL ):

The heroku pg command provides more in-depth information on your app’s Heroku Postgres databases:

Running this command for your app indicates that the app has a Mini Postgres database currently with zero rows of data.

The example app you deployed already has database functionality, which you can reach by visiting your app’s /database path.

You see something like this:

Assuming that you have Postgres installed locally, use the heroku pg:psql command to connect to the remote database and see all the rows:

The following info illustrates how the example app implements its database functionality. Don’t make changes to your example app code in this step.

The code in the example app looks like this:

The database method adds a new row to the tick table when you access your app using the /database route. It then returns all rows to render in the output.

The DataSource shown in the example app code is automatically configured and injected by the Spring Boot framework. It refers to the values in the src/main/resources/application.properties file for the database connection configuration.

The example app has spring.datasource.url set to the value in the JDBC_DATABASE_URL environment variable to establish a pool of connections to the database:

The official Heroku Java buildpack that’s automatically added to your app sets this JDBC_DATABASE_URL environment variable. This variable is dynamic and doesn’t appear in your list of configuration variables when running heroku config . You can view it by running the following command:

Read more about Heroku PostgreSQL. You can also install Redis or other data add-ons via heroku addons:create .

Prepare the Local Environment

In the following steps, you learn how to work with your app locally and push changes to Heroku. Begin by installing your dependencies locally in this step.

Run ./mvnw clean install in your local directory. This command installs the dependencies, preparing your system to run the app locally.

The Maven process compiles and builds a JAR, with dependencies, placing it into your application’s target directory. The spring-boot-maven-plugin in the pom.xml provides this process.

After installing dependencies, you can run your app locally. However, the app requires a Postgres database. Create a local Postgres database and update your local .env file. heroku local , the command used to run apps locally, automatically sets up your environment based on the .env file in your app’s root directory. Set the JDBC_DATABASE_URL environment variable with your local Postgres database’s connection string:

Your local environment is now ready to run your app and connect to the database.

Run the App Locally

Ensure you’ve already run ./mvnw clean install before running your app locally.

Start your application locally with the heroku local CLI command:

Just like the Heroku platform, heroku local examines your Procfile to determine what command to run.

Open http://localhost:5001 with your web browser to see your app running locally.

If you want to access the app’s /database route locally, ensure that your local Postgres database is running before you visit the URL.

To stop the app from running locally, go back to your terminal window and press CTRL+C to exit.

Push Local Changes

In this step, you make local changes to your app and deploy them to Heroku. Add the following dependency and some code that uses it.

Modify pom.xml to include a dependency for jscience by adding the following code inside the <dependencies> element:

In file pom.xml , add the following dependency to the <dependencies> element:

In file src/main/java/com/heroku/java/GettingStartedApplication.java , add the following import statements for the library:

Add the following convert method to GettingStartedApplication.java :

Finally, create a src/main/resources/templates/convert.html file with these contents:

Here’s the final source code for GettingStartedApplication.java . Ensure that your changes look similar. Here’s a diff of all the local changes made.

Test your changes locally:

Visiting your application’s /convert path at http://localhost:5001/convert, which displays some scientific conversions:

After testing, deploy your changes. Almost every Heroku deployment follows this same pattern. First, use the git add command to stage your modified files for commit:

Next, commit the changes to the repository:

Now deploy, just as you did previously:

Finally, check that your updated code successfully deployed by opening your browser to that route:

Define Config Vars

Heroku lets you externalize your app’s configuration by storing data such as encryption keys or external resource addresses in config vars.

At runtime, config vars are exposed to your app as environment variables. For example, modify GettingStartedApplication.java so that the method obtains an energy value from the ENERGY environment variable:

In file src/main/java/com/heroku/java/GettingStartedApplication.java , change the convert method:

Recompile the app to integrate this change by running ./mvnw clean install .

heroku local automatically sets up your local environment based on the .env file in your app’s root directory. Your sample app already includes a .env file with the following contents:

Your local .env file also includes the JDBC_DATABASE_URL variable if you set it during the Run the App Locally step.

Don’t commit the .env file to version control as it often includes secure credentials. Include .env in your repo’s .gitignore file. The sample app repo only includes a .env file as an example for this tutorial step.

Run the app with heroku local —port 5001 and visit http://localhost:5001/convert to see the conversion value for 20 GeV.

Now that you know it works as expected locally, set this variable as a config var on your app running on Heroku. Execute the following:

View the app’s config vars using heroku config to verify you’ve done it correctly:

Deploy your local changes to Heroku and visit the /convert route to see your changes in action:

Start a One-off Dyno

The heroku run command lets you run maintenance and administrative tasks on your app in a one-off dyno. It also lets you launch a REPL process attached to your local terminal for experimenting in your app’s environment or your deployed application code:

If you receive an error, Error connecting to process , configure your firewall.

Remember to type exit to exit the shell and terminate the dyno.

Next Steps

Congratulations! You now know how to deploy an app, change its configuration, scale it, view logs, attach add-ons, and run it locally.