One place for hosting & domains

      Создание и развертывание приложения Flask с использованием Docker в Ubuntu 18.04


      Автор выбрал Tech Education Fund для получения пожертвования в рамках программы Write for DOnations.

      Введение

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

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

      Развертывание приложения Flask с помощью Docker позволит вам воспроизводить приложение на разных серверах с минимальными изменениями конфигурации.

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

      Предварительные требования

      Для выполнения этого руководства вам потребуется следующее:

      Шаг 1 — Настройка приложения Flask

      Вначале вы создадите структуру каталогов, где будет размещено ваше приложение Flask. В этом обучающем модуле мы создадим каталог TestApp в каталоге /var/www, но вы можете изменить команду и использовать любое другое название.

      • sudo mkdir /var/www/TestApp

      Перейдите в созданный каталог TestApp:

      Создайте базовую структуру папок для приложения Flask:

      • sudo mkdir -p app/static app/templates

      Флаг -p означает, что команда mkdir создаст каталог и все его родительские каталоги, которых еще не существует. В данном случае команда mkdir создаст родительский каталог app в процессе создания каталогов static и templates.

      В каталоге app будут находиться все файлы, связанные с приложением Flask, в том числе views и blueprints. Views — это создаваемый вами код, обеспечивающий ответы на запросы вашего приложения. Blueprints создает компоненты приложения и поддерживает стандартные шаблоны внутри приложения или для нескольких разных приложений.

      В каталоге static хранятся различные ресурсы, в том числе файлы изображений, CSS и JavaScript. В каталоге templates хранятся шаблоны HTML для вашего проекта.

      Теперь базовая структура папок готова, и вы можете создать все файлы, необходимые для запуска приложения Flask. Вначале создайте файл __init__.py в каталоге app. Этот файл сообщает интерпретатору Python, что каталог app является пакетом, и его следует рассматривать именно как пакет.

      Запустите следующую команду для создания файла:

      • sudo nano app/__init__.py

      Пакеты в Python позволяют группировать модули в логические пространства имен или иерархии. Этот подход позволяет разбивать код на отдельные управляемые блоки, которые выполняют конкретные функции.

      Затем вы добавитье в файл __init__.py код, который создаст экземпляр Flask и импортирует логику из файла views.py, которы вы создадите после сохранения этого файла. Добавьте в новый файл следующий код:

      /var/www/TestApp/__init__.py

      from flask import Flask
      app = Flask(__name__)
      from app import views
      

      После добавления этого кода сохраните и закройте файл.

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

      Затем добавьте код в файл views.py. Этот код будет возвращать фразу hello world! строка для пользователей, посещающих вашу веб-страницу:

      /var/www/TestApp/app/views.py

      from app import app
      
      @app.route('/')
      def home():
         return "hello world!"
      

      Строка @app.route над функцией называется декоратором. Декораторы изменяют функцию, которая следует за ними. В данном случае декторатор указывает Flask, какой URL активирует функцию home(). Текст hello world, возвращаемый функцией home, будет отображаться пользователю в браузере.

      Создав файл views.py, вы готовы к созданию файла uwsgi.ini. Этот файл будет содержать конфигурации uWSGI для нашего приложения. uWSGI — это опция развертывания Nginx, представляющая собой как протокол, так и сервер приложений, который может обслуживать протоколы uWSGI, FastCGI и HTTP.

      Для создания этого файла запустите следующую команду:

      Затем добавьте в файл следующее содержание для настройки сервера uWSGI:

      /var/www/TestApp/uwsgi.ini

      [uwsgi]
      module = main
      callable = app
      master = true
      

      Этот код определяет модуль, из которого будет обслуживаться приложение Flask. В данном случае это файл main.py, который здесь указывается как main. Опция callable указывает uWSGI использовать экземпляр app, экспортированный основным приложением. Параметр master позволяет вашему приложению продолжать работать, и поэтому даже при перезагрузке всего приложения время простоя будет минимальным.

      Теперь создайте файл main.py, который будет главной точкой входа в приложение. Точка входа сообщает uWSGI, как следует взаимодействовать с приложением.

      Далее скопируйте и вставьте в файл следующий код. Этот код импортирует экземпляр Flask под названием app из пакета приложения, созданного на предыдущих шагах.

      /var/www/TestApp/main.py

      from app import app
      

      Наконец, создайте файл requirements.txt, чтобы указать, какие зависимости диспетчер пакетов pip установит в вашу среду Docker:

      • sudo nano requirements.txt

      Добавьте следующую строку для добавления Flask в качестве зависимости:

      /var/www/TestApp/app/requirements.txt

      Flask==1.0.2
      

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

      Сохраните и закройте файл. Вы успешно настроили свое приложение Flask и готовы к настройке Docker.

      Шаг 2 — Настройка Docker

      На этом шаге вы создадите два файла для развертывания Docker, Dockerfile и start.sh. Dockerfile — это текстовый документ, содержащий команды, используемые для сборки образа. Файл start.sh — это скрипт оболочки, который построит образ и создаст контейнер из файла Dockerfile.

      Вначале создайте файл Dockerfile.

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

      /var/www/TestApp/Dockerfile

      FROM tiangolo/uwsgi-nginx-flask:python3.6-alpine3.7
      RUN apk --update add bash nano
      ENV STATIC_URL /static
      ENV STATIC_PATH /var/www/app/static
      COPY ./requirements.txt /var/www/requirements.txt
      RUN pip install -r /var/www/requirements.txt
      

      В этом примере образ Docker будет построен на основе существующего образа tiangolo/uwsgi-nginx-flask, который можно найти на ресурсе DockerHub. Этот конкретный образ Docker лучше многих других, потому что он поддерживает широкий спектр версий Python и образов ОСs.

      В первых двух строках указывается родительский образ, который вы будете использовать для запуска приложений и установки процессора команд bash и текстового редактора nano. Также он устанавливает клиент git для связи со службами хостинга контроля версий, такими как GitHub, GitLab и Bitbucket. ENV STATIC_URL /static — переменная среды, используемая для конкретного образа Docker. Она определяет статичную папку, где хранятся все ресурсы, включая образы, файлы CSS и файлы JavaScript.

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

      Сохраните и закройте файл после добавления вашей конфигурации.

      Теперь вы установили файл Dockerfile и уже почти готовы написать скрипт start.sh, который построит для вас контейнер Docker. Прежде чем создавать скрипт start.sh, убедитесь, что у вас имеется открытый порт для использования в конфигурации. Чтобы проверить, свободен ли порт, запустите следующую команду:

      • sudo nc localhost 56733 < /dev/null; echo $?

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

      Когда вы найдете открытый порт для использования, создайте скрипт start.sh:

      Скрипт start.sh — это скрипт оболочки, создающий образ из файла Dockerfile и создающий контейнер на основе полученного образа Docker. Добавьте свою конфигурацию в новый файл:

      /var/www/TestApp/start.sh

      #!/bin/bash
      app="docker.test"
      docker build -t ${app} .
      docker run -d -p 56733:80 
        --name=${app} 
        -v $PWD:/app ${app}
      

      Первая строка называется shebang. Она указывает, что это файл bash, и что его нужно выполнять как команды. В следующей строке указывается, какое имя вы хотите присвоить образу и контейнеру, а также выполняется сохранение этого имени в переменной app. Следующая строка указывает Docker построить образ из файла Dockerfile, находящегося в текущем каталоге. В этом примере будет создан образ с именем docker.test.

      Последние три строки создают новый контейнер с именем docker.test с открытым портом 56733. Наконец, текущий каталог связывается с каталогом /var/www directory в контейнере.

      Флаг -d используется для запуска контейнера в режиме демона или в качестве фонового процесса. Флаг -p используется для привязки порта на сервере к конкретному порту контейнера Docker. В данном случае вы привязываете порт 56733 к порту 80 контейнера Docker. Флаг -v указывает, какой том Docker следует монтировать на контейнер. В данном случае вы монтируете весь каталог проекта в папку /var/www в контейнере Docker.

      Запустите скрипт start.sh для создания образа Docker и построения контейнера на основе этого образа:

      После завершения выполнения скрипта используйте следующую команду для вывода списка всех запущенных контейнеров:

      В результате будет выведен список контейнеров:

      Output

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 58b05508f4dd docker.test "/entrypoint.sh /sta…" 12 seconds ago Up 3 seconds 443/tcp, 0.0.0.0:56733->80/tcp docker.test

      Вы увидите, что контейнер docker.test запущен и работает. Теперь, когда контейнер работает, откройте в браузере IP-адрес на указанном порту: http://ip-address:56733

      Страница будет выглядеть примерно следующим образом:

      Главная страница

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

      Шаг 3 — Работа с файлами шаблонов

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

      Вначале создайте файл home.html в каталоге app/templates:

      • sudo nano app/templates/home.html

      Добавьте код для вашего шаблона. Этот код создаст страницу HTML5, содержащую заголовок и текст.

      /var/www/TestApp/app/templates/home.html

      
      <!doctype html>
      
      <html lang="en-us">   
        <head>
          <meta charset="utf-8">
          <meta http-equiv="x-ua-compatible" content="ie=edge">
          <title>Welcome home</title>
        </head>
      
        <body>
          <h1>Home Page</h1>
          <p>This is the home page of our application.</p>
        </body>
      </html>
      

      После добавления шаблона сохраните и закройте файл.

      Теперь измените файл app/views.py, чтобы обслуживать созданный файл:

      Вначале добавьте в начале файла следующую строку для импорта метода render_template из Flask. Этот метод проводит синтаксический анализ файла HTML для рендеринга веб-страницы для пользователя.

      /var/www/TestApp/app/views.py

      from flask import render_template
      ...
      

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

      /var/www/TestApp/app/views.py

      ...
      
      @app.route('/template')
      def template():
          return render_template('home.html')
      

      Обновленный файл app/views.py будет выглядеть примерно следующим образом:

      /var/www/TestApp/app/views.py

      from flask import render_template
      from app import app
      
      @app.route('/')
      def home():
          return "Hello world!"
      
      @app.route('/template')
      def template():
          return render_template('home.html')
      

      Сохраните и закройте файл после завершения.

      Чтобы эти изменения вступили в силу, вам нужно будет остановить и перезапустить контейнеры Docker. Запустите следующую команду для повторного построения контейнера:

      • sudo docker stop docker.test && sudo docker start docker.test

      Откройте свое приложение по адресу http://your-ip-address:56733/template, чтобы увидеть, как выводится новый шаблон.

      главная страница

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

      Шаг 4 — Обновление приложения

      Иногда в приложение бывает нужно внести изменения. Это может быть установка новых требований, обновление контейнера Docker или внесение изменений в код HTML и логику. В этом разделе вы настроите команду touch-reload для внесения этих зменений без перезапуска контейнера Docker.

      Функция автоматической перезагрузки Python отслеживает изменения во всей файловой системе и обновляет приложение при обнаружении изменений. Автоматическая перезагрузка не рекомендуется в производственной среди, поскольку она может очень быстро увеличить нагрузку на ресурсы системы. На этом шаге вы используете команду touch-reload для отслеживания изменений определенного файла и перезагрузке контейнера в случае обновления или замены файла.

      Для реализации этой функции откройте файл uwsgi.ini:

      Добавьте в конец файла выделенную строку:

      /var/www/TestApp/uwsgi.ini

      module = main
      callable = app
      master = true
      touch-reload = /app/uwsgi.ini
      

      Эта строка указывает файл, изменение которого запускает перезагрузку приложения. После внесения изменений сохраните и закройте файл.

      Чтобы продемонстрировать это, внесите в ваше приложение небольшое изменение. Для начала откройте файл app/views.py:

      Замените строку, возвращаемую функцией home:

      /var/www/TestApp/app/views.py

      from flask import render_template
      from app import app
      
      @app.route('/')
      def home():
          return "<b>There has been a change</b>"
      
      @app.route('/template')
      def template():
          return render_template('home.html')
      

      Сохраните и закройте файл после внесения изменения.

      Если вы откроете главную страницу приложения по адресу http://ip-address:56733, вы увидите, что изменения не отражаются. Это связано с тем, что условием перезагрузки будет изменение в файле uwsgi.ini. Чтобы перезагрузить приложение, используйте команду touch для активации условия:

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

      Главная страница обновлена

      На этом шаге вы выберете условие команды touch-reload, с которым приложение будет обновляться после внесения изменений.

      Заключение

      В этом обучающем модуле вы создали и развернули приложение Flask в контейнере Docker. Также вы настроили команду touch-reload для обновления приложения без необходимости перезапуска контейнера.

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



      Source link

      Cómo crear e implementar una aplicación de Flask utilizando Docker en Ubuntu 18.04


      El autor seleccionó el Tech Education Fund para que recibiese una donación como parte del programa Write for DOnations.

      Introducción

      Docker es una aplicación de código abierto que permite a los administradores crear, administrar, implementar y replicar aplicaciones usando contenedores. Los contenedores pueden considerarse como un paquete que alberga las dependencias que una aplicación requiere para ejecutarse a nivel de sistema operativo. Esto significa que cada aplicación implementada usando Docker reside en un entorno propio y sus requisitos se gestionan por separado.

      Flask es un micromarco web que se compila con Python. Se denomina micromarco porque no requiere herramientas ni complementos específicos para ejecutarse. El marco de Flask es ligero y flexible, pero muy estructurado. Esto lo convierte en la opción preferida por encima de otros marcos.

      Implementar una aplicación de Flask con Docker le permitirá replicarla en varios servidores con una reconfiguración mínima.

      A través de este tutorial, creará una aplicación de Flask y la implementará con Docker. En este artículo, también se abordará la manera de actualizar una aplicación tras la implementación.

      Requisitos previos

      Para completar este tutorial, necesitará lo siguiente:

      Paso 1: Configurar la aplicación de Flask

      Para comenzar, creará una estructura de directorios que contendrá su aplicación de Flask. En este tutorial, se creará un directorio llamado TestApp en /var/www, pero puede modificar el comando para darle el nombre que desee.

      • sudo mkdir /var/www/TestApp

      Diríjase al directorio TestApp recién creado:

      A continuación, cree la estructura de carpetas para la aplicación de Flask:

      • sudo mkdir -p app/static app/templates

      El indicador -p marca que mkdir creará un directorio y todos los directorios principales que no existen. En este caso, mkdir creará el directorio principal app en el proceso de creación de los directorios static y templates.

      El directorio app contendrá todos los archivos relacionados con la aplicación de Flask, como sus vistas y modelos. Las vistas son el código que uste escribe para responder a las solicitudes a su aplicación. Los modelos crean componentes de aplicaciones, y admiten patrones comunes dentro de una aplicación y entre varias de estas.

      El directorio static es el punto en el que se alojan recursos como los archivos de imagen, CSS y JavaScript. El directorio templates es el espacio en el que dispondrá las plantillas HTML para su proyecto.

      Ahora que la estructura básica de carpetas está completa, cree los archivos necesarios para ejecutar la aplicación de Flask. Primero, cree un archivo __init__.py dentro del directorio app. Este archivo indica al intérprete de Python que el directorio app es un paquete y debería tratarse como tal.

      Ejecute el siguiente comando para crear el archivo:

      • sudo nano app/__init__.py

      Los paquetes de Python le permiten agrupar módulos en jerarquías o espacios de nombres lógicos. Este enfoque permite desglosar el código en bloques individuales y manejables que realizan funciones específicas.

      A continuación, añadirá código al __init__.py que creará una instancia de Flask e importará la lógica desde el archivo views.py, que creará tras guardar este archivo. Añada el siguiente código a su nuevo archivo:

      /var/www/TestApp/__init__.py

      from flask import Flask
      app = Flask(__name__)
      from app import views
      

      Una vez que lo haga, guarde y cierre el archivo.

      Después de crear el archivo __init__.py, estará listo para crear el archivo views.py en su directorio app. Este archivo contendrá la mayor parte de la lógica de su aplicación.

      A continuación, añada el código a su archivo views.py. Con este código se mostrará la cadena hello world! a los usuarios que visiten su página web:

      /var/www/TestApp/app/views.py

      from app import app
      
      @app.route('/')
      def home():
         return "hello world!"
      

      La línea @app.route sobre la función se conoce como decorador. Los decoradores modifican la función que los sigue. En este caso, el decorador indica a Flask la URL que desencadenará la función home(). El texto hello world mostrado por la función home se mostrará al usuario en el navegador.

      Una vez que esté preparado el archivo views.py, estará listo para crear el archivo uwsgi.ini. Este archivo contendrá las configuraciones de uWSGI para nuestra aplicación. uWSGI es una opción de implementación para Nginx que es tanto un protocolo como un servidor de aplicaciones; el servidor de aplicaciones puede proporcionar los protocolos uWSGI, FastCGI y HTTP.

      Para crear este archivo, ejecute el siguiente comando:

      A continuación, añada el siguiente contenido a su archivo para configurar el servidor uWSGI:

      /var/www/TestApp/uwsgi.ini

      [uwsgi]
      module = main
      callable = app
      master = true
      

      Este código define el módulo desde el que se proporcionará la aplicación de Flask. En este caso, este es el archivo main.py, citado aquí como main. La opción callable indica a uWSGI que use la instancia de app exportada por la aplicación principal. La opción master permite que su aplicación siga ejecutándose, de modo que haya poco tiempo de inactividad incluso cuando se vuelva a cargar toda la aplicación.

      A continuación, cree el archivo main.py, que es el punto de entrada a la aplicación. El punto de entrada indica a uWSGI cómo interactuar con la aplicación.

      A continuación, copie lo siguiente y péguelo en el archivo. Con esto, se importará la instancia de Flask llamada app desde el paquete de la aplicación que se creó previamente.

      /var/www/TestApp/main.py

      from app import app
      

      Finalmente, cree un archivo requirements.txt para especificar las dependencias que el administrador de paquetes pip instalará en su implementación de Docker:

      • sudo nano requirements.txt

      Añada la siguiente línea para agregar Flask como dependencia:

      /var/www/TestApp/app/requirements.txt

      Flask==1.0.2
      

      Esto especifica la versión de Flask que se instalará. En el momento en que se redactó este tutorial, la versión 1.0.2 fue la más reciente de Flask. Puede verificar si existen actualizaciones en el sitio web oficial de Flask.

      Guarde y cierre el archivo. De esta manera, habrá configurado correctamente su aplicación de Flask y estará listo para configurar Docker.

      Paso 2: Configurar Docker

      A lo largo de este paso creará dos archivos, Dockerfile y start.sh, para crear su implementación de Docker. El archivo Dockerfile es un documento de texto que contiene los comandos utilizados para ensamblar la imagen. El archivo start.sh es una secuencia de comandos shell que creará una imagen y un contenedor desde Dockerfile.

      Primero, cree Dockerfile.

      A continuación, añada su configuración deseada a Dockerfile. Estos comandos especifican la forma en que se creará la imagen y los requisitos adicionales que se incluirán.

      /var/www/TestApp/Dockerfile

      FROM tiangolo/uwsgi-nginx-flask:python3.6-alpine3.7
      RUN apk --update add bash nano
      ENV STATIC_URL /static
      ENV STATIC_PATH /var/www/app/static
      COPY ./requirements.txt /var/www/requirements.txt
      RUN pip install -r /var/www/requirements.txt
      

      En este ejemplo, la imagen de Docker se creará a partir de una imagen existente, tiangolo/uwsgi-nginx-flask, que podrá encontrar en DockerHub. Esta imagen de Docker concreta es una buena opción en comparación con otras, porque es compatible con una amplia variedad de versiones de Python e imágenes de SO.

      Las primeras dos líneas especifican la imagen principal que utilizará para ejecutar la aplicación e instalar el procesador de comandos bash y el editor de texto nano. También instala el cliente git para realizar extracciones desde servicios de alojamiento de control de versiones, como GitHub, GitLab y Bitbucket, e incorporaciones en ellos. ENV STATIC_URL /static es una variable de entorno específica para esta imagen de Docker. Define la carpeta estática desde la cual se proporcionan todos los recursos como imágenes, archivos CSS y archivos JavaScript.

      Las últimas dos líneas copiarán el archivo requirements.txt al contenedor para que pueda ejecutarse y luego analice el archivo requirements.txt para instalar las dependencias especificadas.

      Guarde y cierre el archivo después de añadir su configuración.

      Una vez que este listo su Dockerfile, casi estará preparado listo para escribir la secuencia de comandos start.sh que creará el contenedor de Docker. Antes de escribir la secuencia de comandos start.sh, primero asegúrese de disponer de un puerto abierto para usarlo en la configuración. Para verificar si hay un puerto libre, ejecute el siguiente comando:

      • sudo nc localhost 56733 < /dev/null; echo $?

      Si el resultado del comando anterior es 1, el puerto estará libre y podrá utilizarse. De lo contrario, deberá seleccionar un puerto diferente para usarlo en su archivo de configuración start.sh.

      Una vez que encuentre un puerto abierto para usarlo, cree la secuencia de comandos start.sh:

      La secuencia de comandos start.sh es una secuencia de comandos de shell que creará una imagen desde Dockerfile y un contenedor a partir de la imagen de Docker resultante. Añada su configuración al nuevo archivo:

      /var/www/TestApp/start.sh

      #!/bin/bash
      app="docker.test"
      docker build -t ${app} .
      docker run -d -p 56733:80 
        --name=${app} 
        -v $PWD:/app ${app}
      

      La primera línea se denomina shebang. Especifica que este es un archivo bash y se ejecutará como comandos. En la siguiente línea se especifica el nombre que desea dar a la imagen y al contenedor, y se guarda como una app con nombre variable. La siguiente línea indica a Docker que cree una imagen desde su Dockerfile ubicado en el directorio actual. Con esto, se creará una imagen llamada docker.test en este ejemplo.

      Con las últimas tres líneas se crea un nuevo contenedor llamado docker.test que se expone en el puerto 56733. Finalmente, vincula el directorio actual al directorio /var/www del contenedor.

      El indicador -d se utiliza para iniciar un contenedor en el modo de demonio, o como proceso en segundo plano. El indicador -p se incluye para vincular un puerto del servidor a un puerto concreto del contenedor Docker. En este caso, vinculará el puerto 56733 al puerto 80 en el contenedor Docker. El indicador -v especifica un volumen de Docker para montarlo en el contenedor y, en este caso, usted montará todo el directorio del proyecto en la carpeta /var/www del contenedor de Docker.

      Ejecute la secuencia de comandos start.sh para crear la imagen de Docker y un contenedor a partir de la imagen resultante:

      Una vez que la secuencia de comandos termine de ejecutarse, utilice el siguiente comando para enumerar todos los contenedores en ejecución:

      Verá un resultado en el que se mostrarán los contenedores:

      Output

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 58b05508f4dd docker.test "/entrypoint.sh /sta…" 12 seconds ago Up 3 seconds 443/tcp, 0.0.0.0:56733->80/tcp docker.test

      Verá el contenedor docker.test en ejecución. Ahora que se está ejecutando, visite la dirección IP en el puerto especificado de su navegador: http://ip-address56733.

      Verá una página similar a la siguiente:

      Página de inicio

      Una vez completado este paso, habrá implementado correctamente su aplicación de Flask en Docker. A continuación, usará plantillas para mostrar el contenido a los usuarios.

      Paso 3: Presentar archivos de plantillas

      Las plantillas son archivos que muestran contenido estático y dinámico a los usuarios que visitan su aplicación. En este paso, creará una plantilla HTML con el propósito de producir una página de inicio para la aplicación.

      Comience creando un archivo home.html en el directorio app/templates:

      • sudo nano app/templates/home.html

      Añada el código para su plantilla. Con este código, se creará una página HTML5 que contiene un título y texto.

      /var/www/TestApp/app/templates/home.html

      
      <!doctype html>
      
      <html lang="en-us">   
        <head>
          <meta charset="utf-8">
          <meta http-equiv="x-ua-compatible" content="ie=edge">
          <title>Welcome home</title>
        </head>
      
        <body>
          <h1>Home Page</h1>
          <p>This is the home page of our application.</p>
        </body>
      </html>
      

      Guarde y cierre el archivo una vez que agregue su plantilla.

      A continuación, modifique el archivo app/views.py para presentar el archivo recién creado:

      Primero, añada la siguiente línea al inicio de su archivo para importar el método render_template desde Flask. Con este método se analiza un archivo HTML para presentar una página web al usuario.

      /var/www/TestApp/app/views.py

      from flask import render_template
      ...
      

      Al final del archivo, también agregará una nueva ruta para representar el archivo de plantilla. Con este código se especifica que los usuarios reciben el contenido del archivo home.html cuando visitan la ruta /template en su aplicación.

      /var/www/TestApp/app/views.py

      ...
      
      @app.route('/template')
      def template():
          return render_template('home.html')
      

      El archivo app/views.py actualizado tendrá este aspecto:

      /var/www/TestApp/app/views.py

      from flask import render_template
      from app import app
      
      @app.route('/')
      def home():
          return "Hello world!"
      
      @app.route('/template')
      def template():
          return render_template('home.html')
      

      Guarde y cierre el archivo cuando termine.

      Para que estos cambios se apliquen, deberá detener y reiniciar los contenedores de Docker. Ejecute el siguiente comando para volver a compilar el contenedor:

      • sudo docker stop docker.test && sudo docker start docker.test

      Visite su aplicación en http://your-ip-address:56733/template para ver la nueva plantilla que se presenta.

      Página de inicio

      Con esto, habrá creado un archivo de plantilla de Docker que se presentará a los visitantes de su aplicación. En el siguiente paso, verá cómo los cambios que realice a su aplicación pueden aplicarse sin necesidad de reiniciar el contenedor de Docker.

      Paso 4: Actualizar la aplicación

      A veces, deberá realizar en la aplicación cambios que pueden incluir instalar nuevos requisitos, actualizar el contenedor de Docker o aplicar modificaciones vinculadas al HTML y a la lógica. A lo largo de esta sección, configurará touch-reload para realizar estos cambios sin necesidad de reiniciar el contenedor de Docker.

      autoreloading de Python controla el sistema completo de archivos en busca de cambios y actualiza la aplicación cuando detecta uno. No se aconseja el uso de autoreloading en producción porque puede llegar a utilizar muchos recursos de forma muy rápida. En este paso, utilizará touch-reload para realizar la verificación en busca de cambios en un archivo concreto y volver a cargarlo cuando se actualice o sustituya.

      Para implementar esto, abra su archivo uwsgi.ini:

      A continuación, añada la línea resaltada al final del archivo:

      /var/www/TestApp/uwsgi.ini

      module = main
      callable = app
      master = true
      touch-reload = /app/uwsgi.ini
      

      Esto especifica un archivo que se modificará para activar una recarga completa de la aplicación. Una vez que realice los cambios, guarde y cierre el archivo.

      Para demostrar esto, realice un pequeño cambio a su aplicación. Comience abriendo su archivo app/views.py:

      Sustituya la secuencia de comandos mostrada por la función home:

      /var/www/TestApp/app/views.py

      from flask import render_template
      from app import app
      
      @app.route('/')
      def home():
          return "<b>There has been a change</b>"
      
      @app.route('/template')
      def template():
          return render_template('home.html')
      

      Guarde y cierre el archivo después de realizar un cambio.

      A continuación, si abre la página de inicio de su aplicación en http://ip-address56733<^> observará que los cambios no se reflejan. Esto se debe a que la condición para volver a cargar es un cambio en el archivo uwsgi.ini. Para volver a cargar la aplicación, use touch a fin de activar la condición:

      Vuelva a cargar la página de inicio de la aplicación en su navegador. Verá que en la aplicación se incorporaron los cambios:

      Página de inicio actualizada

      Al completar este paso, habrá configurado una condición touch-reload para actualizar su aplicación tras realizar cambios.

      Conclusión

      A través de este tutorial, creó una aplicación de Flask y la implementó en un contenedor de Docker. También configuró touch-reload para actualizar su aplicación sin necesidad de reiniciar el contenedor.

      Con su nueva aplicación en Docker, ahora podrá realizar el escalamiento de forma sencilla. Para obtener más información sobre el uso de Docker, consulte su documentación oficial.



      Source link

      How To Build and Deploy a Flask Application Using Docker on Ubuntu 18.04


      O autor selecionou a Tech Education Fund para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O Docker é um aplicativo de código aberto que permite que os administradores criem, gerenciem, implantem e repliquem aplicativos usando contêineres. Os contêineres podem ser considerados como um pacote que abriga dependências que um aplicativo precisa para executar no nível do sistema operacional. Isso significa que cada aplicativo implantado usando o Docker vive em um ambiente próprio e seus requisitos são tratados separadamente.

      O Flask é um microframework Web que é construído em Python. Ele é chamado de microframework porque não precisa de ferramentas específicas ou plugins para funcionar. O framework Flask é leve e flexível e, ainda sim, altamente estruturado, tornando-o preferido em relação a outros frameworks.

      Implantar um aplicativo Flask com o Docker permitirá que você replique o aplicativo em diferentes servidores com uma reconfiguração mínima.

      Neste tutorial, você criará um aplicativo Flask e irá implantá-lo com o Docker. Este tutorial também irá tratar sobre como atualizar um aplicativo após a implantação.

      Pré-requisitos

      Para seguir este tutorial, você precisará do seguinte:

      Passo 1 — Configurando o aplicativo Flask

      Para começar, você criará uma estrutura de diretórios que irá reter seu aplicativo Flask. Neste tutorial será criado um diretório chamado TestApp em /var/www, mas é possível modificar o comando para nomeá-lo como quiser.

      • sudo mkdir /var/www/TestApp

      Vá até o diretório TestApp recém-criado:

      Em seguida, crie a estrutura base da pasta para o aplicativo Flask:

      • sudo mkdir -p app/static app/templates

      A sinalização -p indica que o mkdir criará um diretório e todos os diretórios pais que não existam. Neste caso, o mkdir criará o diretório pai app enquanto cria os diretórios static e templates.

      O diretório app abrigará todos os arquivos relacionados ao aplicativo Flask como suas visualizações e blueprints (planos gráficos). As visualizações são o código que você escreve para responder aos pedidos para seu aplicativo. Os Blueprints criam componentes do aplicativo e oferecem suporte aos padrões comuns dentro de um aplicativo ou de vários aplicativos.

      O diretório static é onde estão os ativos como imagens, CSS e arquivos JavaScript. O diretório templates é onde você irá colocar os modelos HTML do seu projeto.

      Agora que a estrutura base de pasta está completa, crie os arquivos necessários para executar o aplicativo Flask. Primeiro, crie um arquivo __init__.py dentro do diretório app. Esse arquivo informa o programa interpretador do Python que o diretório app é um pacote e deve ser tratado como tal.

      Execute o comando a seguir para criar o arquivo:

      • sudo nano app/__init__.py

      Os pacotes no Python permitem que você agrupe os módulos em namespaces ou hierarquisas lógicos. Esta abordagem permite que o código seja dividido em blocos individuais e gerenciáveis que desempenham funções específicas.

      Em seguida, adicione código ao __init__.py que criará uma instância de Flask e importará a lógica do arquivo views.py, que você criará após salvar este arquivo. Adicione o código a seguir ao seu novo arquivo:

      /var/www/TestApp/__init__.py

      from flask import Flask
      app = Flask(__name__)
      from app import views
      

      Uma vez adicionado tal código, salve e feche o arquivo.

      Com o arquivo __init__.py criado, está tudo pronto para criar o arquivo views.py no diretório app. Este arquivo conterá a maior parte da lógica do seu aplicativo.

      Em seguida, adicione o código ao seu arquivo views.py. Esse código retornará a string hello world! para os usuários que visitarem sua Web page:

      /var/www/TestApp/app/views.py

      from app import app
      
      @app.route('/')
      def home():
         return "hello world!"
      

      A linha @app.route acima da função é chamada de decorador. Os decoradores modificam a função que as segue. Neste caso, os decoradores avisam ao Flask qual URL irá desencadear a função home(). O texto hello world retornado pela função home será exibido para o usuário no navegador.

      Com o arquivo views.py funcionando, estamos prontos para criar o arquivo uwsgi.ini. O arquivo terá as configurações uWSGI para o nosso aplicativo. A uWSGI é uma opção de implantação do Nginx que é um protocolo e um servidor do aplicativo ao mesmo tempo; o servidor do aplicativo pode atender os protocolos uWSGI, FastCGI e HTTP.

      Para criar esse arquivo, execute o seguinte comando:

      Em seguida, adicione o conteúdo seguinte ao seu arquivo para, assim, configurar o servidor do uWSGI:

      /var/www/TestApp/uwsgi.ini

      [uwsgi]
      module = main
      callable = app
      master = true
      

      Este código define o módulo que irá servir o aplicativo Flask. Neste caso, trata-se do arquivo main.py, referenciado aqui como main. A opção callable manda o uWSGI usar a instância app exportada pelo aplicativo principal. A opção master permite que seu aplicativo permaneça funcionando, de modo a reduzir o tempo de paralisação ao recarregar o aplicativo inteiro.

      Em seguida, crie o arquivo main.py, que é o ponto de entrada para o aplicativo. O ponto de entrada diz ao uWSGI como interagir com o aplicativo.

      Em seguida, copie e cole o seguinte no arquivo. Este código irá importar a instância Flask chamada app do pacote do aplicativo que foi criado anteriormente.

      /var/www/TestApp/main.py

      from app import app
      

      Por fim, crie um arquivo requirements.txt para especificar as dependências que o gerenciador de pacotes pip instalará para sua implantação do Docker:

      • sudo nano requirements.txt

      Adicione a seguinte linha para adicionar o Flask como uma dependência:

      /var/www/TestApp/app/requirements.txt

      Flask==1.0.2
      

      Isso especifica a versão do Flask a ser instalada. No momento em que este tutorial está sendo escrito, a versão 1.0.2 é a versão do Flask mais recente. Você pode verificar as atualizações no site oficial do Flask.

      Salve e feche o arquivo. Você configurou o aplicativo Flask com sucesso e está pronto para configurar o Docker.

      Passo 2 — Configurando o Docker

      Neste passo, serão criados dois arquivos, o Dockerfile e o start.sh, para criar sua implantação do Docker. O Dockerfile é um documento de texto que contém os comandos usados para montar a imagem. O arquivo start.sh é um script shell que irá construir uma imagem e criará um contêiner do Dockerfile.

      Primeiramente, crie o Dockerfile.

      Em seguida, adicione a configuração desejada ao Dockerfile. Estes comandos especificam como a imagem será construída e quais requisitos extras serão incluídos.

      /var/www/TestApp/Dockerfile

      FROM tiangolo/uwsgi-nginx-flask:python3.6-alpine3.7
      RUN apk --update add bash nano
      ENV STATIC_URL /static
      ENV STATIC_PATH /var/www/app/static
      COPY ./requirements.txt /var/www/requirements.txt
      RUN pip install -r /var/www/requirements.txt
      

      Neste exemplo, a imagem do Docker será construída a partir de uma imagem existente, a tiangolo/uwsgi-nginx-flask, que pode ser encontrada no DockerHub. Esta imagem do Docker em particular é uma boa escolha dentre as outras pois ela oferece suporte a uma ampla gama de versões do Python e imagens de SO.

      As duas primeiras linhas especificam a imagem pai que será usada para executar o aplicativo e instalar o processador de comando bash, assim como o editor de texto nano. O aplicativo também irá instalar o cliente git para extração e envio para as plataformas de hospedagem com controle de versão tais como GitHub, GitLab e Bitbucket. A ENV STATIC_URL/static é uma variável de ambiente específica para essa imagem do Docker. Ela define a pasta estática onde todos os ativos como imagens, arquivos CSS e arquivos JavaScript são atendidos.

      As duas últimas linhas irão copiar o arquivo requirements.txt para o contêiner, de modo a que ele possa ser executado e, em seguida, analisar o arquivo requirements.txt para instalar as dependências especificadas.

      Salve e feche o arquivo após adicionar sua configuração.

      Com seu Dockerfile funcionando, está quase tudo pronto para escrever seu script start.sh que construirá o contêiner do Docker. Antes de escrever o script start.sh, certifique-se primeiro de que você tenha uma porta aberta para usar na configuração. Para verificar se uma porta está livre, execute o seguinte comando:

      • sudo nc localhost 56733 < /dev/null; echo $?

      Se o resultado do comando acima for 1, então a porta está livre e pode ser usada. Caso contrário, será necessário escolher uma porta diferente para usar no seu arquivo de configuração start.sh.

      Assim que você tiver encontrado uma porta aberta para usar, crie o script start.sh:

      O script start.sh é um script shell que irá construir uma imagem do Dockerfile e criar um contêiner a partir da imagem do Docker resultante. Adicione sua configuração ao novo arquivo:

      /var/www/TestApp/start.sh

      #!/bin/bash
      app="docker.test"
      docker build -t ${app} .
      docker run -d -p 56733:80 
        --name=${app} 
        -v $PWD:/app ${app}
      

      A primeira linha é chamada de shebang. Ela especifica que este é um arquivo bash e ele será executado como comando. A linha seguinte especifica o nome que você quer dar à imagem e ao contêiner e salva o arquivo como uma variável chamada app. A próxima linha de comando manda o Docker construir uma imagem a partir do seu Dockerfile, localizado no diretório atual. Neste exemplo, a linha de código criará uma imagem chamada docker.test.

      As três últimas linhas criam um novo contêiner chamado docker.test que está exposto na porta 56733. Por fim, ele vincula o diretório atual ao diretório /var/www do contêiner.

      Você usará o sinalizador -d para iniciar um contêiner no modo daemon ou para iniciar como um processo em segundo plano. Incluirá o sinalizador -p para vincular uma porta no servidor a uma porta em particular no contêiner do Docker. Neste caso, você está ligando a porta 56733 à porta 80 no contêiner do Docker. O sinalizador -v especifica um volume do Docker para ser montado no contêiner e, neste caso, você estará montando o diretório de projeto inteiro na pasta /var/www no contêiner do Docker.

      Execute o script start.sh para criar a imagem do Docker e construir um contêiner a partir da imagem resultante:

      Assim que o script terminar de executar, use o comando a seguir para listar todos os contêineres em execução:

      Você receberá um resultado que mostra os contêineres:

      Output

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 58b05508f4dd docker.test "/entrypoint.sh /sta…" 12 seconds ago Up 3 seconds 443/tcp, 0.0.0.0:56733->80/tcp docker.test

      Você verá que o contêiner docker.test está em execução. Agora que ele está em execução, acesse o endereço IP na porta especificada no seu navegador: http://ip-address:56733

      Você verá uma página parecida com a que segue:

      A página principal

      Neste passo, seu aplicativo Flask foi implementado no Docker com sucesso. Em seguida, você usará modelos para mostrar o conteúdo aos usuários.

      Passo 3 — Servindo arquivos de modelos

      Os modelos são arquivos que mostram o conteúdo estático e dinâmico aos usuários que visitam seu aplicativo. Neste passo, você criará um modelo HTML para criar uma página inicial para o aplicativo.

      Comece criando um arquivo home.html no diretório app/template:

      • sudo nano app/templates/home.html

      Adicione o código ao seu template. Este código irá criar uma página HTML5 que contém um título e algum texto nele.

      /var/www/TestApp/app/templates/home.html

      
      <!doctype html>
      
      <html lang="en-us">   
        <head>
          <meta charset="utf-8">
          <meta http-equiv="x-ua-compatible" content="ie=edge">
          <title>Welcome home</title>
        </head>
      
        <body>
          <h1>Home Page</h1>
          <p>This is the home page of our application.</p>
        </body> 
      </html>
      

      Salve e feche o arquivo assim que tiver adicionado o seu modelo.

      Em seguida, modifique o arquivo app/views.py para atender o arquivo recém-criado:

      Primeiramente, adicione a seguinte linha no início do seu arquivo para importar o método render_template do Flask. Este método analisa um arquivo HTML para renderizar uma página da Web para o usuário.

      /var/www/TestApp/app/views.py

      from flask import render_template
      ...
      

      No final do arquivo, você também irá adicionar uma nova rota para renderizar o arquivo do modelo. Este código especifica que os usuários recebem o conteúdo do arquivo home.html sempre que visitam a rota /template em seu aplicativo.

      /var/www/TestApp/app/views.py

      ...
      
      @app.route('/template')
      def template():
          return render_template('home.html')
      

      O arquivo atualizado app/views.py se parecerá com isto:

      /var/www/TestApp/app/views.py

      from flask import render_template
      from app import app 
      
      @app.route('/')
      def home():
          return "Hello world!"
      
      @app.route('/template')
      def template():
          return render_template('home.html')
      

      Salve e feche o arquivo quando terminar.

      Para que estas alterações passar a vigorar, será necessário parar e reiniciar os contêineres do Docker. Execute o comando a seguir para criar o contêiner novamente:

      • sudo docker stop docker.test && sudo docker start docker.test

      Visite seu aplicativo em http://your-ip-address:56733/template para ver o novo modelo sendo mostrado.

      homepage

      Neste passo, você criou um arquivo modelo do Docker para atender os visitantes em seu aplicativo. No próximo passo, você verá como as alterações que você faz em seu aplicativo podem entrar em vigor sem a necessidade de reiniciar o contêiner do Docker.

      Passo 4 — Atualizando o aplicativo

      Às vezes, você terá que fazer alterações no aplicativo, seja instalando novos requisitos, atualizando o contêiner do Docker ou do HTML e as alterações de lógica. Nesta seção, você irá configurar o touch-reload para fazer essas alterações sem precisar reiniciar o contêiner do Docker.

      O autoreloading do Python monitora todo o sistema de arquivos quanto a alterações e atualiza o aplicativo quando detecta uma mudança. Desencorajamos o uso do autoreloading em produção porque ele pode se tornar um recurso intensivo rapidamente. Neste passo, você usará o touch-reload para monitorar as alterações em um arquivo em particular e recarregar quando o arquivo for atualizado ou substituído.

      Para implementar isso, abra seu arquivo uwsgi.ini:

      Em seguida, adicione a linha destacada ao final do arquivo:

      /var/www/TestApp/uwsgi.ini

      module = main
      callable = app
      master = true
      touch-reload = /app/uwsgi.ini
      

      Ela especifica um arquivo que será modificado para desencadear o recarregamento de um aplicativo inteiro. Uma vez feitas as mudanças, salve e feche o arquivo.

      Como uma demonstração, faça uma pequena alteração no seu aplicativo. Comece abrindo seu arquivo app/views.py:

      Substitua a string retornada pela função home:

      /var/www/TestApp/app/views.py

      from flask import render_template
      from app import app
      
      @app.route('/')
      def home():
          return "<b>There has been a change</b>"
      
      @app.route('/template')
      def template():
          return render_template('home.html')
      

      Salve e feche o arquivo após fazer uma mudança.

      Em seguida, se abrir a página inicial do seu aplicativo em http://ip-address:56733, você verá que as mudanças não estão refletidas. Isso acontece porque a condição para que o recarregamento ocorra é uma alteração feita ao arquivo uwsgi.ini. Para recarregar o aplicativo,utilize a opção touch para ativar a condição:

      Recarregue a homepage do aplicativo em seu navegador novamente. Você verá que o aplicativo incorporou as mudanças:

      Pagina inicial atualizada

      Neste passo, você configurou uma condição touch-reload para atualizar seu aplicativo após fazer alterações.

      Conclusão

      Neste tutorial, você criou e implantou um aplicativo Flask em um contêiner do Docker. Você também configurou o touch-reload para atualizar seu aplicativo sem a necessidade de reiniciar o contêiner.

      Com o seu novo aplicativo em Docker, agora é possível dimensionar com facilidade. Para aprender mais sobre como usar o Docker, verifique sua documentação oficial.



      Source link