Aplicación Dockerizing Flask usando Docker en Debian 10

Docker es una herramienta de código abierto diseñada para facilitar la creación, implementación y ejecución de aplicaciones mediante el uso de contenedores. Un contenedor es un paquete de software que empaqueta el código y todas sus dependencias para que la aplicación se ejecute de manera rápida y confiable de un entorno informático a otro.

Flask es un marco web popular de Python. Se clasifica como un microframework porque no requiere herramientas o bibliotecas particulares. En comparación con otros marcos, es liviano y altamente estructurado.

En este tutorial, explicaremos cómo implementar la aplicación Flask con Docker en el servidor Debian 10.

requisitos previos

• Un servidor que ejecuta Debian 10.
• Una contraseña de root está configurada en su servidor.

Empezando

Antes de comenzar, es una buena idea actualizar el paquete de su sistema a la última versión. Puede actualizar todos los paquetes con el siguiente comando:

apt-get update -y
apt-get upgrade -y

Una vez que todos los paquetes estén actualizados, reinicie su sistema para aplicar los cambios.

Instalar las dependencias requeridas

A continuación, deberá instalar el servidor web Nginx y otras dependencias en su sistema. Puede instalarlos todos usando el siguiente comando:

apt-get install nginx apt-transport-https ca-certificates curl gnupg2 software-properties-common curl -y

Una vez que todos los paquetes estén instalados, puede continuar con el siguiente paso.

Instalar ventana acoplable

De forma predeterminada, la última versión de Docker no está disponible en el repositorio de Debian 10. Por lo que es buena idea instalarlo desde el repositorio oficial de Docker.

Primero, descargue y agregue la clave GPG con el siguiente comando:

wget https://download.docker.com/linux/debian/gpg apt-key add gpg

A continuación, agregue el repositorio de Docker con el siguiente comando:

add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian buster stable"

A continuación, actualice el repositorio e instale Docker con el siguiente comando:

apt-get update -y
apt-get install docker-ce -y

Una vez que la instalación se haya completado con éxito, verifique el estado del Docker con el siguiente comando:

systemctl status docker

Deberías obtener el siguiente resultado:

? docker.service - Docker Application Container Engine
   Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
   Active: active (running) since Sun 2020-04-19 06:26:25 UTC; 1min 8s ago
     Docs: https://docs.docker.com
 Main PID: 8883 (dockerd)
    Tasks: 10
   Memory: 46.6M
   CGroup: /system.slice/docker.service
           ??8883 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

Apr 19 06:26:24 debian10 dockerd[8883]: time="2020-04-19T06:26:24.413828757Z" level=warning msg="Your kernel does not support swap memory limit
Apr 19 06:26:24 debian10 dockerd[8883]: time="2020-04-19T06:26:24.413876690Z" level=warning msg="Your kernel does not support cgroup rt period"
Apr 19 06:26:24 debian10 dockerd[8883]: time="2020-04-19T06:26:24.413889604Z" level=warning msg="Your kernel does not support cgroup rt runtime
Apr 19 06:26:24 debian10 dockerd[8883]: time="2020-04-19T06:26:24.414115814Z" level=info msg="Loading containers: start."
Apr 19 06:26:24 debian10 dockerd[8883]: time="2020-04-19T06:26:24.788332166Z" level=info msg="Default bridge (docker0) is assigned with an IP a
Apr 19 06:26:24 debian10 dockerd[8883]: time="2020-04-19T06:26:24.972022325Z" level=info msg="Loading containers: done."
Apr 19 06:26:25 debian10 dockerd[8883]: time="2020-04-19T06:26:25.010940205Z" level=info msg="Docker daemon" commit=afacb8b7f0 graphdriver(s)=o
Apr 19 06:26:25 debian10 dockerd[8883]: time="2020-04-19T06:26:25.011145541Z" level=info msg="Daemon has completed initialization"
Apr 19 06:26:25 debian10 systemd[1]: Started Docker Application Container Engine.
Apr 19 06:26:25 debian10 dockerd[8883]: time="2020-04-19T06:26:25.074603639Z" level=info msg="API listen on /var/run/docker.sock"

En este punto, Docker está instalado y ejecutándose. Ahora puede continuar con el siguiente paso.

Configuración de la estructura del directorio del matraz

A continuación, deberá crear una estructura de directorios para albergar su aplicación Flask.

Vamos a crear un directorio llamado matraz dentro del directorio /var/www/:

mkdir -p /var/www/flask

A continuación, cambie el directorio a un matraz y cree la estructura de directorios para el matraz:

cd /var/www/flask
mkdir -p app/static
mkdir -p app/templates

El directorio estático se usa para almacenar imágenes, CSS y archivos JavaScript, mientras que el directorio de plantillas se usa para almacenar las plantillas HTML para su proyecto.

