Déployer une application Flask avec Dokku

Dokku est une plate-forme en tant que service (PaaS) auto-hébergée qui simplifie le déploiement d'applications à l'aide de Git. Bien que l'implémentation de Dokku soit similaire à Heroku, il lui manque certaines fonctionnalités clés telles que la mise à l'échelle automatique. Dokku est un outil extrêmement puissant qui exécute automatiquement votre application dans Docker et nécessite une configuration minimale des serveurs Web.

Ce guide montre comment :

Créez une application Flask qui renvoie "Hello World !" sur la page d'index
Installer Dokku sur un Linode
Déployer une application Flask avec un serveur WSGI dans un conteneur Docker
Ajouter un certificat SSL via Dokku avec le plug-in Let's Encrypt

Avant de commencer

Sur votre ordinateur local

Remarque Dokku v0.12.5 est compatible avec Ubuntu 16.04 x64, Ubuntu 14.04 x64 et Debian 8.2 x64. CentOS 7 x64 n'est pris en charge qu'à titre expérimental et, à ce titre, certaines étapes telles que la configuration des clés SSH et des hôtes virtuels doivent être effectuées manuellement à l'aide de l'interface de ligne de commande dokku. Voir la documentation officielle pour plus d'informations.

Une clé publique est supposée disponible. Généralement, il se trouve dans ~/home/username/.ssh/id_rsa.pub .

Installez Git si nécessaire :

sudo apt install git

Sur votre Linode

Le script d'installation de Dokku crée un dokku utilisateur sur le système, installe Docker et extrait l'image appropriée.

Téléchargez le script d'installation depuis Dokku puis exécutez le 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.
...

Accédez à l'adresse IP publique de votre Linode dans un navigateur et entrez la clé publique :

Attention Ajoutez la clé publique immédiatement après avoir exécuté le script d'installation pour éviter que quelqu'un d'autre n'ajoute une clé publique à Dokku. Pour une installation sans assistance, reportez-vous aux instructions d'installation avancées.
Pour ajouter des clés SSH supplémentaires, dirigez la sortie via SSH vers le dokku utilisateur. Remplacez example.com avec l'adresse IP de votre Linode.
```
cat ~/.ssh/id_rsa.pub | ssh [email protected] ssh-keys:add new-key
```

Créer une application Flask

Sur votre ordinateur local, créez un nouveau répertoire de projet :
```
mkdir flask-example && cd flask-example
```

Créez un nouveau fichier appelé hello_world.py qui sert "Hello World !" sur la page d'index.

Fichier :hello_world .py

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)

Ajouter un requirements.txt fichier pour suivre les versions de toutes les dépendances de l'application Flask. Gunicorn est le serveur WSGI utilisé pour permettre à Flask de s'interfacer correctement avec NGINX.
Fichier :exigences .txt
1 2

Flask==0.12.1 gunicorn==19.7.1
Pour les projets plus complexes avec de nombreuses dépendances utilisant un environnement virtuel, redirigez la sortie de pip freeze dans requirements.txt .
```
pip freeze > requirements.txt
```

Ajouter un gitignore

Ajoutez éventuellement un .gitignore pour que Git omette la mise en cache et les fichiers d'environnement virtuel du contrôle de version.

Fichier :. gitignore

__pycache__/
*.pyc

venv/

Procfile

Le Procfile indique au serveur Gunicorn quelle commande utiliser lors du lancement de l'application :

Fichier :Procfile

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

Remarque 4 workers est une bonne valeur par défaut pour une application Web exécutée sur un Linode. Consultez la documentation Gunicorn pour plus d'informations sur la détermination du nombre correct de travailleurs pour votre application particulière.

Git Remote

Initialiser un dépôt Git :

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

Ajouter une télécommande nommée dokku avec le nom d'utilisateur dokku et remplacez example.com avec l'adresse IP publique de votre Linode :
```
git remote add dokku [email protected]:flask-example
```

Vérifiez que la télécommande est ajoutée :

git remote -v

Cela listera les télécommandes.

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

En résumé, la mise en page du projet ressemble à :

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

Créer un projet sur un hôte Dokku

Connectez-vous en SSH à votre Linode et créez l'application :
```
dokku apps:create flask-example
```
Assurez-vous que VHOST est activé.
```
dokku domains:enable flask-example
```

Déployer une application Flask

Sur votre ordinateur local, déployez l'application Flask en poussant la branche vers le dokku télécommande. Cela prendra soin de NGINX dans les coulisses et exposera le port 80 :
```
git push dokku master
```
D'autres branches locales peuvent également être déployées mais toutes les branches doivent être poussées vers la branche master du dokku télécommande :
```
git push dokku branch-name:master
```
curl l'adresse IP de votre Linode pour tester que l'application a été déployée avec succès :
```
curl example.com
```
```
Hello World!
```

Certificat SSL avec Dokku et Let's Encrypt

Les étapes restantes de ce guide doivent être effectuées à partir de votre Linode.

Installez le plugin Let's Encrypt pour Dokku :

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

Définissez le DOKKU_LETSENCRYPT_EMAIL variable d'environnement à l'e-mail pour Let's Encrypt :
```
dokku config:set flask-example [email protected]
```

Ajoutez l'application et le domaine :

dokku domains:add flask-example example.com

Créez le certificat SSL. NGINX commencera automatiquement à servir l'application via HTTPS sur le port 443 :
```
 dokku letsencrypt flask-example
```
Exécutez ceci comme une tâche cron afin que le certificat se renouvelle automatiquement :.
```
dokku letsencrypt:cron-job --add
```
Remarque Cela nécessite Dokku version 0.5 ou supérieure. Vérifiez en exécutant dokku version .

Démarrer, arrêter et redémarrer les applications

Listez toutes les applications Dokku en cours d'exécution :
```
  dokku apps
```
Redémarrez une application :
```
  dokku ps:restart flask-example
```
Arrêter une application :
```
  dokku ps:stop flask-example
```
Restaurer toutes les applications après un redémarrage :
```
  dokku ps:restore
```

Afficher les journaux des applications

Affichez les journaux d'application via Dokku ou le conteneur Docker.

Pour voir les journaux via Dokku :
```
dokku logs flask-example
```
Répertorier tous les conteneurs Docker en cours d'exécution :
```
sudo docker ps -a
```
Recherchez l'ID du conteneur, puis exécutez :
```
sudo docker logs container_id
```

Applications de mise à l'échelle

Dokku ne dimensionne pas automatiquement les applications et, par défaut, n'exécute qu'un seul web processus. Pour augmenter le nombre de conteneurs exécutant votre application, vous pouvez utiliser le ps:scale commande.

Vérifiez combien de travailleurs votre application compte actuellement :

dokku ps:scale flask-example

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

Évoluez jusqu'à 4 web processus :
```
dokku ps:scale flask-example web=4
```

Confirmez que les nouveaux processus sont en cours d'exécution :

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

Dokku est une alternative open source à Heroku pour les petites applications. Le déploiement d'applications est aussi simple que de pousser vers une télécommande avec Git. Des éléments tels que Docker et NGINX sont abstraits pour minimiser le temps de déploiement. Il existe des fonctionnalités supplémentaires telles que les crochets de pré-déploiement et les bases de données de liaison qui ne sont pas présentées dans ce guide.

Plus d'informations

Vous pouvez consulter les ressources suivantes pour plus d'informations sur ce sujet. Bien que ceux-ci soient fournis dans l'espoir qu'ils seront utiles, veuillez noter que nous ne pouvons pas garantir l'exactitude ou l'actualité des documents hébergés en externe.

Dokku PaaS
Flacon