GNU/Linux >> Tutoriales Linux > >> Panels >> Docker

Implemente una aplicación Flask con Dokku

Dokku es una plataforma como servicio (PaaS) autohospedada que simplifica la implementación de aplicaciones con Git. Aunque la implementación de Dokku es similar a la de Heroku, carece de ciertas funciones clave, como el escalado automático. Dokku es una herramienta extremadamente poderosa que ejecuta automáticamente su aplicación dentro de Docker y requiere una configuración mínima de servidores web.

Esta guía demuestra cómo:

Cree una aplicación Flask que devuelva "¡Hola mundo!" en la página de índice
Instalar Dokku en un Linode
Implemente una aplicación Flask con un servidor WSGI dentro de un contenedor Docker
Agregue un certificado SSL a través de Dokku con el complemento Let's Encrypt

Antes de comenzar

En su computadora local

Nota Dokku v0.12.5 es compatible con Ubuntu 16.04 x64, Ubuntu 14.04 x64 y Debian 8.2 x64. CentOS 7 x64 solo se admite de forma experimental y, como tal, algunos pasos, como la configuración de claves SSH y hosts virtuales, deben realizarse manualmente mediante la interfaz de línea de comandos de dokku. Consulte la documentación oficial para obtener más información.

Se supone que una clave pública está disponible. Por lo general, esto se encuentra en ~/home/username/.ssh/id_rsa.pub .

Instale Git si es necesario:

sudo apt install git

En tu Linode

El script de instalación de Dokku crea un dokku usuario en el sistema, instala Docker y extrae la imagen relevante.

Descargue el script de instalación de Dokku y luego ejecute el script:

wget https://raw.githubusercontent.com/dokku/dokku/v0.12.5/bootstrap.sh
sudo DOKKU_TAG=v0.12.5 bash bootstrap.sh

Preparing to install v0.11.6 from https://github.com/dokku/dokku.git...
For dokku to build containers, it is strongly suggested that you have 1024 megabytes or more of free memory
If necessary, please consult this document to setup swap: http://dokku.viewdocs.io/dokku/advanced-installation/#vms-with-less-than-1gb-of-memory
--> Ensuring we have the proper dependencies
--> Initial apt-get update
--> Installing docker
--> NOTE: Using Linode? Docker may complain about missing AUFS support.
    You can safely ignore this warning.
        Installation will continue in 10 seconds.
...

Navegue a la dirección IP pública de su Linode en un navegador e ingrese la clave pública:

Precaución Agregue la clave pública inmediatamente después de ejecutar el script de instalación para evitar que alguien más agregue una clave pública a Dokku. Para una instalación desatendida, consulte las instrucciones de instalación avanzada.
Para agregar claves SSH adicionales, canalice la salida a través de SSH al dokku usuario. Reemplace example.com con la dirección IP de tu Linode.
```
cat ~/.ssh/id_rsa.pub | ssh [email protected] ssh-keys:add new-key
```

Crear una aplicación Flask

En su computadora local, cree un nuevo directorio de proyecto:
```
mkdir flask-example && cd flask-example
```

Crea un nuevo archivo llamado hello_world.py que sirve "Hello World!" en la página de índice.

Archivo:hello_world .py

Agregue un requirements.txt archivo para realizar un seguimiento de las versiones de cualquier dependencia de la aplicación Flask. Gunicorn es el servidor WSGI utilizado para permitir que Flask interactúe correctamente con NGINX.

Archivo:requisitos .txt

import os

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello World!'

if __name__ == '__main__':
    # Bind to PORT if defined, otherwise default to 5000.
    port = int(os.environ.get('PORT', 5000))
    app.run(host='127.0.0.1', port=port)

Para proyectos más complejos con muchas dependencias que usan un entorno virtual, redirija la salida de pip freeze en requirements.txt .

pip freeze > requirements.txt

Añadir un gitignore

Opcionalmente, agregue un .gitignore para que Git omita el almacenamiento en caché y los archivos de entorno virtual del control de versiones.

Archivo:. gitignorar

1
2

Flask==0.12.1
gunicorn==19.7.1

Procfile

El Procfile le dice al servidor Gunicorn qué comando usar al iniciar la aplicación:

Archivo:Procfile

__pycache__/
*.pyc

venv/

Nota 4 trabajadores es un buen valor predeterminado para una aplicación web que se ejecuta en un Linode. Consulte los documentos de Gunicorn para obtener más información sobre cómo determinar la cantidad correcta de trabajadores para su aplicación en particular.

Remoto Git

Inicializar un repositorio de Git:

git init
git add .
git commit -m "Deploy Flask with Dokku"

Agregue un control remoto llamado dokku con el nombre de usuario dokku y sustituya example.com con la dirección IP pública de tu Linode:
```
git remote add dokku [email protected]:flask-example
```

