Вы написали сценарий Python, которым гордитесь, и теперь хотите продемонстрировать его всему миру. Но как? Большинство людей не знают, что делать с вашим файлом .py. Преобразование вашего скрипта в веб‑приложение Python — отличное решение сделать ваш код пригодным для широкой аудиторией.

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

К концу урока вы будете знать:

  • Что такое веб‑приложения и как их разместить в Интернете;
  • Как преобразовать скрипт Python в веб‑приложение Flask;
  • Как улучшить интерактивность, добавив HTML в код Python;
  • Как развернуть веб‑приложение Python в Google App Engine.

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

Содержание

Основы

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

  • Какие типы распространения кода Python существуют;
  • Почему создание веб‑приложения может быть хорошим выбором;
  • Что такое веб‑приложение;
  • Как контент доставляется через Интернет;
  • Что такое веб‑хостинг;
  • Какие существуют хостинг-провайдеры и какой с ними бороться.

Освоение этих тем может помочь вам почувствовать себя более уверенно при написании кода Python для Интернета. Однако, если вы уже знакомы с ними, можете пропустить, установить Google Cloud SDK и приступить к созданию веб‑приложения Python.

Распространение своего кода Python

Доведение кода до пользователей называется распространением. Традиционно существует три различных подхода, которые вы можете использовать для распространения своего кода для других:

  1. Библиотека Python.
  2. Автономная программа.
  3. Веб-приложение Python.

Ниже вы подробнее рассмотрите каждый из этих подходов.

Если вы же работали с обширной экосистемой пакетов Python, то, вероятно, устанавливали пакеты с помощью pip. Как программист, вы можете опубликовать свой пакет Python на PyPI, чтобы другие cмогли получить доступ к вашему коду и использовать его, установив его с помощью pip:

$ python3 -m pip install <your-package-name>

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

Если вы не хотите публиковать свой код как пакет PyPI, вы все равно можете использовать встроенный Pythonв команде sdist для создания исходного дистрибутива или колеса Python для создания встроенного дистрибутива для совместного использования с вашими пользователями.

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

Более рационально представить свой код потенциальным пользователям — создать отдельную программу.

Компьютерные программы бывают разных типов и форм, и есть несколько вариантов преобразования ваших скриптов Python в автономные программы. Ниже вы прочитаете о двух возможных:

  • Упаковка вашего кода.
  • Создание графического интерфейса.

Такие программы, как PyInstaller, py2app, py2exe или Briefcase, помогут с упаковкой вашего кода. Они превращают сценарии Python в исполняемые программы, которые можно использовать на разных платформах, не требуя от пользователей явного запуска интерпретатора Python.

Примечание. Чтобы узнать больше об упаковке вашего кода, ознакомьтесь с использованием PyInstaller для простого распространения приложений Python или послушайте Podcast Real Python об упаковке вашего приложения Python.

Хотя упаковка вашего кода может решить проблемы с зависимостями, ваш код по-прежнему просто запускается в командной строке. Большинство людей привыкли работать с программами, которые предоставляют графический интерфейс пользователя (GUI). Вы можете сделать свой код Python доступным для большего числа людей, создав для него графический интерфейс.

Примечание. Есть масса различных пакетов для создания графического интерфейса, включая Tkinter, wxPython и PySimpleGUI. Если вы хотите создать собственное настольное приложение, ознакомьтесь с планом обучения программированию графического интерфейса пользователя Python.

Хотя автономная настольная программа с графическим интерфейсом пользователя может сделать ваш код доступным для более широкой аудитории, она по-прежнему представляет собой препятствие для начала работы. Перед запуском вашей программы потенциальные пользователи должны выполнить несколько шагов. Им нужно найти правильную версию для своей операционной системы, загрузить ее и успешно установить. Некоторые могут сдаться, прежде чем доберутся до конца.

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

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

Python используется во многих крупных веб‑приложениях и часто основным языком программирования серверной части. Многие веб‑приложения на основе Python с самого начала планируются как веб‑приложения и создаются с использованием веб‑фреймворков Python, таких как Flask, которые вы будете использовать в этом руководстве.

Однако вместо описанного выше подхода, ориентированного на Интернет, вы собираетесь взглянуть под другим углом. В конце концов, вы не планировали создавать веб‑приложение. Вы только что создали полезный скрипт Python и теперь хотите поделиться им со всем миром. Чтобы сделать его доступным для широкого круга пользователей, вам нужно преобразовать его в веб‑приложение, а затем развернуть в Интернете. Пришло время узнать, что такое веб‑приложение и чем оно отличается от другого контента в Интернете.

