Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Déploiement d'une application Flask sur Elastic Beanstalk
<a name="create-deploy-python-flask"></a>

Ce didacticiel vous explique le processus de génération d'une application Flask et de son déploiement dans un AWS Elastic Beanstalk environnement. Flask est une infrastructure d'application web open source pour Python. 

Dans le cadre de ce didacticiel, vous effectuerez les tâches suivantes :
+ [Configuration d'un environnement virtuel Python avec Flask](#python-flask-setup-venv)
+ [Création d'une application Flask](#python-flask-create-app)
+ [Déploiement de votre site avec l'interface de ligne de commande (CLI) EB](#python-flask-deploy) 
+ [Nettoyage](#python-flask-tutorial-cleanup) 

## Conditions préalables
<a name="python-flask-prereq"></a>

Ce tutoriel suppose que vous connaissez les opérations de base Elastic Beanstalk et la console Elastic Beanstalk. Si ce n'est pas déjà fait, suivez les instructions dans [Découvrez comment démarrer avec Elastic Beanstalk](GettingStarted.md) pour lancer votre premier environnement Elastic Beanstalk.

Pour suivre les procédures décrites dans ce guide, vous aurez besoin d'un shell ou d'un terminal de ligne de commande pour exécuter des commandes. Dans les listes, les commandes sont précédées d'un symbole d'invite (\$1) et du nom du répertoire actuel, le cas échéant.

```
~/eb-project$ this is a command
this is output
```

Sous Linux et macOS, vous pouvez utiliser le shell et le gestionnaire de package de votre choix. Sur Windows, vous pouvez [installer le sous-système Windows pour Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) afin d'obtenir une version intégrée à Windows d'Ubuntu et de Bash.

Dans ce didacticiel, nous utilisons Python 3.11 et la version correspondante de la plateforme Elastic Beanstalk. Installez Python en suivant les instructions à l'adresse [Configuration de votre environnement de développement Python pour Elastic Beanstalk](python-development-environment.md).

L'infrastructure [Flask](http://flask.pocoo.org/) sera installée dans le cadre de ce didacticiel.

Ce didacticiel utilise également l'interface de ligne de commande (CLI) Elastic Beanstalk (EB). Pour de plus amples informations sur l'installation et la configuration de la CLI EB, veuillez consulter [Installation de la CLI EB avec un script de configuration (recommandé)](eb-cli3.md#eb-cli3-install) et [Configuration de l'interface de ligne de commande EB](eb-cli3-configuration.md).

## Configuration d'un environnement virtuel Python avec Flask
<a name="python-flask-setup-venv"></a>

Créez un répertoire de projet et un environnement virtuel pour votre application, puis installez Flask.

**Pour configurer votre environnement de projet**

1. Créez un répertoire de projet.

   ```
   ~$ mkdir eb-flask
   ~$ cd eb-flask
   ```

1. Créez et activez un environnement virtuel nommé `virt` :

   ```
   ~/eb-flask$ virtualenv virt
   ~$ source virt/bin/activate
   (virt) ~/eb-flask$
   ```

   Vous verrez `(virt)` ajouté à votre invite de commande, ce qui indique que vous êtes dans un environnement virtuel. Utilisez l'environnement virtuel pour le reste du didacticiel.

1. Installez Flask avec `pip install` :

   ```
   (virt)~/eb-flask$ pip install flask==3.0.3
   ```

1. Affichez les bibliothèques installées avec `pip freeze` :

   ```
   (virt)~/eb-flask$ pip freeze
   blinker==1.8.2
   click==8.1.7
   Flask==3.0.3
   importlib_metadata==8.5.0
   itsdangerous==2.2.0
   Jinja2==3.1.4
   MarkupSafe==2.1.5
   Werkzeug==3.0.4
   zipp==3.20.2
   ```

   Cette commande répertorie tous les packages installés dans votre environnement virtuel. Étant donné que vous êtes dans un environnement virtuel, globalement les packages installés tels que l'interface de ligne de commande (CLI) EB ne sont pas affichés.

1. Enregistrez la sortie de `pip freeze` dans un fichier nommé `requirements.txt`.

   ```
   (virt)~/eb-flask$ pip freeze > requirements.txt
   ```

   Ce fichier indique à Elastic Beanstalk d'installer les bibliothèques pendant le déploiement. Pour de plus amples informations, veuillez consulter [Spécification des dépendances à l'aide d'un fichier d'exigences sur Elastic Beanstalk](python-configuration-requirements.md).

## Création d'une application Flask
<a name="python-flask-create-app"></a>

Créez ensuite une application qui vous allez déployer à l'aide d'Elastic Beanstalk. Nous allons créer un service RESTful Web « Hello World ».

Créez un nouveau fichier texte dans ce répertoire nommé `application.py` avec le contenu suivant :

**Example `~/eb-flask/application.py`**  

```
from flask import Flask

# print a nice greeting.
def say_hello(username = "World"):
    return '<p>Hello %s!</p>\n' % username

# some bits of text for the page.
header_text = '''
    <html>\n<head> <title>EB Flask Test</title> </head>\n<body>'''
instructions = '''
    <p><em>Hint</em>: This is a RESTful web service! Append a username
    to the URL (for example: <code>/Thelonious</code>) to say hello to
    someone specific.</p>\n'''
home_link = '<p><a href="/">Back</a></p>\n'
footer_text = '</body>\n</html>'

# EB looks for an 'application' callable by default.
application = Flask(__name__)

# add a rule for the index page.
application.add_url_rule('/', 'index', (lambda: header_text +
    say_hello() + instructions + footer_text))

# add a rule when the page is accessed with a name appended to the site
# URL.
application.add_url_rule('/<username>', 'hello', (lambda username:
    header_text + say_hello(username) + home_link + footer_text))

# run the app.
if __name__ == "__main__":
    # Setting debug to True enables debug output. This line should be
    # removed before deploying a production app.
    application.debug = True
    application.run()
```

Cet exemple affiche un message d'accueil personnalisé qui varie selon le chemin d'accès utilisé pour accéder au service.

**Note**  
En ajoutant `application.debug = True` avant d'exécuter l'application, la sortie de débogage est activée pour parer à une éventuelle défaillance. C'est une bonne pratique pour le développement, mais vous devez supprimer les instructions de débogage dans le code de production, car la sortie de débogage peut révéler des aspects internes de votre application.

Utiliser `application.py` comme nom de fichier et fournir un objet `application` joignable (dans ce cas, l'objet Flask) permet à Elastic Beanstalk de trouver facilement le code de votre application.

Exécutez `application.py` avec Python :

```
(virt) ~/eb-flask$ python application.py
 * Serving Flask app "application" (lazy loading)
 * Environment: production
   WARNING: Do not use the development server in a production environment.
   Use a production WSGI server instead.
 * Debug mode: on
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 313-155-123
```

Ouvrez `http://127.0.0.1:5000/` dans votre navigateur web. Vous devriez voir l'application en cours d'exécution, affichant la page d'index :

![\[Web browser displaying "Hello World!" message and a hint about RESTful web service usage.\]](http://docs.aws.amazon.com/fr_fr/elasticbeanstalk/latest/dg/images/eb_flask_test_local.png)


Consultez le journal du serveur pour voir le résultat de votre demande. Vous pouvez arrêter le serveur web et revenir à votre environnement virtuel en appuyant sur **Ctrl\$1C**.

Si vous avez obtenu la sortie de débogage à la place, corrigez les erreurs et veillez à ce que l'application s'exécute localement avant de procéder à la configuration pour Elastic Beanstalk.

## Déploiement de votre site avec l'interface de ligne de commande (CLI) EB
<a name="python-flask-deploy"></a>

Vous avez ajouté tout ce dont vous avez besoin pour déployer votre application sur Elastic Beanstalk. Votre répertoire de projet devrait maintenant ressembler à ceci :

```
~/eb-flask/
|-- virt
|-- application.py
`-- requirements.txt
```

Le dossier `virt`, toutefois, n'est pas requis pour que l'application s'exécute sur Elastic Beanstalk. Au moment du déploiement, Elastic Beanstalk crée un environnement virtuel sur les instances de serveur et installe les bibliothèques répertoriées dans `requirements.txt`. Pour réduire la taille du bundle source que vous chargez pendant le déploiement, ajoutez un fichier [.ebignore](eb-cli3-configuration.md#eb-cli3-ebignore) qui demande à l'interface de ligne de commande (CLI) EB d'exclure le dossier `virt`.

**Example \$1/eb-flask/.ebignore**  

```
virt
```

Ensuite, vous allez créer votre environnement d'applications et déployer votre application configurée avec Elastic Beanstalk.

**Pour créer un environnement et déployer votre application Flask**

1. Initialisez votre référentiel d'interface de ligne de commande (CLI) EB avec la commande **eb init** :

   ```
   ~/eb-flask$ eb init -p python-3.11 flask-tutorial --region us-east-2
   Application flask-tutorial has been created.
   ```

   Cette commande crée une nouvelle application nommée `flask-tutorial` et configure votre dépôt local pour créer des environnements avec la dernière version de la plateforme Python 3.11.

1. (facultatif) Exécutez à **eb init** nouveau pour configurer une paire de clés par défaut afin de pouvoir vous connecter à l' EC2 instance qui exécute votre application avec SSH :

   ```
   ~/eb-flask$ eb init
   Do you want to set up SSH for your instances?
   (y/n): y
   Select a keypair.
   1) my-keypair
   2) [ Create new KeyPair ]
   ```

   Sélectionnez une paire de clés si vous en avez déjà une, ou suivez les invites pour en créer une. Si vous ne voyez pas l'invite ou que vous avez besoin de modifier vos paramètres ultérieurement, exécutez **eb init -i**.

1. Créez un environnement et déployez-y votre application avec **eb create** :

   ```
   ~/eb-flask$ eb create flask-env
   ```

La création d'un environnement prend environ 5 minutes et crée les ressources suivantes :
+ **EC2 instance** — Une machine virtuelle Amazon Elastic Compute Cloud (Amazon EC2) configurée pour exécuter des applications Web sur la plateforme de votre choix.

  Chaque plateforme exécute un ensemble spécifique de logiciels, de fichiers de configuration et de scripts pour prendre en charge une version de langage, une infrastructure ou un conteneur web spécifiques, ou une combinaison de ces éléments. La plupart des plateformes utilisent Apache ou nginx comme proxy inverse situé devant votre application web, qui lui transmet des demandes, traite des ressources statiques et génère des journaux d'accès et d'erreur.
+ **Groupe de sécurité d'instance** : groupe EC2 de sécurité Amazon configuré pour autoriser le trafic entrant sur le port 80. Cette ressource permet au trafic HTTP provenant de l'équilibreur de charge d'atteindre l' EC2 instance qui exécute votre application Web. Par défaut, le trafic n'est pas autorisé sur les autres ports.
+ **Équilibreur de charge** – Équilibreur de charge Elastic Load Balancing configuré pour répartir les demandes vers les instances exécutant votre application. De plus, l'équilibreur de charge vous évite d'exposer directement vos instances sur Internet.
+ Groupe de **sécurité d'équilibrage de charge : groupe** EC2 de sécurité Amazon configuré pour autoriser le trafic entrant sur le port 80. Cette ressource autorise le trafic HTTP provenant d'Internet à atteindre l'équilibreur de charge. Par défaut, le trafic n'est pas autorisé sur les autres ports.
+ **Groupe Auto Scaling** – Groupe Auto Scaling configuré pour remplacer une instance si elle est résiliée ou devient indisponible.
+ **Compartiment Amazon S3** – Emplacement de stockage pour votre code source, les journaux et autres artefacts qui sont créés lorsque vous utilisez Elastic Beanstalk.
+ ** CloudWatch Alarmes Amazon** : deux CloudWatch alarmes qui surveillent la charge sur les instances de votre environnement et qui sont déclenchées si la charge est trop élevée ou trop faible. Lorsqu'une alarme est déclenchée, votre groupe Auto Scaling s'adapte en fonction, à la hausse ou à la baisse.
+ **CloudFormation stack** : Elastic CloudFormation Beanstalk utilise pour lancer les ressources de votre environnement et propager les modifications de configuration. Les ressources sont définies dans un modèle, que vous pouvez afficher dans la [console CloudFormation](https://console.aws.amazon.com/cloudformation).
+ **Nom de domaine** : nom de domaine qui permet d'accéder à votre application Web dans le formulaire **subdomain*. *region*.elasticbeanstalk.com*.
**Sécurité du domaine**  
Pour renforcer la sécurité de vos applications Elastic Beanstalk, le domaine *elasticbeanstalk.com* est enregistré dans la [liste des suffixes publics (PSL)](https://publicsuffix.org/).  
Si vous devez définir des cookies sensibles dans le nom de domaine par défaut de vos applications Elastic Beanstalk, nous vous recommandons d'utiliser des cookies `__Host-` avec un préfixe pour une sécurité accrue. Cette pratique protège votre domaine contre les tentatives de falsification de requêtes intersites (CSRF). Pour plus d'informations, consultez la page [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) du Mozilla Developer Network.

Toutes ces ressources sont gérées par Elastic Beanstalk. Lorsque vous arrêtez votre environnement, Elastic Beanstalk arrête toutes les ressources qu'il contient.

**Note**  
Le compartiment Amazon S3 créé par Elastic Beanstalk est partagé entre les environnements et n'est pas supprimé lors de l'arrêt de l'environnement. Pour de plus amples informations, veuillez consulter [Utilisation d'Elastic Beanstalk avec Amazon S3](AWSHowTo.S3.md).

Lorsque le processus de création de l'environnement est terminé, ouvrez votre site web avec **eb open** :

```
~/eb-flask$ eb open
```

Cela ouvre une fenêtre de navigateur à l'aide du nom de domaine créé pour votre application. Vous devez voir le même site web Flask que celui que vous avez créé et testé localement.

![\[Browser window displaying a Flask web application with a "Hello World!" message and usage hint.\]](http://docs.aws.amazon.com/fr_fr/elasticbeanstalk/latest/dg/images/eb_flask_deployed.png)


Si vous ne voyez pas votre application en cours d'exécution ou si vous obtenez un message d'erreur, consultez [Déploiements](troubleshooting.md#troubleshooting-deployments) afin d'obtenir de l'aide concernant la façon de déterminer la cause de l'erreur.

Si vous voyez *effectivement* votre application en cours d'exécution, alors félicitations, vous avez déployé votre première application Flask avec Elastic Beanstalk \$1

## Nettoyage
<a name="python-flask-tutorial-cleanup"></a>

Une fois que vous avez fini d'utiliser le code de démonstration, vous pouvez mettre fin à votre environnement. [Elastic Beanstalk supprime toutes les ressources AWS associées, [telles que les instances EC2 Amazon](using-features.managing.ec2.md)[, les instances de base de données, les équilibreurs de charge, les](using-features.managing.db.md)[groupes de sécurité](using-features.managing.elb.md) et les alarmes.](using-features.alarms.md#using-features.alarms.title) 

La suppression de ressources n'entraîne pas la suppression de l'application Elastic Beanstalk. Vous pouvez donc créer de nouveaux environnements pour votre application à tout moment.

**Pour mettre fin à votre environnement Elastic Beanstalk depuis la console**

1. Ouvrez la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk), puis **dans la liste des régions, sélectionnez votre**. Région AWS

1. Dans le panneau de navigation, choisissez **Environments** (Environnements), puis choisissez le nom de votre environnement dans la liste.

1. Choisissez **Actions** (Actions), puis **Terminate Environment** (Résilier l’environnement).

1. Utilisez la boîte de dialogue à l'écran pour confirmer la résiliation de l'environnement.

Ou, avec l'interface de ligne de commande (CLI) EB :

```
~/eb-flask$ eb terminate flask-env
```

## Étapes suivantes
<a name="python-flask-more-info"></a>

Pour plus d'informations sur Flask, visitez [flask.pocoo.org](http://flask.pocoo.org/).

Si vous souhaitez essayer un autre cadre web Python, veuillez consulter [Déploiement d'une application Django sur Elastic Beanstalk](create-deploy-python-django.md).