Verifique que se haya agregado el control remoto:

git remote -v

Esto mostrará una lista de los controles remotos.

dokku   [email protected]:flask-example (fetch)
dokku   [email protected]:flask-example (push)

En resumen, el diseño del proyecto se ve así:

flask-example
├── .gitignore
├── Procfile
├── hello_world.py
└── requirements.txt

Crear proyecto en un Dokku Host

SSH en su Linode y cree la aplicación:
```
dokku apps:create flask-example
```
Asegúrese de que VHOST esté habilitado.
```
dokku domains:enable flask-example
```

Implementar una aplicación Flask

En su computadora local, implemente la aplicación Flask empujando la rama al dokku remoto. Esto se encargará de NGINX entre bastidores y expondrá el puerto 80 :
```
git push dokku master
```
También se pueden implementar otras ramas locales, pero todas las ramas deben enviarse a la rama maestra de dokku remoto:
```
git push dokku branch-name:master
```
curl la dirección IP de tu Linode para probar que la aplicación se implementó correctamente:
```
curl example.com
```
```
Hello World!
```

Certificado SSL con Dokku y Let's Encrypt

Los pasos restantes de esta guía deben realizarse desde su Linode.

Instale el complemento Let's Encrypt para Dokku:

sudo dokku plugin:install https://github.com/dokku/dokku-letsencrypt.git

Establecer el DOKKU_LETSENCRYPT_EMAIL variable de entorno al correo electrónico de Let's Encrypt:
```
dokku config:set flask-example [email protected]
```

Agregue la aplicación y el dominio:

dokku domains:add flask-example example.com

Cree el certificado SSL. NGINX automáticamente comenzará a servir la aplicación a través de HTTPS en el puerto 443:
```
 dokku letsencrypt flask-example
```
Ejecute esto como un trabajo cron para que el certificado se renueve automáticamente:.
```
dokku letsencrypt:cron-job --add
```
Nota Esto requiere Dokku versión 0.5 o superior. Compruébalo ejecutando dokku version .

Iniciar, detener y reiniciar aplicaciones

Enumere todas las aplicaciones Dokku en ejecución:
```
  dokku apps
```
Reiniciar una aplicación:
```
  dokku ps:restart flask-example
```
Detener una aplicación:
```
  dokku ps:stop flask-example
```
Restaurar todas las aplicaciones después de reiniciar:
```
  dokku ps:restore
```

Ver registros de aplicaciones

Vea los registros de la aplicación a través de Dokku o el contenedor Docker.

Para ver registros a través de Dokku:
```
dokku logs flask-example
```
Enumere todos los contenedores Docker en ejecución:
```
sudo docker ps -a
```
Encuentre el ID del contenedor y luego ejecute:
```
sudo docker logs container_id
```

Aplicaciones de escala

Dokku no escala las aplicaciones automáticamente y, de forma predeterminada, solo ejecutará una única web proceso. Para aumentar la cantidad de contenedores que ejecutan su aplicación, puede usar ps:scale comando.

Compruebe cuántos trabajadores tiene actualmente su aplicación:

dokku ps:scale flask-example

-----> Scaling for flask-example
-----> proctype           qty
-----> --------           ---
-----> web                1

Escale hasta 4 web procesos:
```
dokku ps:scale flask-example web=4
```

Confirme que los nuevos procesos se están ejecutando:

-----> Scaling for flask-example
-----> proctype           qty
-----> --------           ---
-----> web                4

Dokku es una alternativa de código abierto a Heroku para aplicaciones pequeñas. Implementar aplicaciones es tan simple como presionar un control remoto con Git. Elementos como Docker y NGINX se abstraen para minimizar el tiempo de implementación. Hay funciones adicionales, como enlaces previos a la implementación y vinculación de bases de datos, que no se muestran en esta guía.

Más información

Es posible que desee consultar los siguientes recursos para obtener información adicional sobre este tema. Si bien estos se proporcionan con la esperanza de que sean útiles, tenga en cuenta que no podemos garantizar la precisión o la puntualidad de los materiales alojados externamente.

Dokku PaaS
frasco

Instrumentación de contenedores con el Elastic Stack

Acceda a un servidor web Apache dentro de un contenedor LXD

Docker

Cómo implementar pilas de Docker Compose en Kubernetes con Kompose

Cómo implementar una aplicación API de Python Flask en Docker

Cómo implementar CouchDB como un clúster con Docker

Cómo implementar aplicaciones completas rápidamente con las plantillas de aplicaciones de Portainer

Node.js cPanel:cómo implementar una aplicación

¿Cómo implementar la aplicación Laravel con Nginx en Ubuntu?

`1`	`web: gunicorn hello_world:app --workers=4`