Flask en marche

FlaconGitGitOpsCLIconfiguration

Cet article est également disponible en Anglais.

Ce guide fournit des instructions pour déployer et travailler avec Flask - unframework web léger et populaire pour construire des applications web en utilisant Python - sur Upsun. Il est souvent considéré comme un micro framework car il fournit les composants essentiels pour construire des applications web mais laisse de nombreuses décisions et extensions au développeur - nous allons nous y plonger dans le contexte d'Upsun.

Si vous êtes plutôt du genre à me donner les étapes, vous pouvez passer directement au pas-à-pas inclus à la fin de ce guide.

Configuration de l'application et du référentiel

Pour les besoins de ce guide, nous commencerons par générer un projet Flask à partir de Cookiecutter, puis nous suivrons les étapes nécessaires pour déployer le projet sur Upsun. Comme pour tout ce qui touche à la technologie, il existe de nombreuses façons d'atteindre le même objectif ; la bonne façon de procéder dépendra de vos besoins et objectifs spécifiques, ainsi que de la composition de votre projet. Le guide suivant est simplement une façon de déployer une application Flask sur Upsun, mais c'est une façon qui a été testée et approuvée par notre équipe.

A partir d'un terminal ou d'une ligne de commande, installez d'abord Cookiecutter :

> pip3 install cookiecutter

Ensuite, vous devez générer le modèle Flask à partir de Cookiecutter - si c'est la première fois que vous générez un modèle Flask, vous devrez pointer vers l'adresse complète du dépôt GitHub :

> cookiecutter https://github.com/cookiecutter-flask/cookiecutter-flask.git

Sinon, vous pouvez simplement indiquer le modèle spécifique que vous souhaitez générer :

> cookiecutter cookiecutter-flask

Cookiecutter vous posera ensuite une série de 10 questions, comme vous pouvez le voir ci-dessous :

[1/10] full_name () : Paul Gilzow [2/10] email () : paul.gilzow@upsun.com [3/10] github_username () : gilzow [4/10] project_name () : my_flask_project [5/10] app_name () : my_flask_cookie [6/10] project_short_description () : Un projet de démonstration [7/10] use_pipenv () : n [8/10] python_version () : 3.11 [9/10] node_version () : 18 [10/10] use_heroku () : N

Répondez à chaque question, en faisant attention à ce que vous utilisez pour la question app_name car vous en aurez besoin plus tard. Une fois que Cookiecutter a généré le modèle, allez dans le répertoire qu'il vient de créer ; ce sera le même nom que celui que vous avez donné pour la question app_name. Pour cet exemple, je l'ai nommé my_flask_cookie et j'y ferai référence dans le reste du guide.
Vous devez initialiser le contenu de ce répertoire en tant que dépôt Git, donc avant de faire quoi que ce soit d'autre, initialisez le dépôt :

> git init .

Par défaut, Git utilisera toujours master comme nom pour la branche initiale. Si vous souhaitez changer le nom de la branche par défaut, vous pouvez le faire avec la commande git branch -m. Je vais renommer la mienne en main:

> git branch -m main

Préparation de Flask pour le déploiement d'Upsun

Maintenant que nous avons initialisé le dépôt et généré notre modèle, nous sommes prêts à le préparer pour l'utiliser sur Upsun. Avant de tenter la commande suivante, assurez-vous que l'outil CLI d'Upsun est installé et fonctionne, et que vous avez authentifié l'outil CLI avec votre compte Upsun. Une fois ces tâches accomplies, vous êtes maintenant prêt à demander à l'outil CLI d'Upsun de générer les fichiers de configuration dont nous aurons besoin pour le déploiement sur Upsun.

> upsun project:init

Remarque: cette commande est également disponible sous le nom de upsun ify.

L'outil CLI d'Upsun va maintenant vous poser une série de questions pour déterminer les besoins de votre projet, comme vous pouvez le voir ci-dessous :

> upsun project:init Bienvenue à Upsun ! Commençons par quelques questions. Nous avons besoin d'en savoir un peu plus sur votre projet. Cela ne prendra qu'une minute ! Quelle langue votre projet utilise-t-il ? Nous supportons les langages suivants : Utilisez les flèches pour monter et descendre, tapez pour filtrer C#/.Net Core Elixir Go Java Lisp JavaScript/Node.js PHP > Python Ruby