О веб‑приложениях Python

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

Вы можете просмотреть пример статического веб‑сайта по первому URL‑адресу, который когда-либо был в сети, а также по страницам, на которые он ссылается:

Пример статической страницы
Пример статической страницы

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

Например, приложение веб‑почты позволяет вам взаимодействовать с ним разными способами. В зависимости от ваших действий он может отображать разные типы информации, часто оставаясь на одной странице:

Одностраничное приложение Яндекс.Почта
Одностраничное приложение Яндекс.Почта

Веб-приложения, управляемые Python, используют код Python, чтобы определять, какие действия выполнять и какой контент отображать. Ваш код запускается на веб‑сервере, на котором размещен ваш сайт, а это означает, что вашим пользователям не нужно ничего устанавливать. Все, что им нужно для взаимодействия с вашим кодом, — это браузер и подключение к Интернету.

Запуск Python на веб‑сайте может быть сложным, но существует ряд различных веб‑фреймворков, которые автоматически заботятся о деталях. Как упоминалось выше, в этом руководстве вы создадите базовое приложение Flask.

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

Цикл HTTP‑запрос‑ответ

Обслуживание динамического контента через Интернет включает в себя множество различных частей, и все они должны взаимодействовать друг с другом для правильного функционирования. Вот общий обзор того, что происходит, когда пользователь взаимодействует с веб‑приложением:

  • Отправка: во-первых, ваш пользователь делает запрос на определенную веб‑страницу в вашем веб‑приложении. Они могут это сделать, например, введя URL‑адрес в свой браузер.
  • Получение: этот запрос получает веб‑сервер, на котором размещен ваш сайт.
  • Соответствие: ваш веб‑сервер теперь использует Google App Engine для просмотра файла конфигурации вашего приложения. Google App Engine сопоставляет запрос пользователя с определенной частью вашего скрипта Python.
  • Выполнение: соответствующий код Python вызывается Google App Engine. Когда ваш код запускается, он записывает веб‑страницу в качестве ответа.
  • Доставка: Google App Engine доставляет этот ответ вашему пользователю через веб‑сервер.
  • Просмотр: наконец, пользователь может просмотреть ответ веб‑сервера. Например, полученную веб‑страницу можно отобразить в браузере.

Это общий процесс доставки контента через Интернет. Язык программирования, используемый на сервере, а также технологии, используемые для установления этого соединения, могут различаться. Однако, концепция, используемая для взаимодействия между HTTP запросами и ответами, остается прежней и называется циклом HTTP Request-Response, HTTP запрос-ответ.

Примечание: Flask справится с большей частью этой сложности за вас, но это может помочь иметь общее представление об этом процессе.

Чтобы Flask мог обрабатывать запросы на стороне сервера, вам нужно будет найти место, где ваш код Python может жить в Интернете. Хранение вашего кода в Интернете для запуска веб‑приложения называется веб‑хостингом, и есть ряд поставщиков, предлагающих как платный, так и бесплатный веб‑хостинг.

Выберите хостинг: Google App Engine

При выборе провайдера веб‑хостинга вам необходимо подтвердить, что он поддерживает запуск кода Python. Многие из них стоят денег, но в этом руководстве будет использоваться бесплатный профессиональный и хорошо масштабируемый вариант, но все же разумный для настройки: Google App Engine.

Примечание. Google App Engine устанавливает ежедневные квоты для каждого приложения. Если ваше веб‑приложение превышает эти квоты, Google начнет выставлять вам счет. Если вы новый клиент Google Cloud, то при регистрации вы можете получить бесплатный промокупон.

Существует ряд других бесплатных вариантов, таких как PythonAnywhere, Repl.it или Heroku, которые вы можете изучить позже. Использование Google App Engine даст вам хорошее начало в изучении развертывания кода Python в Интернете, поскольку оно обеспечивает баланс между абстрагированием от сложности и возможностью делать настройку.

Google App Engine является частью облачной платформы Google (GCP), которая управляется Google и представляет собой одного из крупных облачных провайдеров наряду с Microsoft Azure и Amazon Web Services (AWS).

