Watch a demoFree trial
Blog

Flask en marche

FlaskGitGitOpsCLIconfiguration
04 août 2025
Paul Gilzow
Paul Gilzow
Ingénieur chargé des relations avec les développeurs
Partager
Cet article est également disponible en Allemande et Anglais.

Ce guide fournit des instructions pour déployer et travailler avec Flask, un framework 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 (): A demonstration project
[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
Welcome to Upsun!
Let's get started with a few questions.

We need to know a bit more about your project. This will only take a minute!

What language is your project using? We support the following:
Use arrows to move up and down, type to filter
  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 :

What language is your project using? We support the following: [Python]

✓ Detected dependency managers: 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:

                                               (\_/)
We're almost done...  =(^.^)=

Last but not least, unless you're creating a static website, your project uses services. Let's define them:

Select all the services you are using:
Use arrows to move, space to select, type to filter
  [ ]  MariaDB
  [ ]  MySQL
> [x]  PostgreSQL
  [ ]  Redis
  [ ]  Redis Persistent
  [ ]  Memcached
  [ ]  OpenSearch

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

┌───────────────────────────────────────────────────┐
│   CONGRATULATIONS!                                                                                                                      │
│                                                                                                                                                                     │
│   We have created the following files for your:                                                                         │
│     - .environment                                                                                                                                  │
│     - .upsun/config.yaml                                                                                                                       │
│                                                                                                                                                                     │
│   We're jumping for joy! ⍢                                                                                                                  │
└───────────────────────────────────────────────────┘
        │ /
        │/
        │
  (\ /)
  ( . .)
  o (_(")(")

You can now deploy your application to Upsun!
To do so, commit your files and deploy your application using the Upsun CLI:
  $ 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 web Upsun . 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 to control the environment. More information: https://docs.upsun.com/create-apps/app-reference.html#variables
variables:
env:
  FLASK_APP: autoapp.py
#     # Add environment variables here that are static.
#     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é ./<application-name>/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 :
 

# Mounts define directories that are writable after the build is complete.
# More information: 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 hook 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 le pip install initial et ajouter npm install:
 

# Hooks allow you to customize your code/environment as the project moves through the build and deploy stages
# More information: https://docs.upsun.com/create-apps/app-reference.html#hooks
hooks:
 # The build hook is run after any build flavor.
 # More information: https://docs.upsun.com/create-apps/hooks/hooks-comparison.html#build-hook
 build: |
   set -eux
   pip install --upgrade pip
   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.

# The deploy hook is run after the app container has been started, but before it has started accepting requests.
  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 # The web key configures the web server running in front of your app. 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:
 # Commands are run once after deployment to start the application process.
 # More information: https://docs.upsun.com/create-apps/app-reference.html#web-commands
 commands:
   # The command to launch your app. If it terminates, it's restarted immediately.
   # You can use the $PORT or the $SOCKET environment variable depending on the socket family of your upstream
   start: "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"
# You can listen to a UNIX socket (unix) or a TCP port (tcp, default).
# Whether your app should speak to the webserver via TCP or Unix socket. Defaults to tcp
# More information: https://docs.upsun.com/create-apps/app-reference.html#where-to-listen
upstream:
 # Whether your app should speak to the webserver via TCP or Unix socket. Defaults to tcp
 # More information: 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)"

# Set database environment variables
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 :

# Set database environment variables
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 "adds needed flask environmental variables"

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 hook 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 Hook de déploiement où vous avez ajouté npm run build. Sur la ligne suivante, ajoutez flask db upgrade:

# The deploy hook is run after the app container has been started, but before it has started accepting requests.
# More information:    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

  1. T : pip3 install cookiecutter
  2. T : cookiecutter https://github.com/cookiecutter-flask/cookiecutter-flask.git
  3. 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
  4. Cd dans le répertoire (devrait être ce que vous avez répondu pour 3e)
  5. T : git init .
  6. T : git branch -m main
  7. T : upsun project:init
    1. Sélectionnez Python
    2. Sélectionner Postgres
  8. T : git add .
  9. T : git commit -m "init commit"
  10. T : upsun p:create
  11. 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"
  12. 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 
      "<name-of-your-app-from-3e-above>/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".
  13. T : git add ./.upsun/config.yaml
  14. T : git commit -m "adds FLASK_APP env var, adds mount for static builds, build commands, npm run build on deploy, web start command"
  15. Ouvrir le fichier .environment
    1. Supprimez tout et remplacez par :
      # Set database environment variables
      export RELATIONSHIPS_JSON="$(echo $PLATFORM_RELATIONSHIPS | base64 --decode)"
      # Set database environment variables
      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")
      # In production, set to a higher number, like 31556926
      export SEND_FILE_MAX_AGE_DEFAULT=$( [ "${upsun_ENVIRONMENT_TYPE}" = "production" ] && echo 31556926 || echo 0)
  16. T : git add .environment
  17. T : git commit -m "ajoute les vars nécessaires à l'environnement flask"
  18. T : upsun e:push
    1. Réponse Y
  19. A la fin du déploiement, l'URL de votre projet vous sera donnée
  20. T : python3 -m venv env
  21. T : source venv/bin/activate
  22. T : pip install --upgrade pip
  23. T : pip install -r requirements.txt
  24. T : upsun tunnel:open -y
  25. T : export upsun_RELATIONSHIPS="$(upsun tunnel:info --encode)"
  26. T : export PORT=8888
  27. T : export upsun_PROJECT_ENTROPY=$(openssl rand -base64 32)
  28. T : export upsun_ENVIRONMENT_TYPE=production
  29. T : source ./.environment
  30. T : flask db init
  31. T : flask db migrate
  32. 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`
  33. T : git add migrations/*
  34. T : git commit -m "ajoute les migrations"
  35. T : git add ./.upsun/config.yaml
  36. T : git commit -m "ajoute la mise à jour de la base de données flask au crochet de déploiement"
  37. T : upsun environment:push

Votre meilleur travail
est à l'horizon

Essai gratuit
CompanyEventsAbout usJobsSustainabilityFAQ
ProductOverviewFeaturesPricingPricing calculator
IndustriesRetailHigher educationSaaSTravel and hospitalityFinancial ServicesGovernment
ResourcesBlogDeveloper CenterDocumentationCloud regionsSupportContact us
Use casesSaaS hostingApplication modernizationeCommerce hostingCMS hostingMulti site managementSaaS extensions
CompareHeroku alternativePantheon alternative
Discord
© 2025 Platform.sh. All rights reserved.