A continuación, deberá crear un archivo __init__.py dentro del directorio de la aplicación:

nano app/__init__.py

Agregue los siguientes contenidos para crear una instancia de Flask e importe la lógica desde el archivo views.py:

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

Guarde y cierre el archivo, luego cree el archivo views.py en el directorio de su aplicación.

nano app/views.py

Agrega las siguientes líneas

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

Guarde y cierre el archivo, luego cree el archivo uwsgi.ini con el siguiente comando:

nano uwsgi.ini

Este archivo contendrá las configuraciones de uWSGI para nuestra aplicación como se muestra a continuación:

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

Guarde y cierre el archivo cuando haya terminado. uWSGI es una opción de implementación para Nginx que es tanto un protocolo como un servidor de aplicaciones.

A continuación, deberá crear el archivo main.py para importar la instancia de Flask llamada app desde el paquete de la aplicación. Puedes crearlo con el siguiente comando:

nano main.py

Agregue la siguiente línea:

from app import app

Guarde y cierre el archivo cuando haya terminado. A continuación, cree un archivo requirements.txt para especificar las dependencias que el administrador de paquetes pip instalará en su implementación de Docker:

nano requirements.txt

Agregue la siguiente línea que coincida con la última versión de Flask:

Flask==1.1.2

Guarde y cierre el archivo cuando haya terminado.

En este punto, su aplicación Flask se ha configurado correctamente. Ahora puede continuar con el siguiente paso.

Configurar Docker para implementar Flask

A continuación, deberá crear un Dockerfile para compilar e implementar una aplicación de matraz.

Primero, crea un Dockerfile con el siguiente comando:

cd /var/www/flask
nano Dockerfile

Agregue las siguientes líneas:

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

Guarde y cierre el archivo cuando haya terminado. A continuación, cree una secuencia de comandos start.sh para crear una imagen a partir de Dockerfile y cree un contenedor a partir de la imagen de Docker resultante.

nano start.sh

Agregue la siguiente línea:

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

Guarde y cierre el archivo cuando haya terminado.

Nota : Asegúrese de que el puerto 56733 esté libre y utilizable.

Finalmente, ejecute el script usando el siguiente comando:

bash start.sh

Esto creará la imagen de Docker y construirá un contenedor a partir de la imagen resultante como se muestra a continuación:

Sending build context to Docker daemon  9.728kB
Step 1/6 : FROM tiangolo/uwsgi-nginx-flask:python3.6-alpine3.7
python3.6-alpine3.7: Pulling from tiangolo/uwsgi-nginx-flask
48ecbb6b270e: Pull complete 
692f29ee68fa: Pull complete 
f75fc7ac1098: Pull complete 
c30e40bb471c: Pull complete 
Successfully built f5de17e1ce82
Successfully tagged docker.test:latest
22cd2bd23c9190cf2900fa1d7c55e4765a266e68c74dc1e6858872e9ebe7bdcd

Ahora puede enumerar los contenedores en ejecución con el siguiente comando:

docker ps

Deberías obtener el siguiente resultado:

CONTAINER ID        IMAGE               COMMAND                  CREATED              STATUS              PORTS                            NAMES
22cd2bd23c91        docker.test         "/entrypoint.sh /sta…"   About a minute ago   Up About a minute   443/tcp, 0.0.0.0:56733->80/tcp   docker.test

También puede verificar el contenedor Docker visitando la URL http://your-server-ip:56733. Debería ver la siguiente pantalla:

Implementar archivos de plantilla

También puede implementar archivos de plantilla para servir contenido estático y dinámico. Puede crear una plantilla de página de inicio para su aplicación con el siguiente comando:

nano app/templates/home.html

Agrega los siguientes códigos:

<!doctype html>

<html lang="en-us">
  <head>
    <meta charset="utf-8">
    <meta http-equiv="x-ua-compatible" content="ie=edge">
    <title>Welcome Flask</title>
  </head>

  <body>
    <h1>Home Page</h1>
    <p>This is the home page of our flask application.</p>
  </body>
</html>

Guarde y cierre el archivo cuando haya terminado. A continuación, deberá modificar el archivo views.py para servir el archivo recién creado:

nano app/views.py

Actualice el archivo como se muestra a continuación:

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. Luego, deberá reiniciar los contenedores de Docker para aplicar los cambios.

Puede reiniciar el contenedor Docker llamado docker.test con el siguiente comando:

docker stop docker.test
docker start docker.test

Ahora, abra su navegador web y escriba la URL http://your-server-ip:56733/template. Debería ver su plantilla recién creada en la siguiente pantalla:

Conclusión

¡Felicidades! Ha implementado con éxito una aplicación Flask con Docker en el servidor Debian 10. Ahora puede replicar la aplicación en diferentes servidores con una reconfiguración mínima. No dude en preguntarme si tiene alguna pregunta.