Чтобы начать работу с GCP, загрузите и установите Google Cloud SDK для своей операционной системы. Для получения дополнительных рекомендаций, помимо того, что вы найдете в этом руководстве,вы можете ознакомиться с документацией Google App Engine.

Примечание. Вы будете работать в стандартной среде Python 3. Стандартна среда Google App Engine поддерживает среду выполнения Python 3 и предлагает уровень бесплатного пользования.

Установка Google Cloud SDK также включает программу командной строки gcloud, которую вы позже будете использовать для развертывания своего веб‑приложения. Когда вы закончите установку, вы можете убедиться, что все работает, введя в консоль следующую команду:

$ gcloud --version

Вы должны получить в своем терминале что-то похожее на то, что показан ниже:

app-engine-python 1.9.91
bq 2.0.62
cloud-datastore-emulator 2.1.0
core 2020.11.13
gsutil 4.55

Ваши номера версий, вероятно, будут другими, но если программа gcloud успешно найдена на вашем компьютере, ваша установка прошла успешно.

Имея в виду этот общий обзор концепций и установленный Google Cloud SDK, вы готовы создать проект Python, который позже развернете в Интернете.

Базовое веб‑приложение Python

Google App Engine требует, чтобы вы использовали веб‑фреймворк для создания веб‑приложения в среде Python 3. Поскольку вы пытаетесь использовать минимальную настройку для размещения локального кода Python в Интернете, микрофреймворк, такой как Flask, является хорошим выбором. Минимальная реализация Flask настолько мала, что вы можете даже не заметить, что используете веб‑фреймворк.

Примечание. Если вы ранее работали с Google App Engine в среде Python 2.7, то заметите, что процесс значительно изменился.

Два примечательных изменения заключаются в том, что webapp2 был удален, и вы больше не можете указывать URL‑адреса для динамического содержания в файле app.yaml. Причина обоих этих изменений заключается в том, что теперь Google App Engine требует от вас использования веб‑инфраструктуры Python.

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

Настройте свой проект

Создайте папку проекта и дайте ей имя, описывающее ваш проект. Для этого практического проекта вызовите папку hello-app. Внутри этой папки вам понадобятся три файла:

  1. main.py содержит ваш код Python, заключенный в минимальную реализацию веб‑фреймворка Flask.
  2. requirements.txt перечисляет все зависимости, необходимые вашему коду для правильной работы.
  3. app.yaml помогает Google App Engine решить, какие настройки использовать на его сервере.

Хотя три файла могут показаться большим количеством, вы увидите, что в этом проекте для всех трех файлов используется менее десяти строк кода. Это минимальная настройка, которую вам нужно предоставить Google App Engine для любого проекта Python, который вы можете запустить. Остальное будет вашим собственным кодом Python. Вы можете загрузить полный исходный код, который будете использовать в этом руководстве, щелкнув ссылку ниже:

Затем вы посмотрите на содержимое каждого из файлов, начиная с самого сложного, main.py.

Создайте main.py

main.py — это файл, который Flask использует для доставки вашего контента. Вверху файла вы импортируете класс Flask в строке 1, а затем создаете экземпляр приложения Flask в строке 3:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def index():
    return "Поздравляем, это веб‑приложение!"

После создания приложения Flask вы пишете декоратор Python в строке 5 с именем @app.route, который Flask использует для соединения конечных точек URL с кодом, содержащимся в функциях. Аргумент @app.route определяет компонент пути URL, которым в данном случае является корневой путь («/«).

Код в строках 6 и 7 составляет index(), который обернут декоратором. Эта функция определяет, что должно быть выполнено, если определенная конечная точка URL запрошена пользователем. Его возвращаемое значение определяет, что увидит пользователь при загрузке страницы.

Примечание. Название index() носит условный характер. Это связано с тем, что главная страница веб‑сайта часто называется index.html. При желании вы можете выбрать другое имя функции.

Другими словами, если пользователь вводит базовый URL‑адрес вашего веб‑приложения в свой браузер, Flask запускает index(), и пользователь видит возвращенный текст. В данном случае этот текст представляет собой всего лишь одно предложение: Поздравляем, это веб‑приложение!

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

Создайте файл requirements.txt

Следующий файл, на который стоит обратить внимание — requirements.txt. Поскольку Flask является единственной зависимостью этого проекта, это все, что вам нужно указать:

Flask==1.1.2

Если у вашего приложения есть другие зависимости, вам также необходимо добавить их в файл requirements.txt.