Faites défiler vers le bas et sélectionnez Python, il devrait alors détecter automatiquement votre gestionnaire de dépendances :

Quel est le langage utilisé par votre projet ? Nous prenons en charge les langages suivants : [Python] ✓ Gestionnaires de dépendances détectés : Pip

Il vous demandera alors le nom de votre application et à partir de là, il devrait vous demander les services dont votre projet a besoin. Sélectionnez chacun d'entre eux et appuyez sur Entrée. Pour cet exemple, je n'ai besoin que de PostgreSQL:

                                              (\_/) Nous avons presque terminé... =(^.^)= Enfin, à moins que vous ne créiez un site web statique, votre projet utilise des services. Définissons-les : Sélectionnez tous les services que vous utilisez : Utilisez les flèches pour vous déplacer, l'espace pour sélectionner, le type pour filtrer [ ] MariaDB [ ] MySQL > [x] PostgreSQL [ ] Redis [ ] Redis Persistent [ ] Memcached [ ] OpenSearch

Il génère ensuite une série de fichiers de configuration pour vous :

┌───────────────────────────────────────────────────┐ │ CONGRATULATIONS !                                                                                                                      │ │ │ │ Nous avons créé les fichiers suivants pour vous :                                                                         │ │ - .environment │ │ - .upsun/config.yaml │ │ │ │ Nous sautons de joie ! ⍢ │ └───────────────────────────────────────────────────┘ │ / │/2502↩ ↪So_ (\ /) ( . .) o (_(")(") Vous pouvez maintenant déployer votre application sur Upsun ! Pour cela, commitez vos fichiers et déployez votre application à l'aide de la CLI d'Upsun : $ git add . $ git commit -m 'Add Upsun configuration files' $ upsun project:set-remote $ upsun push.

Enfin, vous devez ajouter tous les fichiers générés, à la fois par Cookiecutter et par l'outil CLI d'Upsun, à votre dépôt Git :

> git add . > git commit -m "initial commit"

Avant de pouvoir déployer votre application, vous devez créer un nouveau projet sur Upsun à partir de la ligne de commande :

> upsun project:create

L'outil CLI va maintenant vous guider dans la création d'un projet en vous demandant votre organisation, le titre du projet, la région dans laquelle vous voulez que l'application soit hébergée, et le nom de la branche (utilisez le même que celui que vous avez défini plus tôt). Pour l'instant, autorisez l'outil CLI à définir Upsun en tant que référentiel distant, puis sélectionnez Y pour autoriser l'outil à créer le projet. Le robot Upsun commencera la génération de votre projet Upsun et une fois terminé, il vous rapportera les détails de votre projet, y compris l'ID du projet, et l'URL où vous pouvez gérer le projet à partir de la console webUpsun . Ne vous inquiétez pas si vous oubliez l'une de ces informations, vous pouvez les récupérer plus tard avec :

> upsun project:info

Et vous pouvez lancer la console web pour votre projet à tout moment en faisant ce qui suit :

> upsun web

Maintenant que notre projet Upsun est créé et que notre projet local est généré et associé au projet Upsun, la seule chose qu'il nous reste à faire est d'ajouter les configurations spécifiques à l'application. Pour commencer, nous devons ajouter une variable d'environnement pour FLASK_APP pour tous les environnements qui pointe vers notre fichier autoapp.py. Ouvrez le fichier config.yaml situé dans le répertoire .upsun que l'outil CLI a généré et localisez la ligne commentée qui commence par # Variables to control the environment. Nous devons décommenter les deux lignes suivantes sous cette ligne, et ajouter notre variable environnementale à la liste :

# Variables pour contrôler l'environnement. Plus d'informations : https://docs.upsun.com/create-apps/app-reference.html#variables variables : env : FLASK_APP : autoapp.py # # Ajoutez ici les variables d'environnement qui sont statiques. # PYTHONUNBUFFERED : "1"

Remarque: lorsque vous décommentez une section, assurez-vous de supprimer à la fois le marqueur de commentaire # et l'espace supplémentaire. Si vous ne supprimez pas l'espace supplémentaire, vous obtiendrez une erreur d'indentation de clé de mappage de bloc invalide lors de la validation du fichier de configuration.

Actifs statiques

Ensuite, vous allez avoir besoin d'un espace disque accessible en écriture pour contenir les ressources statiques que npm construit et que flask-static-digest génère. Ce répertoire existe sous notre paquetage d'application nommé ./<nom de l'application>/static. Dans ./.upsun/config.yml, trouvez la ligne qui commence par # Mounts define directories that are writable. Vous devrez décommenter la ligne # mounts : et ajouter une entrée décrivant l'endroit où nous voulons ajouter un montage accessible en écriture :

# Les montages définissent les répertoires qui sont accessibles en écriture une fois la construction terminée. # Plus d'informations : https://docs.upsun.com/create-apps/app-reference.html#mounts mounts : "my_flask_cookie/static" : source : "storage" 
   source_path : "static_assets"

source indique le type de montage : storage, tmp, ou service et source_path spécifie où le montage pointe dans le répertoire externe. Pour plus d'informations, veuillez consulter la documentation sur les montages.

Le crochet de construction nous permet d'apporter des modifications à l'application avant qu'elle ne soit finalisée et déployée. Vous devriez remarquer que lorsque l'outil CLI a généré le fichier de configuration pour moi plus tôt dans le processus, il a automatiquement ajouté pip install -r requirements.txt! C'est dans cette même section que vous indiquerez à Upsun d'installer vos paquets npm. Mais avant cela, j'ai l'habitude de mettre à jour pip avant de lancer pip install, je vais donc ajouter une nouvelle ligne au dessus et ajouter pip install --upgrade pip. Ensuite, je vais ajouter une autre ligne après l'installation initiale de pip et ajouter npm install:

# Les hooks vous permettent de personnaliser votre code/environnement lorsque le projet passe par les étapes de construction et de déploiement # Plus d'informations : https://docs.upsun.com/create-apps/app-reference.html#hooks hooks : # Le hook de construction est exécuté après toute saveur de construction. # Plus d'informations : https://docs.upsun.com/create-apps/hooks/hooks-comparison.html#build-hook build : | set -eux pip install --upgrade pip install -r requirements.txt npm install

Vous devez également informer Upsun de ce qui doit se passer lorsque votre application est déployée. Le hook de déploiement est similaire au hook de construction mais s'exécute après que l'image de l'application ait été construite. A ce stade, l'image de l'application est en lecture seule, mais votre espace disque accessible en écriture a été monté et est maintenant accessible. Trouvez la clé deploy : YAML, ajoutez une nouvelle ligne après set -eux, et ajoutez npm run build.

# Le crochet de déploiement est exécuté après le démarrage du conteneur d'application, mais avant qu'il ne commence à accepter des requêtes. deploy : | set -eux npm run build

Ensuite, nous devons configurer la façon dont Upsun va gérer les requêtes vers cette image d'application. Dans ./.upsun/config.yaml localisez la ligne qui commence par # La clé web configure le serveur web qui tourne en face de votre application. Sous cette ligne, il devrait y avoir une propriété YAML de commands :. Quelques lignes plus bas, il y aura une propriété YAML de start :. Encore une fois, l'outil CLI a déjà ajouté quelques informations ici, mais comme il ne connaît pas les spécificités de ce qui doit être utilisé, il a simplement laissé des instructions que vous devez remplacer par votre propre commande start. Pour l'instant, vous n'avez besoin que du serveur Flask de base, donc remplacez le contenu actuel par flask run -p $PORT.

web : # Les commandes sont lancées une fois après le déploiement pour démarrer le processus d'application. # Plus d'informations : https://docs.upsun.com/create-apps/app-reference.html#web-commands commands : # La commande pour lancer votre application. Vous pouvez utiliser la variable d'environnement $PORT ou $SOCKET en fonction de la famille de sockets de votre démarrage en amont : "flask run -p $PORT"

Puisque vous utilisez le serveur Flask (pour l'instant), vous devrez également changer la socket_family de unix à tcp:

start : "flask run -p $PORT" # Vous pouvez écouter un socket UNIX (unix) ou un port TCP (tcp, par défaut) # Si votre application doit parler au serveur web via un socket TCP ou Unix. La valeur par défaut est tcp # Plus d'informations : https://docs.upsun.com/create-apps/app-reference.html#where-to-listen upstream : # Si votre application doit parler au serveur web via un socket TCP ou Unix. La valeur par défaut est tcp # Plus d'informations : https://docs.upsun.com/create-apps/app-reference.html#where-to-listen socket_family : tcp

Nous avons maintenant ajouté toute la configuration dont Upsun a besoin pour pouvoir construire et déployer votre application ! Commençons par valider ces changements :

> git add ./upsun/config.yaml > git commit -m "adds FLASK_APP env var, adds mount for static builds, build commands, npm run build on deploy, web start command"

Préparer l'application pour Upsun

Bien que nous ayons fini de dire à Upsun ce qu'il doit faire pour construire et déployer votre application, votre application a toujours besoin de connaître certaines choses à propos d'Upsun. Ce type d'information se trouve généralement dans votre fichier .env. Upsun génère ce type de données et les expose à l'application sous forme de variables environnementales dans l'image déployée. Comme les informations sont dynamiques et changent d'un environnement à l'autre, il n'est pas souhaitable d'enregistrer ces valeurs statiques dans un fichier .env. Au lieu de cela, Upsun prend en charge un fichier .environment qui se trouve dans l'image de l'application, ainsi que dans votre shell lorsque vous vous connectez au conteneur par SSH. Pour une liste de toutes les variables générées par Upsun, veuillez vous référer à la documentation sur les variables environnementales fournies.

Ouvrez le fichier .environment que l'outil CLI a généré précédemment. Vous remarquerez qu'il a déjà créé quelques variables environnementales pour vous permettre de vous connecter à votre service de base de données. Cependant, puisque vous devrez utiliser un tunnel pour générer vos fichiers de migration, vous devez remplacer ce que l'outil CLI d'Upsun a généré, et le remplacer par ce qui suit :

export RELATIONSHIPS_JSON="$(echo $PLATFORM_RELATIONSHIPS | base64 --decode)" # Définir les variables d'environnement de la base de données export DB_HOST="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].host')" export DB_PORT="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].port')" export DB_DATABASE="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].path')" export DB_USERNAME="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].username')" export DB_PASSWORD="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].password')" export DB_CONNECTION="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].scheme')" export DATABASE_URL="postgresql://${DB_USERNAME}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_DATABASE}"

Vous devrez en ajouter d'autres pour notre application Flask afin que Flask dispose de ce dont il a besoin pour fonctionner correctement. Pour commencer, vous devez ajouter le reste des variables définies dans .env. Vous vous êtes déjà occupé de FLASK_APP dans le fichier ./.upsun/config.yaml, il reste donc ce qui suit :

FLASK_ENV
FLASK_DEBUG
LOG_LEVEL
SEND_FILE_MAX_AGE_DEFAULT
SECRET_KEY
GUNICORN_WORKERS

Upsun nous fournit des informations sur le type d'environnement dans lequel l'application s'exécute via une variable d'environnement nommée PLATFORM_ENVIRONMENT_TYPE, dont les valeurs peuvent être production, développement ou staging. Dans le fichier .environment, ajoutez la ligne suivante :

export FLASK_ENV="${PLATFORM_ENVIRONMENT_TYPE}"

Cependant, plusieurs autres variables d'environnement doivent également être modifiées, que vous soyez ou non dans un environnement de production. Vous pouvez donc exploiter les informations contenues dans PLATFORM_ENVIRONMENT_TYPE pour définir non seulement FLASK_ENV, mais également plusieurs autres variables. Vous ne voulez activer FLASK_DEBUG (1) que si vous ne travaillez pas en production. Dans le fichier .environment, ajoutez la ligne suivante :

export FLASK_DEBUG=$( [ "${PLATFORM_ENVIRONMENT_TYPE}" = "production" ] && echo 0 || echo 1)

Si l'environnement dans lequel vous vous trouvez est "production", vous retournerez 0 (désactivé), sinon vous retournerez 1 (activé). Faisons quelque chose de similaire pour LOG_LEVEL. Dans le fichier .environment, ajoutez la ligne suivante :

export LOG_LEVEL=$( [ "${PLATFORM_ENVIRONMENT_TYPE}" = "production" ] && echo "info" || echo "debug")

Si l'environnement dans lequel vous vous trouvez est la production, mettez LOG_LEVEL à "info", sinon mettez-le à "debug".

La dernière variable d'environnement qui doit être différente selon le type d'environnement est SEND_FILE_MAX_AGE_DEFAULT où nous voulons qu'elle soit à 0 si nous ne sommes pas en production, mais à une valeur plus élevée si nous le sommes. Dans le fichier .environment, ajoutez la ligne suivante :

export SEND_FILE_MAX_AGE_DEFAULT=$( [ "${PLATFORM_ENVIRONMENT_TYPE}" = "production" ] && echo 31556926 || echo 0)

La variable environnementale suivante que vous devez définir est SECRET_KEY. Elle est utilisée pour signer de manière sécurisée le cookie de session et peut être utilisée pour tout autre besoin lié à la sécurité par les extensions ou votre application. Il doit s'agir d'une longue chaîne aléatoire. Encore une fois, Upsun nous fournit une variable d'environnement pour cela : PLATFORM_PROJECT_ENTROPY. Dans le fichier .environment, ajoutez la ligne suivante :

export SECRET_KEY="${PLATFORM_PROJECT_ENTROPY}"

Puisque pour l'instant nous utilisons Flask comme serveur web, vous pouvez ne pas ajouter GUNICORN_WORKERS à votre fichier .environment. Nous aborderons le passage à gunicorn dans un prochain article de blog.

Votre fichier .environment devrait maintenant ressembler à ce qui suit :

# Définissez les variables d'environnement de la base de données export DB_HOST="$POSTGRESQL_HOST" export DB_PORT="$POSTGRESQL_PORT" export DB_PATH="$POSTGRESQL_PATH" export DB_USERNAME="$POSTGRESQL_USERNAME" export DB_PASSWORD="$POSTGRESQL_PASSWORD" export DB_SCHEME="postgresql" export DATABASE_URL="${DB_SCHEME} ://${DB_USERNAME}:${DB_PASSWORD}@${DB_HOST} :${DB_PORT}/${DB_PATH}" export FLASK_ENV="${PLATFORM_ENVIRONMENT_TYPE}" export FLASK_DEBUG=$( ["${PLATFORM_ENVIRONMENT_TYPE}" = "production" ] && echo 0 || echo 1) export LOG_LEVEL=$( ["${PLATFORM_ENVIRONMENT_TYPE}" = "production" ] && echo "info" || echo "debug") export SEND_FILE_MAX_AGE_DEFAULT=$( ["${PLATFORM_ENVIRONMENT_TYPE}" = "production" ] && echo 31556926 || echo 0) export SECRET_KEY="${PLATFORM_PROJECT_ENTROPY}"

Puisque vous avez modifié votre fichier .environment, vous devez valider ces modifications avant de pousser le dépôt vers Upsun :

> git add .environment > git commit -m "ajoute les variables environnementales nécessaires à flask"

Vous pouvez maintenant pousser les changements vers Upsun et activer votre environnement initial :

> upsun environment:push

Répondez Y à la question : Are you sure you want to push to the main (type : production) branch ?

Upsun va maintenant lire vos fichiers de configuration et commencer à construire l'image de votre application. En supposant que vous n'ayez pas d'erreurs de syntaxe dans vos fichiers de configuration, il devrait construire et déployer votre image et, à la fin du processus, rapporter les URLs associées à notre projet.

Mise en place de la base de données

Vous avez peut-être remarqué que nous n'avons rien fait en ce qui concerne la base de données. Cette application utilise Flask-migrate et comme il s'agit d'une toute nouvelle application, vous devrez configurer les migrations initiales et les valider afin de pouvoir les appliquer à notre base de données Upsun. Cependant, comme la commande migrate a besoin d'accéder à la base de données, vous devrez configurer un environnement local temporaire et lui donner un moyen d'accéder au service de base de données. Commençons par créer un environnement virtuel dans lequel vous pourrez exécuter votre projet :

> python3 -m venv env && source venv/bin/activate

Tout comme dans votre crochet de construction, mettez à jour pip et installez vos pré-requis :

> pip install --upgrade pip > pip install -r requirements.txt

Ensuite, vous allez configurer cette instance locale pour qu'elle puisse communiquer avec votre service de base de données. Lorsque vous avez poussé vers Upsun précédemment, il a créé et déployé votre service de base de données. L'outil CLI d'Upsun vous donne une méthode pour communiquer avec les services de votre application : upsun tunnel

> upsun tunnel:open -y

Ceci ouvre un tunnel SSH vers tous les services de l'application, et vous pouvez maintenant l'utiliser pour permettre à votre instance locale de communiquer avec eux comme s'ils étaient eux aussi locaux. Pour ce faire, vous devrez configurer quelques variables d'environnement de la même manière que vous l'avez fait précédemment. Si vous rouvrez le fichier .environment, vous remarquerez en haut que nous utilisons une variable d'environnement nommée $PLATFORM_RELATIONSHIPS pour récupérer des informations sur les services et leurs informations d'identification. Le tunnel que vous avez créé vous donne accès à ces mêmes données, vous permettant de générer une variable d'environnement locale PLATFORM_RELATIONSHIPS contenant les mêmes informations.

> export PLATFORM_RELATIONSHIPS="$(upsun tunnel:info --encode)"

Si vous essayez maintenant de faire un écho à $PLATFORM_RELATIONSHIPS, vous verrez qu'il a été défini à une valeur encodée en base64 assez importante. Cette chaîne contient vos services, leurs définitions, leurs emplacements et, plus important encore, leurs identifiants. Comme cette variable environnementale est définie localement, vous pouvez réutiliser votre fichier .environment pour Upsun afin de recréer la plupart des autres variables environnementales dont vous avez besoin pour fonctionner localement.

Cependant, vous aurez quelques variables qui ne sont pas définies via PLATFORM_RELATIONSHIPS et que vous devrez encore configurer.

> export PLATFORM_ENVIRONMENT_TYPE=production > export PORT=8888 > export PLATFORM_PROJECT_ENTROPY=$(openssl rand -base64 32)

Enfin, sourcez votre fichier .environment pour finir de configurer toutes les variables d'environnement dans votre shell actuel :

> source ./.environment

Vous avez maintenant tout ce dont vous avez besoin pour que Flask-Migrate puisse se connecter à la base de données et générer vos fichiers de migration. Tout d'abord, vous devez faire en sorte que Flask-Migrate initie le répertoire migrations et se prépare à la commande migrate :

> flask db init

Vous pouvez maintenant demander à Flask-migrate de générer vos migrations :

> flask db migrate

Vous pouvez ensuite valider les migrations générées :

> git add migrations/* > git commit -m "adds migrations"

Vous devez maintenant demander à Upsun d'exécuter la commande Flask-Migrate upgrade lors du déploiement afin de savoir si les changements de migration sont automatiquement appliqués. Rouvrez le fichier ./.upsun/config.yaml et trouvez le crochet de déploiement où vous avez ajouté npm run build. Sur la ligne suivante, ajoutez flask db upgrade:

# Le crochet de déploiement est exécuté après le démarrage du conteneur d'application, mais avant qu'il ne commence à accepter des demandes. # Plus d'informations : https://docs.upsun.com/create-apps/hooks/hooks-comparison.html#deploy-hook deploy : | set -eux npm run build flask db upgrade

Commencez les modifications :

> git add ./.upsun/config.yaml > git commit -m "adds flask db upgrade to deploy hook"

Enfin, poussez le tout dans votre environnement Upsun !

> upsun environment:push -y

Félicitations, vous avez maintenant déployé avec succès votre application Flask sur Upsun, prenez un moment pour visiter votre site et le tester.

Dans les prochains articles, nous explorerons les différentes options dont vous disposez pour les serveurs web, un environnement de développement local plus robuste, l'intégration du contrôle de source et l'ajout de divers services à votre projet. Mais pour l'instant, allez-y et déployez (même le vendredi) !

Les fichiers .upsun/config.yaml et .environment sont disponibles sur GitHub.

Un pas à pas rapide

Pour ceux d'entre vous qui préfèrent commencer dès que possible, voici un guide rapide et simple étape par étape :

T:` - exécuter la ligne dans un terminal/une invite de commande

T : pip3 install cookiecutter
T : cookiecutter https://github.com/cookiecutter-flask/cookiecutter-flask.git
Répondez aux questions :
1. Nom
2. Email
3. Nom d'utilisateur Github
4. Nom du projet
5. Nom de l'application
6. Description de l'application
7. Pipenv
8. Version de Python
9. Version Node
10. heroku
Cd dans le répertoire (devrait être ce que vous avez répondu pour 3e)
T : git init .
T : git branch -m main
T : upsun project:init
1. Sélectionnez Python
2. Sélectionner Postgres
T : git add .
T : git commit -m "init commit"
T : upsun p:create
Répondre aux questions
1. Choisissez votre organisation
2. Donnez-lui un titre
3. Choisissez une région
4. Entrez le nom de la branche à partir de #7
5. Définissez le projet comme étant le projet distant (pour l'instant)
6. Sélectionnez Y pour "continuer"
Ouvrez ./.upsun/config.yaml
1. Trouvez la section décrivant les "Variables"
2. Décommentez "# variables" et la ligne suivante "env :"
3. Sur la ligne suivante, ajoutez FLASK_APP : autoapp.py
4. Trouvez la section décrivant les "montages"
5. Décommentez "# mounts :"
6. Sur la ligne suivante, ajoutez
  "<nom-de-votre-app-de-3e-plus-haut>/static" :
  source : storage
  source_path : static_build
7. Trouvez la section pour hooks:build
8. Sur la ligne précédant pip install, ajoutez ce qui suit :
  pip install --upgrade pip
9. Sur la ligne en dessous de pip install, ajoutez ce qui suit
  npm install
10. Descendez jusqu'à la section deploy
11. Sur la ligne après set -eux, ajoutez
  npm run build
12. Trouvez la section web:commands:start et remplacez-la par
  start : flask run -p $PORT
13. En dessous, trouvez la section upstream:socket_family et commentez les deux lignes ou remplacez "unix" par "tcp".
T : git add ./.upsun/config.yaml
T : git commit -m "adds FLASK_APP env var, adds mount for static builds, build commands, npm run build on deploy, web start command"
Ouvrir le fichier .environment
1. Supprimez tout et remplacez par :
  # Définir les variables d'environnement de la base de données
  export RELATIONSHIPS_JSON="$(echo $PLATFORM_RELATIONSHIPS | base64 --decode)"
  # Définir les variables d'environnement de la base de données
  export DB_HOST="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].host')"
  export DB_PORT="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].port')"
  export DB_DATABASE="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].path')"
  export DB_USERNAME="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].username')"
  export DB_PASSWORD="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].password')"
  export DB_CONNECTION="$(echo $RELATIONSHIPS_JSON | jq -r '.postgresql[0].scheme')"
  export DATABASE_URL="postgresql://${DB_USERNAME}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_DATABASE}"
2. Ajoutez les lignes suivantes à .environment :
  export SECRET_KEY="${upsun_PROJECT_ENTROPY}"
  export FLASK_DEBUG=$( ["${upsun_ENVIRONMENT_TYPE}" = "production" ] && echo 0 || echo 1)
  export FLASK_ENV="${upsun_ENVIRONMENT_TYPE}"
  export GUNICORN_WORKERS=1
  export LOG_LEVEL=$( ["${upsun_ENVIRONMENT_TYPE}" = "production" ] && echo "info" || echo "debug")
  # En production, mettre un nombre plus élevé, comme 31556926
  export SEND_FILE_MAX_AGE_DEFAULT=$( [ "${upsun_ENVIRONMENT_TYPE}" = "production" ] && echo 31556926 || echo 0)
T : git add .environment
T : git commit -m "ajoute les vars nécessaires à l'environnement flask"
T : upsun e:push
1. Réponse Y
A la fin du déploiement, l'URL de votre projet vous sera donnée
T : python3 -m venv env
T : source venv/bin/activate
T : pip install --upgrade pip
T : pip install -r requirements.txt
T : upsun tunnel:open -y
T : export upsun_RELATIONSHIPS="$(upsun tunnel:info --encode)"
T : export PORT=8888
T : export upsun_PROJECT_ENTROPY=$(openssl rand -base64 32)
T : export upsun_ENVIRONMENT_TYPE=production
T : source ./.environment
T : flask db init
T : flask db migrate
Ouvrez ./.upsun/config.yaml
1. Trouvez la section pour hooks:deploy
2. Sur une nouvelle ligne après `npm run build`, ajoutez `flask db upgrade`
T : git add migrations/*
T : git commit -m "ajoute les migrations"
T : git add ./.upsun/config.yaml
T : git commit -m "ajoute la mise à jour de la base de données flask au crochet de déploiement"
T : upsun environment:push