Google App Engine будет использовать файл requirements.txt для установки необходимых зависимостей Python для вашего проекта при его настройке на сервере. Это похоже на то, что вы сделали бы после создания и активации новой виртуальной среды локально.

Создайте app.yaml

Третий файл, app.yaml, помогает Google App Engine настроить правильную серверную среду для вашего кода. Для этого файла требуется только одна строка, которая определяет среду выполнения Python:

runtime: python38

Строка, показанная выше, поясняет, что правильная среда выполнения для вашего кода Python — Python 3.8. Этого достаточно, чтобы Google App Engine произвел необходимую настройку на своих серверах.

Примечание. Убедитесь, что среда выполнения Python 3, которую вы хотите использовать, доступна в Google App Engine.

Вы можете использовать файл app.yaml Google App Engine для дополнительной настройки, например для добавления переменных среды в ваше приложение. Вы также можете использовать его для определения пути к статическому содержимому вашего приложения, например изображениям, файлам CSS или JavaScript. В этом руководстве не рассматриваются эти дополнительные настройки, но вы можете обратиться к документации Google App Engine, если хотите добавить такую ​​функцию в файле конфигурации app.yaml.

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

Однако, Рекомендуется протестировать код перед запуском в производство, чтобы выявить потенциальные ошибки. Затем вы проверите, все ли работает должным образом на локальном компьютере, прежде чем размещать код в Интернете.

Локальное тестирование

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

  1. Настройте виртуальную среду.
  2. Установите пакет Flask.

Чтобы настроить виртуальную среду Python 3, перейдите в папку проекта на своем терминале и введите следующую команду:

$ python3 -m venv venv

Это создаст новую виртуальную среду с именем venv, используя версию Python 3, которую вы установили в своей системе. Затем вам необходимо активировать виртуальную среду, используя сценарий активации:

$ source venv/bin/activate

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

$ python3 -m pip install -r requirements.txt

Эта команда извлекает все пакеты, перечисленные в файле requirements.txt, из PyPI и устанавливает их в вашей виртуальной среде. В этом случае единственным установленным пакетом будет Flask.

Подождите, пока установка завершится, затем откройте main.py и добавьте следующие две строки кода в конец файла:

if __name__ == "__main__":
    app.run(host="127.0.0.1", port=8080, debug=True)

Эти две строки сообщают Python, что нужно запустить сервер разработки Flask, когда сценарий выполняется из командной строки. Он будет использоваться только при локальном запуске скрипта. Когда вы развертываете код в Google App Engine, приложение будет обслуживать профессиональный процесс веб‑сервера, такой как Gunicorn. Вам не нужно ничего менять, чтобы это произошло.

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

$ python3 main.py

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

 * Serving Flask app "main" (lazy loading)
 * Environment: production
   WARNING: This is a development server.
   Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: on
 * Running on http://127.0.0.1:8080/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 315-059-987

Здесь показаны три важных элемента информации:

  1. ВНИМАНИЕ: это сервер разработки Flask, а это значит, что вы не хотите использовать его для обслуживания кода в рабочей среде. Вместо этого Google App Engine сделает это за вас.
  2. Запуск на http://127.0.0.1:8080/: это URL‑адрес, по которому вы можете найти свое приложение. Это URL‑адрес вашего локального хоста, что означает, что приложение работает на вашем компьютере. Перейдите по этому URL‑адресу в своем браузере, чтобы увидеть свой код в реальном времени.
  3. Нажмите CTRL + C для выхода: в той же строке также сообщается, что вы можете выйти из сервера разработки, нажав Ctrl + C на клавиатуре.

Следуйте инструкциям и откройте вкладку браузера по адресу http://127.0.0.1:8080/. Вы должны увидеть страницу с текстом, возвращаемым вашей функцией: Поздравляем, это веб‑приложение!

Примечание. URL‑адрес 127.0.0.1 также называется localhost, что означает, что он указывает на ваш собственный компьютер. Номер 8080, следующий после двоеточия (:), называется номером порта. Порт можно рассматривать как особый канал, аналогичный трансляции теле- или радиоканала.

Вы определили эти значения в app.run() в файле main.py. Запуск приложения на порту 8080 означает, что вы можете настроиться на этот номер порт и получать сообщения от сервера разработки. Порт 8080 обычно используется для локального тестирования, но вы также можете использовать и другой номер.

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

Также имейте в виду, что даже если он хорошо работает локально, он может работать не так же, как после развертывания. Это связано с тем, что при развертывании кода в Google App Engine участвуют и другие факторы. Однако для базового приложения, такого как то, которое вы создаете в этом руководстве, вы можете быть уверены, что он будет работать в производственной среде, если он будет хорошо работать на местном уровне.

После проверки настроек и функциональности кода на локальном сервере разработки вы готовы к развертыванию в Google App Engine.

Развертывание своего веб‑приложения Python

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

Настройка Google App Engine

Ознакомьтесь с приведенным ниже пошаговым процессом установки. Вы можете сравнить то, что видите в браузере, со скриншотами. Имя проекта, используемое в примерах снимков экрана, — hello-app.

Начните с входа в Google Cloud Platform. Перейдите в панель управления, где вы увидите панель инструментов в верхней части окна. Выберите раскрывающийся список, нажав на кнопку со стрелкой к левой стороне панели инструментов. Появится модальное окно со списком ваших проектов Google

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

Нажав «NEW PROJECT», вы перейдете на новую страницу, где сможете выбрать имя для своего проекта. Это имя появится в URL‑адресе вашего приложения, который будет похож на http://your-application-name.nw.r.appspot.com. Используйте hello-app в качестве имени для этого проекта, чтобы соответствовать руководству:

Вы можете увидеть свой идентификатор проекта под полем ввода имени проекта. Идентификатор проекта состоит из введенного вами имени и числа, добавленного Google App Engine. В случае с этим руководством вы можете видеть, что идентификатор проекта — hello-app-295110. Скопируйте свой личный идентификатор проекта, так как он понадобится вам позже для развертывания.

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

Теперь вы можете нажать СОЗДАТЬ и дождаться, пока проект будет настроен на стороне Google App Engine. Как только это будет сделано, появится всплывающее уведомление о создании нового проекта. Это также дает вам возможность выбрать его. Продолжайте и сделайте это, нажав SELECT PROJECT:

Нажав SELECT PROJECT, вы перейдете на главную страницу вашего нового проекта Google Cloud Platform. Выглядит это так:

Отсюда вы хотите переключиться на панель управления Google App Engine. Вы можете сделать это, щелкнув гамбургер-меню в верхнем левом углу, прокрутив вниз, чтобы выбрать App Engine в первом списке, а затем выбрав Dashboard вверху следующего всплывающего списка:

Это, наконец, перенаправит вас на панель управления Google App Engine вашего нового проекта. Поскольку проект пока пуст, страница будет выглядеть примерно так:

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

Настройка локального развертывания

После успешной установки Google Cloud SDK у вас будет доступ к интерфейсу командной строки gcloud. Эта программа поставляется с полезными инструкциями по развертыванию веб‑приложения. Начните с ввода команды, предложенной вам при создании нового проекта на веб‑сайте Google App Engine:

Как вы можете видеть в правом нижнем углу страницы, Google App Engine предлагает команду терминала для развертывания вашего кода в этом проекте. Откройте свой терминал, перейдите в папку своего проекта и выполните предложенную команду:

$ gcloud app deploy

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

ERROR: (gcloud.app.deploy)
You do not currently have an active account selected.
Please run:

  $ gcloud auth login

to obtain new credentials.

If you have already logged in with a different account:

    $ gcloud config set account ACCOUNT

to select an already authenticated account to use.

Вы получаете это сообщение об ошибке, потому что не можете развернуть какой-либо код в своей учетной записи Google App Engine, пока не докажете Google, что являетесь владельцем этой учетной записи. Вам нужно будет пройти аутентификацию в своей учетной записи Google App Engine на локальном компьютере.

Приложение командной строки gcloud уже предоставило вам команду, которую нужно запустить. Введите его в свой терминал:

$ gcloud auth login

Будет запущен процесс аутентификации путем создания URL‑адреса проверки и открытия его в вашем браузере. Завершите процесс, выбрав свою учетную запись Google в окне браузера и предоставив Google Cloud SDK необходимые права. После этого вы можете вернуться к своему терминалу, где увидите некоторую информацию о процессе аутентификации:

Your browser has been opened to visit:

    https://accounts.google.com/o/oauth2/auth?client_id=

You are now logged in as [<>].
Your current project is [None].  You can change this setting by running:
  $ gcloud config set project PROJECT_ID

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

Он сообщает вам, что в настоящее время нет набора проектов, и что вы можете установить его, запустив gcloud config set project PROJECT_ID. Теперь вам понадобится ID проекта, который вы указали ранее.

Примечание. Вы всегда можете получить идентификатор своего проекта, перейдя на веб‑сайт Google App Engine и щелкнув направленную вниз стрелку, которая вызывает модальное окно, показывающее все ваши проекты Google. Идентификатор проекта указан справа от названия вашего проекта и обычно состоит из названия проекта и шестизначного числа.

Обязательно замените hello-app-295110 на свой собственный идентификатор проекта при выполнении предложенной команды:

$ gcloud config set project hello-app-295110

Ваш терминал распечатает короткое сообщение о том, что свойство проекта было обновлено. После успешной аутентификации и установки проекта по умолчанию для вашего идентификатора проекта вы выполнили необходимые шаги по настройке.

Запуск процесса развертывания

Теперь вы готовы попробовать команду первоначального развертывания во второй раз:

$ gcloud app deploy

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

You are creating an app for project [hello-app-295110].
WARNING: Creating an App Engine application for a project is
irreversible and the region cannot be changed.
More information about regions is at
.

Please choose the region where you want your App Engine application
located:

 [1] asia-east2
 [2] asia-northeast1
 [3] asia-northeast2
 [4] asia-northeast3
 [5] asia-south1
 [6] asia-southeast2
 [7] australia-southeast1
 [8] europe-west
 [9] europe-west2
 [10] europe-west3
 [11] europe-west6
 [12] northamerica-northeast1
 [13] southamerica-east1
 [14] us-central
 [15] us-east1
 [16] us-east4
 [17] us-west2
 [18] us-west3
 [19] us-west4
 [20] cancel
Please enter your numeric choice:

Введите одно из чисел, перечисленных слева, и нажмите Enter.

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

После ввода номера интерфейс командной строки продолжит процесс настройки. Перед развертыванием кода в Google App Engine он покажет вам, как будет выглядеть развертывание, и попросит окончательно подтвердить:

Creating App Engine application in project [hello-app-295110]
and region [europe-west]....done.
Services to deploy:

descriptor:      [/Users/realpython/Documents/helloapp/app.yaml]
source:          [/Users/realpython/Documents/helloapp]
target project:  [hello-app-295110]
target service:  [default]
target version:  [20201109t112408]
target url:      [https://hello-app-295110.ew.r.appspot.com]


Do you want to continue (Y/n)?

После того, как вы подтвердите настройку, набрав Y, ваше развертывание, наконец, начнется. Ваш терминал покажет вам дополнительную информацию и небольшую анимацию загрузки, пока Google App Engine настраивает ваш проект на своих серверах:

Beginning deployment of service [default]...
Created .gcloudignore file. See `gcloud topic gcloudignore` for details.
╔════════════════════════════════════════════════════════════╗
╠═ Uploading 3 files to Google Cloud Storage                ═╣
╚════════════════════════════════════════════════════════════╝
File upload done.
Updating service [default]...⠼

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

Deployed service [default] to [https://hello-app-295110.ew.r.appspot.com]

You can stream logs from the command line by running:
  $ gcloud app logs tail -s default

To view your application in the web browser run:
  $ gcloud app browse

Теперь вы можете перейти по указанному URL‑адресу в своем браузере или ввести предложенную команду gcloud app browse, чтобы получить доступ к действующему веб‑приложению. Вы должны увидеть тот же короткий текстовый ответ, который вы видели ранее при запуске приложения на вашем локальном хосте: Поздравляем, это веб‑приложение!

Обратите внимание, что на этом веб‑сайте есть URL‑адрес, которым вы можете поделиться с другими людьми,и они смогут получить к нему доступ. Теперь у вас есть живое веб‑приложение Python!

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

Пора сделать шаг вперед! Следуя тому же процессу, в следующем разделе вы добавите в Интернет более интересные функции.Вы проведете рефакторинг кода сценария локального преобразователя температуры в веб‑приложение Flask.

Преобразование скрипта в веб‑приложение

Поскольку это руководство посвящено созданию и развертыванию веб‑приложений Python из кода, который у вас уже есть, код Python для сценария преобразователя температуры предоставляется здесь:

def fahrenheit_from(celsius):
    """Convert Celsius to Fahrenheit degrees."""
    try:
        fahrenheit = float(celsius) * 9 / 5 + 32
        fahrenheit = round(fahrenheit, 3)  # Round to three decimal places
        return str(fahrenheit)
    except ValueError:
        return "invalid input"

if __name__ == "__main__":
    celsius = input("Celsius: ")
    print("Fahrenheit:", fahrenheit_from(celsius))

Это короткий сценарий, который позволяет пользователю преобразовать температуру по Цельсию в эквивалентную температуру по Фаренгейту.

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

  1. Выполнение: как веб‑приложение узнает, когда запускать код?
  2. Пользовательский ввод: как веб‑приложение будет собирать пользовательский ввод?

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

Добавить код как функцию

Flask разделяет разные задачи на разные функции, каждой из которых назначается маршрут через декоратор @app.route. Когда пользователь посещает указанный маршрут по его URL‑адресу, выполняется код внутри соответствующей функции.

Начните с добавления fahrenheit_from() в ваш файл main.py и оберните его декоратором @app.route:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def index():
    return "Congratulations, it's a web app!"

@app.route("/")
def fahrenheit_from(celsius):
    """Convert Celsius to Fahrenheit degrees."""
    try:
        fahrenheit = float(celsius) * 9 / 5 + 32
        fahrenheit = round(fahrenheit, 3)  # Round to three decimal places
        return str(fahrenheit)
    except ValueError:
        return "invalid input"

if __name__ == "__main__":
    app.run(host="127.0.0.1", port=8080, debug=True)

Пока что вы только скопировали код своего скрипта Python в функцию в приложении Flask и добавили декоратор @app.route.

Однако проблема с этой настройкой уже есть. Что происходит, когда вы запускаете код на своем сервере разработки? Попробуйте.

В настоящее время обе ваши функции запускаются по одному и тому же маршруту («/«).Когда пользователь посещает этот маршрут, Flask выбирает первую соответствующую ему функцию и выполняет этот код. В вашем случае это означает, что fahrenheit_from() никогда не выполняется, потому что index() соответствует тому же маршруту и ​​вызывается первым.

Для доступа к вашей второй функции потребуется собственный уникальный маршрут. Дополнительно, по-прежнему нужно разрешить пользователям вводить данные для функции.

Передача значений в ваш код

Вы можете решить обе эти задачи, указав Flask обработать любую оставшуюся часть URL‑адреса, следующего за базовым URL‑адресом, как значение и передать ее вашей функции. Для этого требуется лишь небольшое изменение параметра декоратора @app.route перед fahrenheit_from():

@app.route("/")
def fahrenheit_from(celsius):
    # -- snip --

Синтаксис угловых скобок (<>) указывает Flask захватывать любой текст, следующий за базовым URL («/»), и передавать его функции, которую декоратор оборачивает как переменную celsius. Обратите внимание, что fahrenheit_from() требует ввода значения Цельсия.

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

Вернитесь в свой веб‑браузер и опробуйте новую функциональность, используя сервер разработки Flask. Теперь вы можете получить доступ к обеим функциям через веб‑приложение, используя разные конечные точки URL:

  1. Индекс (/): если вы перейдете по базовому URL, то увидите короткое ободряющее сообщение из предыдущего.
  2. Цельсия (/42): если вы добавите число после косой черты, вы увидите, что преобразованная температура появится в вашем браузере.

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

Ваше веб‑приложение выполняет те же функции, что и сценарий Python локально, только теперь вы можете развернуть его в Интернете.

Рефакторинг кода

Flask — это зрелый веб‑фреймворк, который позволяет передать множество задач своим внутренним компонентам. Например, вы можете позволить Flask позаботиться о проверке типа ввода вашей функции и возврате сообщения об ошибке, если оно не подходит. Все это можно сделать с помощью краткого синтаксиса внутри параметра @app.route. Добавьте следующее в свой захватчик пути:

@app.route("/")

Добавление int: перед именем переменной сообщает Flask, что нужно проверить, можно ли преобразовать ввод, который он получает от URL‑адреса, в целое число. Если это возможно, содержимое передается в fahrenheit_from(). Если это не удается, Flask отображает страницу с ошибкой Not Found.

Примечание. Ошибка Not Found (Не найдено) означает, что Flask попытался сопоставить компонент пути, который он отсек из URL‑адреса, с любой из известных ему функций.

Однако единственные известные ему шаблоны — это пустой базовый путь (/) и базовый путь, за которым следует число, например /42. Поскольку такой текст, как /hello, не соответствует ни одному из этих шаблонов, он сообщает вам, что запрошенный URL не был найден на сервере.

После применения проверки типа Flask вы можете безопасно удалить блок try… except в fahrenheit_from(). Flask передаст функции только целые числа:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def index():
    return "Congratulations, it's a web app!"

@app.route("/")
def fahrenheit_from(celsius):
    """Convert Celsius to Fahrenheit degrees."""
    fahrenheit = float(celsius) * 9 / 5 + 32
    fahrenheit = round(fahrenheit, 3)  # Round to three decimal places
    return str(fahrenheit)

if __name__ == "__main__":
    app.run(host="127.0.0.1", port=8080, debug=True)

Улучшите пользовательский интерфейс своего веб‑приложения

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

Чтобы улучшить пользовательский интерфейс и удобство использования вашего веб‑приложения, вам необходимо работать с языками, отличными от Python, а именно с front-конечные языки, такие как HTML, CSS и JavaScript. В этом руководстве мы максимально избегаем этого, чтобы сосредоточиться на использовании Python.

Однако, если вы хотите добавить поле ввода в свое веб‑приложение, вам потребуется использовать некоторый HTML. Вы реализуете только абсолютный минимум, чтобы ваше веб‑приложение выглядело и больше походило на веб‑сайт, с которым пользователи будут знакомы. Вы будете использовать HTML-элемент <form> для сбора их ввода.

Примечание. Если вы хотите узнать больше о HTML, ознакомьтесь с материалами сайта КМБ: «HTML, CSS»

После обновления вашего веб‑приложения у вас появится текстовое поле, в котором пользователь может ввести температуру в градусах Цельсия. Там будет кнопка Конвертировать, чтобы преобразовать указанную пользователем температуру Цельсия в градусы Фаренгейта:

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

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

Сбор данных, вводимых пользователем

Начните с создания элемента <form> на целевой странице. Скопируйте следующие несколько строк HTML в оператор возврата index(), заменив предыдущее текстовое сообщение:

@app.route("/")
def index():
    return """
"""

Элемент <form> также содержит два HTML-атрибута, называемых action и method, действием и метод соответственно:

  1. action определяет, куда будут отправлены данные, отправленные пользователем. Здесь вы оставляете значение в виде пустой строки, что заставляет ваш браузер направлять запрос по тому же URL, с которого он был вызван. В вашем случае это пустой базовый URL.
  2. method определяет, какой тип HTTP-запроса создает форма. Использование значения по умолчанию «get» создает запрос HTTP GET. Это означает, что данные, отправленные пользователем, будут видны в параметрах запроса URL. Если вы отправляли конфиденциальные данные или обменивались данными с базой данных, вам необходимо вместо этого использовать HTTP-запрос POST.

После проверки элемента <form> и его атрибутов следующим шагом будет более пристальное внимание к первому из двух элементов <input>.

Поле ввода

Второй элемент HTML — это элемент <input>, вложенный в элемент <form>:

Первый элемент <input> имеет два атрибута HTML:

  1. type определяет, какой тип элемента <input> должен быть создан. Есть много вариантов на выбор, например флажки и раскрывающиеся элементы. В этом случае вы хотите, чтобы пользователь вводил число как текст, поэтому вы устанавливаете тип "text".
  2. name определяет, как значение, вводимое пользователем, будет называться. Вы можете рассматривать его как ключ к словарю, где значение — это то, что пользователь вводит в текстовое поле. Вы видели, как это имя отображается в URL‑адресе как ключ параметра запроса. Этот ключ понадобится вам позже, чтобы получить значение, отправленное пользователем.

Элементы HTML <input> могут иметь разные формы, и для некоторых из них требуются разные атрибуты. Вы увидите пример этого, если посмотрите на второй элемент <input>, который создает кнопку «Convert» и является последним элементом HTML, составляющим фрагмент кода.

Как получить пользовательский запрос

Как экранировать данные пользовательского запроса

Обработка пользовательского запроса

Заключение


Python Web Applications: Deploy Your Script as a Flask App

Опубликовано Вадим В. Костерин

ст. преп. кафедры ИТЭ. Автор более 130 научных и учебно-методических работ. Лауреат ВДНХ (серебряная медаль).

Оставьте комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *