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'applications Python avec Elastic Beanstalk
<a name="create-deploy-python-apps"></a>

Ce chapitre fournit des instructions pour configurer et déployer votre application Web Python sur AWS Elastic Beanstalk. Elastic Beanstalk facilite le déploiement, la gestion et le dimensionnement de vos applications Web Python à l'aide d'Amazon Web Services.

Vous pouvez déployer votre application en quelques minutes à l'aide de l'interface de ligne de commande Elastic Beanstalk (EB CLI) ou de la console Elastic Beanstalk. Après avoir déployé votre application Elastic Beanstalk, vous pouvez continuer à utiliser l'EB CLI pour gérer votre application et votre environnement, ou vous pouvez utiliser la console Elastic Beanstalk, ou le. AWS CLI APIs

Suivez les étapes décrites dans les step-by-step instructions [QuickStart pour Python](python-quickstart.md) pour créer et déployer une application Web Python *Hello World* avec l'EB CLI.

**Topics**
+ [QuickStart: Déployer une application Python sur Elastic Beanstalk](python-quickstart.md)
+ [Configuration de votre environnement de développement Python pour Elastic Beanstalk](python-development-environment.md)
+ [Utilisation de la plateforme Python Elastic Beanstalk](create-deploy-python-container.md)
+ [Déploiement d'une application Flask sur Elastic Beanstalk](create-deploy-python-flask.md)
+ [Déploiement d'une application Django sur Elastic Beanstalk](create-deploy-python-django.md)
+ [Ajouter une instance de base de données Amazon RDS à votre environnement Python Elastic Beanstalk](create-deploy-python-rds.md)
+ [Outils et ressources Python](create-deploy-python-tools-resources.md)

# QuickStart: Déployer une application Python sur Elastic Beanstalk
<a name="python-quickstart"></a>

Ce QuickStart didacticiel explique le processus de création d'une application Python et de son déploiement dans un AWS Elastic Beanstalk environnement.

**Non destiné à une utilisation en production**  
Les exemples sont destinés uniquement à des fins de démonstration. N'utilisez pas d'exemples d'applications en production.

**Topics**
+ [Votre AWS compte](#python-quickstart-aws-account)
+ [Conditions préalables](#python-quickstart-prereq)
+ [Étape 1 : Création d'une application Python](#python-quickstart-create-app)
+ [Étape 2 : Exécutez votre application localement](#python-quickstart-run-local)
+ [Étape 3 : Déployez votre application Python avec l'EB CLI](#python-quickstart-deploy)
+ [Étape 4 : Exécutez votre application sur Elastic Beanstalk](#python-quickstart-run-eb-ap)
+ [Étape 5 : nettoyer](#go-tutorial-cleanup)
+ [AWS ressources pour votre application](#python-quickstart-eb-resources)
+ [Étapes suivantes](#python-quickstart-next-steps)
+ [Déployez avec la console Elastic Beanstalk](#python-quickstart-console)

## Votre AWS compte
<a name="python-quickstart-aws-account"></a>

Si vous n'êtes pas encore AWS client, vous devez créer un AWS compte. L'inscription vous permet d'accéder à Elastic Beanstalk AWS et aux autres services dont vous avez besoin.

Si vous avez déjà un AWS compte, vous pouvez passer à[Conditions préalables](#python-quickstart-prereq).

### Créez un AWS compte
<a name="python-quickstart-aws-account-procedure"></a>

#### Inscrivez-vous pour un Compte AWS
<a name="sign-up-for-aws"></a>

Si vous n'en avez pas Compte AWS, procédez comme suit pour en créer un.

**Pour vous inscrire à un Compte AWS**

1. Ouvrez l'[https://portal.aws.amazon.com/billing/inscription.](https://portal.aws.amazon.com/billing/signup)

1. Suivez les instructions en ligne.

   Dans le cadre de la procédure d’inscription, vous recevrez un appel téléphonique ou un SMS et vous saisirez un code de vérification en utilisant le clavier numérique du téléphone.

   Lorsque vous vous inscrivez à un Compte AWS, un *Utilisateur racine d'un compte AWS*est créé. Par défaut, seul l’utilisateur racine a accès à l’ensemble des Services AWS et des ressources de ce compte. La meilleure pratique de sécurité consiste à attribuer un accès administratif à un utilisateur, et à utiliser uniquement l’utilisateur racine pour effectuer les [tâches nécessitant un accès utilisateur racine](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS vous envoie un e-mail de confirmation une fois le processus d'inscription terminé. À tout moment, vous pouvez consulter l'activité actuelle de votre compte et gérer votre compte en accédant à [https://aws.amazon.com/](https://aws.amazon.com/)et en choisissant **Mon compte**.

#### Création d’un utilisateur doté d’un accès administratif
<a name="create-an-admin"></a>

Une fois que vous vous êtes inscrit à un utilisateur administratif Compte AWS, que vous Utilisateur racine d'un compte AWS l'avez sécurisé AWS IAM Identity Center, que vous l'avez activé et que vous en avez créé un, afin de ne pas utiliser l'utilisateur root pour les tâches quotidiennes.

**Sécurisez votre Utilisateur racine d'un compte AWS**

1.  Connectez-vous en [AWS Management Console](https://console.aws.amazon.com/)tant que propriétaire du compte en choisissant **Utilisateur root** et en saisissant votre adresse Compte AWS e-mail. Sur la page suivante, saisissez votre mot de passe.

   Pour obtenir de l’aide pour vous connecter en utilisant l’utilisateur racine, consultez [Connexion en tant qu’utilisateur racine](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) dans le *Guide de l’utilisateur Connexion à AWS *.

1. Activez l’authentification multifactorielle (MFA) pour votre utilisateur racine.

   Pour obtenir des instructions, voir [Activer un périphérique MFA virtuel pour votre utilisateur Compte AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) dans le guide de l'utilisateur *IAM*.

**Création d’un utilisateur doté d’un accès administratif**

1. Activez IAM Identity Center.

   Pour obtenir des instructions, consultez [Activation d’ AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.

1. Dans IAM Identity Center, octroyez un accès administratif à un utilisateur.

   Pour un didacticiel sur l'utilisation du Répertoire IAM Identity Center comme source d'identité, voir [Configurer l'accès utilisateur par défaut Répertoire IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) dans le *Guide de AWS IAM Identity Center l'utilisateur*.

**Connexion en tant qu’utilisateur doté d’un accès administratif**
+ Pour vous connecter avec votre utilisateur IAM Identity Center, utilisez l’URL de connexion qui a été envoyée à votre adresse e-mail lorsque vous avez créé l’utilisateur IAM Identity Center.

  Pour obtenir de l'aide pour vous connecter en utilisant un utilisateur d'IAM Identity Center, consultez la section [Connexion au portail AWS d'accès](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) dans le *guide de l'Connexion à AWS utilisateur*.

**Attribution d’un accès à d’autres utilisateurs**

1. Dans IAM Identity Center, créez un ensemble d’autorisations qui respecte la bonne pratique consistant à appliquer les autorisations de moindre privilège.

   Pour obtenir des instructions, consultez [Création d’un ensemble d’autorisations](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.

1. Attribuez des utilisateurs à un groupe, puis attribuez un accès par authentification unique au groupe.

   Pour obtenir des instructions, consultez [Ajout de groupes](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.

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

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.

### INTERFACE DE LIGNE DE COMMANDE (CLI) EB
<a name="python-quickstart-prereq.ebcli"></a>

Ce tutoriel utilise également l'interface de ligne de commande Elastic Beanstalk (CLI 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).

### Framework Python et Flask
<a name="python-quickstart-prereq.runtime"></a>

Vérifiez que vous disposez d'une version fonctionnelle de Python `pip` installée en exécutant les commandes suivantes.

```
~$ python3 --version
Python 3.N.N
>~$ python3 -m pip --version
pip X.Y.Z from ... (python 3.N.N)
```

Si l'une des commandes précédentes renvoie « *Python introuvable* », exécutez les commandes suivantes qui utilisent à la `python` place de`python3`. La configuration des alias et des liens symboliques peut varier en fonction du système d'exploitation et des personnalisations individuelles. Il est donc possible que la `python3` commande ne fonctionne pas sur votre machine.

```
~$ python --version
Python 3.N.N
>~$ python -m pip --version
pip X.Y.Z from ... (python 3.N.N)
```

Si Python n'est pas installé sur votre machine locale, vous pouvez le télécharger depuis la page de [téléchargement de Python](https://www.python.org/downloads/) sur le site Web de Python. *Pour obtenir la liste des versions du langage Python prises en charge par Elastic Beanstalk[, consultez la section Plateformes Python AWS Elastic Beanstalk prises en charge](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) dans le guide des plateformes.* Le site Web de téléchargement de Python fournit un lien vers le *guide du développeur Python*, où vous trouverez des instructions d'installation et de configuration.

**Note**  
Le `pip` package Python est inclus par défaut dans Python 3.4 ou version ultérieure.

Si votre résultat indique que vous disposez d'une version compatible de Python, mais que ce n'est pas le cas`pip`, consultez la page [d'installation](https://pip.pypa.io/en/stable/installation/) sur le site Web *pip.pypa.io.* Il fournit des conseils pour installer pip dans un environnement Python qui ne l'a pas.



Vérifiez si Flask est installé en exécutant la commande suivante :

```
~$ pip list | grep Flask
```

Si Flask n'est pas installé, vous pouvez l'installer à l'aide de la commande suivante :

```
~$ pip install Flask
```

## Étape 1 : Création d'une application Python
<a name="python-quickstart-create-app"></a>

Créez un répertoire de projet.

```
~$ mkdir eb-python
~$ cd eb-python
```

Créez un exemple « Hello Elastic Beanstalk \$1 » Application Python que vous déploierez à l'aide d'Elastic Beanstalk.

Créez un fichier texte nommé `application.py` dans le répertoire que vous venez de créer avec le contenu suivant.

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

```
from flask import Flask
application = Flask(__name__)

@application.route('/')
def hello_elastic_beanstalk():
        return 'Hello Elastic Beanstalk!'
```

Créez un fichier texte nommé `requirements.txt` avec la ligne suivante. Ce fichier contient les `pip` packages nécessaires à l'exécution de l'application.

**Example `~/eb-python/requirements.txt`**  

```
Flask
```

## Étape 2 : Exécutez votre application localement
<a name="python-quickstart-run-local"></a>

Exécutez la commande suivante pour exécuter votre application localement.

```
~/eb-python$ export FLASK_APP=application.py && flask run --port 5000
```

Vous devriez voir un résultat similaire à ce qui suit

```
Serving Flask app 'application.py'
Debug mode: off
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
Running on http://127.0.0.1:5000
Press CTRL+C to quit
127.0.0.1 - - [01/Jan/1970 00:00:00] "GET / HTTP/1.1" 200 -
```

Accédez à `http://localhost:5000` dans votre navigateur Web. Le navigateur Web doit afficher « Hello Elastic Beanstalk \$1 ».

## Étape 3 : Déployez votre application Python avec l'EB CLI
<a name="python-quickstart-deploy"></a>

Exécutez les commandes suivantes pour créer un environnement Elastic Beanstalk pour cette application.

 

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

1. Initialisez votre référentiel de la CLI EB avec la commande **eb init** :

   ```
   ~/eb-python$ eb init -p python-3.9 python-tutorial --region us-east-2
   ```

   Cette commande crée une application nommée `python-tutorial` et configure votre dépôt local pour créer des environnements avec la version de plate-forme Python fournie.

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

   ```
   ~/eb-python$ 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**. Elastic Beanstalk crée automatiquement un fichier zip pour votre application et le démarre sur le port 5000.

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

   Il faut environ cinq minutes à Elastic Beanstalk pour créer votre environnement.

## Étape 4 : Exécutez votre application sur Elastic Beanstalk
<a name="python-quickstart-run-eb-ap"></a>

Lorsque le processus de création de votre environnement est terminé, ouvrez votre site Web avec**eb open**.

```
~/eb-python$ eb open
```

Félicitations \$1 Vous avez déployé une application Python avec Elastic Beanstalk \$1 Celle-ci ouvre une fenêtre de navigation en utilisant le nom de domaine créé pour votre application.

## Étape 5 : nettoyer
<a name="go-tutorial-cleanup"></a>

Vous pouvez mettre fin à votre environnement lorsque vous avez fini d'utiliser votre application. Elastic Beanstalk AWS met fin à toutes les ressources associées à votre environnement.

Pour mettre fin à votre environnement Elastic Beanstalk avec l'EB CLI, exécutez la commande suivante.

```
~/eb-python$ eb terminate
```

## AWS ressources pour votre application
<a name="python-quickstart-eb-resources"></a>

Vous venez de créer une application à instance unique. Il s'agit d'un exemple d'application simple avec une seule instance EC2, de sorte qu'il ne nécessite pas d'équilibrage de charge ni de dimensionnement automatique. Pour les applications à instance unique, Elastic Beanstalk crée les ressources suivantes : AWS 
+ **Instance EC2** – Une machine virtuelle Amazon EC2 configurée pour exécuter des applications web sur la plateforme de votre choix.

  Chaque plateforme exécute un ensemble distinct 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 qui traite le trafic web devant votre application web, lui transmet les demandes, traite les ressources statiques et génère des journaux d'accès et d'erreurs.
+ **Groupe de sécurité de l'instance** – Un groupe de sécurité Amazon EC2 configuré pour autoriser le trafic entrant sur le port 80. Cette ressource autorise le trafic HTTP provenant de l'équilibreur de charge à atteindre l'instance EC2 qui exécute votre application web. Par défaut, le trafic n'est pas autorisé sur les autres ports.
+ **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 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*. 

Elastic Beanstalk gère toutes ces ressources. Lorsque vous arrêtez votre environnement, Elastic Beanstalk arrête toutes les ressources qu'il contient.

## Étapes suivantes
<a name="python-quickstart-next-steps"></a>

Dès que vous disposez d'un environnement exécutant une application, vous pouvez à tout moment déployer une nouvelle version de l'application ou une application totalement différente. Le déploiement d'une nouvelle version d'application est très rapide, car il n'est pas nécessaire de mettre en service ni de redémarrer les instances EC2. Vous pouvez également explorer votre nouvel environnement à l'aide de la console Elastic Beanstalk. Pour connaître les étapes détaillées, consultez la section [Explorez votre environnement](GettingStarted.md#GettingStarted.Explore) dans le chapitre *Mise* en route de ce guide.

**Essayez d'autres didacticiels**  
Si vous souhaitez essayer d'autres didacticiels avec différents exemples d'applications, consultez les didacticiels suivants :  
[Déploiement d'une application Flask sur Elastic Beanstalk](create-deploy-python-flask.md)
[Déploiement d'une application Django sur Elastic Beanstalk](create-deploy-python-django.md)

Une fois que vous avez déployé un ou deux exemples d'applications et que vous êtes prêt à commencer à développer et à exécuter des applications Python localement, consultez[Configuration de votre environnement de développement Python pour Elastic Beanstalk](python-development-environment.md). 

## Déployez avec la console Elastic Beanstalk
<a name="python-quickstart-console"></a>

Vous pouvez également utiliser la console Elastic Beanstalk pour lancer l'exemple d'application. Pour connaître les étapes détaillées, voir [Création d'un exemple d'application](GettingStarted.md#GettingStarted.CreateApp) dans le chapitre *Mise* en route de ce guide.

# Configuration de votre environnement de développement Python pour Elastic Beanstalk
<a name="python-development-environment"></a>

Cette rubrique fournit des instructions pour configurer un environnement de développement Python afin de tester votre application localement avant de la déployer AWS Elastic Beanstalk. Il fait également référence à des sites Web qui fournissent des instructions d'installation pour des outils utiles.

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.

**Topics**
+ [Conditions préalables](#python-common-prereq)
+ [Utilisation d’un environnement virtuel](#python-common-setup-venv)
+ [Configuration d'un projet Python pour Elastic Beanstalk](#python-common-configuring)

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

La liste suivante fournit les prérequis courants pour travailler avec Elastic Beanstalk et vos applications Python :
+ **Langage Python** : installez la version du langage Python incluse dans la version de plateforme Elastic Beanstalk Python que vous avez choisie. Pour obtenir la liste des versions de langage Python prises en charge, consultez la section [Plateformes Python prises en charge](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) dans le guide *AWS Elastic Beanstalk des plateformes*. Si Python n'est pas encore configuré sur votre machine de développement, consultez la page de [téléchargement de Python](https://www.python.org/downloads/) sur le site Web de Python.
+ **`pip`utilitaire** — L'`pip`utilitaire est le programme d'installation de packages de Python. Il installe et répertorie les dépendances de votre projet, afin qu'Elastic Beanstalk sache comment configurer l'environnement de votre application. Pour plus d'informations`pip`, consultez la [page pip](https://pip.pypa.io/en/stable/) sur le site Web *pip.pypa.io*.
+ **(Facultatif) L'interface de ligne de commande Elastic Beanstalk (EB CLI) : l'interface de ligne** de commande [EB peut empaqueter](eb-cli3.md) votre application avec les fichiers de déploiement nécessaires. Il peut également créer un environnement Elastic Beanstalk et y déployer votre application. Vous pouvez également effectuer des déploiements via la console Elastic Beanstalk, de sorte que l'EB CLI n'est pas strictement nécessaire.
+ **Une `SSH` installation fonctionnelle** — Vous pouvez vous connecter à vos instances en cours d'exécution à l'aide du protocole SSH pour examiner ou déboguer un déploiement.
+ **`virtualenv`package** — Cet `virtualenv` outil crée un environnement de développement et de test pour votre application. Elastic Beanstalk peut répliquer cet environnement sans installer de packages supplémentaires qui ne sont pas requis par votre application. Pour plus d'informations, consultez le site Web de [virtualenv](https://virtualenv.pypa.io/en/latest/). Après avoir installé Python, vous pouvez installer le `virtualenv` package à l'aide de la commande suivante :

  ```
  $ pip install virtualenv
  ```

## Utilisation d’un environnement virtuel
<a name="python-common-setup-venv"></a>

Une fois les conditions préalables en place, configurez un environnement virtuel avec `virtualenv` pour installer les dépendances de votre application. En utilisant un environnement virtuel, vous pouvez déterminer exactement quels packages sont nécessaires à votre application afin que les packages requis soient installés sur les EC2 instances qui exécutent votre application.

**Pour configurer un environnement virtuel**

1. Ouvrez une fenêtre de ligne de commande et tapez :

   ```
   $ virtualenv /tmp/eb_python_app
   ```

   *eb\$1python\$1app*Remplacez-le par un nom adapté à votre application (utiliser le nom de votre application est une bonne idée). La commande `virtualenv` crée un environnement virtuel pour vous dans le répertoire spécifié et imprime les résultats de ses actions :

   ```
   Running virtualenv with interpreter /usr/bin/python
   New python executable in /tmp/eb_python_app/bin/python3.12
   Also creating executable in /tmp/eb_python_app/bin/python
   Installing setuptools, pip...done.
   ```

1. Une fois que votre environnement virtuel est prêt, démarrez-le en exécutant le script `activate` situé dans le répertoire `bin` de l'environnement. Par exemple, pour démarrer l'environnement **eb\$1python\$1app** créé à l'étape précédente, tapez :

   ```
   $ source /tmp/eb_python_app/bin/activate
   ```

   L'environnement virtuel affiche son nom (par exemple : `(eb_python_app)`) au début de chaque invite de commande, pour vous rappeler que vous êtes dans un environnement Python virtuel.

1. Pour arrêter d'utiliser votre environnement virtuel et revenir à l'interpréteur Python par défaut du système avec toutes les bibliothèques installées, exécutez la commande `deactivate`.

   ```
   (eb_python_app) $ deactivate
   ```

**Note**  
Une fois l'environnement virtuel créé, vous pouvez le redémarrer à tout moment en exécutant à nouveau son script `activate`.

## Configuration d'un projet Python pour Elastic Beanstalk
<a name="python-common-configuring"></a>

Vous pouvez utiliser l'interface de ligne de commande (CLI) Elastic Beanstalk pour préparer vos applications Python à déployer avec Elastic Beanstalk.

**Pour configurer une application Python à déployer avec Elastic Beanstalk**

1. Depuis votre [environnement virtuel](#python-common-setup-venv), revenez vers le haut de l'arborescence de votre projet (`python_eb_app`) et saisissez :

   ```
   pip freeze >requirements.txt
   ```

   Cette commande copie les noms et les versions des packages qui sont installés dans votre environnement virtuel dans `requirements.txt`. Par exemple, si le package *PyYAML*, version *3.11* est installé dans votre environnement virtuel, le fichier contiendra la ligne :

   ```
   PyYAML==3.11
   ```

   Cela permet à Elastic Beanstalk de répliquer l'environnement Python de votre application à l'aide des mêmes packages et de la même version que ceux utilisés pour développer et tester votre application.

1. Configurez le référentiel de l'interface de ligne de commande (CLI) EB avec la commande **eb init**. Suivez les invites pour choisir une région, une plateforme et d'autres options.

Par défaut, Elastic Beanstalk recherche un fichier appelé `application.py` pour démarrer votre application. S'il n'existe pas dans le projet Python que vous avez créé, certains ajustements de l'environnement de votre application sont nécessaires. Vous devrez également définir des variables d'environnement afin que les modules de votre application puissent être chargés. Pour plus d'informations, consultez [Utilisation de la plateforme Python Elastic Beanstalk](create-deploy-python-container.md).

# Utilisation de la plateforme Python Elastic Beanstalk
<a name="create-deploy-python-container"></a>

Cette rubrique explique comment configurer, créer et exécuter vos applications Python sur Elastic Beanstalk.

AWS Elastic Beanstalk prend en charge un certain nombre de branches de plate-forme pour différentes versions du langage de programmation Python. Voir [Python](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) dans le document *AWS Elastic Beanstalk Platforms* pour une liste complète.

Les applications Web Python peuvent s'exécuter derrière un serveur proxy avec WSGI. Elastic [Beanstalk](https://gunicorn.org/) fournit Gunicorn comme serveur WSGI par défaut. 

Vous pouvez ajouter un `Procfile` à votre solution groupée source pour spécifier et configurer le serveur WSGI pour votre application. Pour en savoir plus, consultez [Configuration du serveur WSGI avec un profil sur Elastic Beanstalk](python-configuration-procfile.md).

Vous pouvez utiliser les fichiers `Pipfile.lock` et `Pipfile` créés par Pipenv pour spécifier les dépendances du package Python et d'autres exigences. Pour plus d'informations sur la spécification des dépendances, consultez [Spécification des dépendances à l'aide d'un fichier d'exigences sur Elastic Beanstalk](python-configuration-requirements.md).

Elastic [Beanstalk propose](command-options.md) des options de configuration que vous pouvez utiliser pour personnaliser le logiciel qui s'exécute EC2 sur les instances de votre environnement Elastic Beanstalk. Vous pouvez configurer des variables d'environnement nécessaires pour votre application, activer la rotation des journaux sur Amazon S3 et mapper des dossiers dans la source de votre application contenant des fichiers statiques vers des chemins desservis par le serveur proxy.

Des options de configuration sont disponibles dans la console Elastic Beanstalk pour [modifier la configuration d'un environnement en cours d'exécution](environment-configuration-methods-after.md). Pour éviter de perdre la configuration de votre environnement en le résiliant, vous pouvez utiliser des [configurations enregistrées](environment-configuration-savedconfig.md) pour enregistrer vos paramètres et les appliquer par la suite à un autre environnement.

Pour enregistrer les paramètres dans votre code source, vous pouvez inclure des [fichiers de configuration](ebextensions.md). Les paramètres des fichiers de configuration sont appliquées chaque fois que vous créez un environnement ou que vous déployez votre application. Vous pouvez également utiliser des fichiers de configuration pour installer des packages, exécuter des scripts ou effectuer d'autres opérations de personnalisation d'instance lors des déploiements.

Les paramètres appliqués dans la console Elastic Beanstalk remplacent les mêmes paramètres des fichiers de configuration, s'ils existent. Cela vous permet d'utiliser les paramètres par défaut dans les fichiers de configuration et de les remplacer par des paramètres spécifiques à l'environnement dans la console. Pour plus d'informations sur la priorité et les autres méthodes de modification des paramètres, consultez [Options de configuration](command-options.md).

Pour les packages Python disponibles à partir de `pip`, vous pouvez également inclure un fichier d'exigences dans la racine du code source de votre application. Elastic Beanstalk installe tous les packages de dépendance spécifiés dans un fichier de configuration lors du déploiement. Pour en savoir plus, consultez [Spécification des dépendances à l'aide d'un fichier d'exigences sur Elastic Beanstalk](python-configuration-requirements.md).

Pour plus d'informations sur les différentes manières d'étendre une plateforme Elastic Beanstalk basée sur Linux, consultez [Extension des plateformes Linux Elastic Beanstalk](platforms-linux-extend.md).

## Configuration de votre environnement Python
<a name="create-deploy-python-container-console"></a>

Les paramètres de la plateforme Python vous permettent d'affiner le comportement de vos EC2 instances Amazon. Vous pouvez modifier la configuration de l'instance Amazon de l'environnement Elastic Beanstalk à l'aide EC2 de la console Elastic Beanstalk.

Utilisez la console Elastic Beanstalk pour configurer les AWS X-Ray paramètres des processus Python, activer, activer la rotation des journaux vers Amazon S3 et configurer les variables que votre application peut lire depuis l'environnement.

**Pour configurer votre environnement Python dans la console Elastic Beanstalk**

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. Dans le panneau de navigation, choisissez **Configuration**.

1. Dans la catégorie de configuration **Mises à jour, surveillance et journalisation**, sélectionnez **Modifier**.

### Paramètres Python
<a name="python-console-settings"></a>
+ **Proxy server (Serveur proxy)** – Serveur proxy à utiliser sur vos instances d'environnement. Le serveur nginx est utilisé par défaut.
+ **Chemin WSGI** – Nom du chemin d'accès à votre fichier d'application principal. Par exemple, `application.py` ou `django/wsgi.py`.
+ **NumProcesses**— Le nombre de processus à exécuter sur chaque instance d'application.
+ **NumThreads**— Le nombre de threads à exécuter dans chaque processus.

### AWS X-Ray paramètres
<a name="python-console-xray"></a>
+ **Démon X-Ray** — Exécutez le AWS X-Ray démon pour traiter les données de trace provenant du. [Kit SDK AWS X-Ray pour Python](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html)

### Options du journal
<a name="create-deploy-python-container.console.logoptions"></a>

La section Options du journal a deux paramètres :
+ **Instance profile (Profil d'instance)** – Spécifie le profil d'instance qui est autorisé à accéder au compartiment Amazon S3 associé à votre application.
+ **Activer la rotation des fichiers journaux vers Amazon S3** : indique si les fichiers journaux des EC2 instances Amazon de votre application sont copiés dans le compartiment Amazon S3 associé à votre application.

### Fichiers statiques
<a name="python-platform-staticfiles"></a>

Pour améliorer les performances, la section des **Fichiers statiques** vous permet de configurer le serveur proxy pour proposer des fichiers statiques (HTML ou images, par exemple) à partir d'un ensemble de répertoires dans votre application web. Pour chaque répertoire, vous définissez le chemin virtuel sur le mappage de répertoires. Lorsque le serveur proxy reçoit une demande pour un fichier dans le chemin spécifié, il fournit le fichier directement au lieu d'acheminer la demande vers votre application.

Pour en savoir plus sur la configuration des fichiers statiques à l'aide des fichiers de configuration ou de la console Elastic Beanstalk, consultez [Service de fichiers statiques](environment-cfg-staticfiles.md).

Par défaut, le serveur proxy d'un environnement Python sert tous les fichiers dans un dossier nommé `static` sur le chemin d'accès `/static`. Par exemple, si votre code source d'application contient un fichier nommé `logo.png` dans un dossier nommé `static`, le serveur proxy le sert aux utilisateurs dans `subdomain.elasticbeanstalk.com/static/logo.png`. Vous pouvez configurer d'autres mappages comme expliqué dans cette section.

### Propriétés de l'environnement
<a name="create-deploy-python-custom-container-envprop"></a>

Vous pouvez utiliser les propriétés de l'environnement afin de fournir des informations à votre application et de configurer des variables d'environnement. Par exemple, vous pouvez créer une propriété de l'environnement nommée `CONNECTION_STRING` qui spécifie une chaîne de connexion que votre application peut utiliser pour se connecter à une base de données.

A l'intérieur de l'environnement Python s'exécutant dans Elastic Beanstalk, ces valeurs sont accessibles à l'aide du dictionnaire `os.environ` Python. Pour plus d'informations, consultez [http://docs.python. org/library/os.html](http://docs.python.org/library/os.html).

Vous pouvez utiliser un code similaire au suivant pour accéder aux clés et aux paramètres :

```
import os
endpoint = os.environ['API_ENDPOINT']
```

Les propriétés de l'environnement peuvent également fournir des informations à une infrastructure. Par exemple, vous pouvez créer une propriété nommée `DJANGO_SETTINGS_MODULE` pour configurer Django pour utiliser un module de paramètres spécifique. Selon l'environnement, cette valeur peut être `development.settings`, `production.settings`, etc.

Pour plus d’informations, consultez [Variables d'environnement et autres paramètres du logiciel](environments-cfg-softwaresettings.md).

## Espaces de noms de la configuration Python
<a name="python-namespaces"></a>

Vous pouvez utiliser un [fichier de configuration](ebextensions.md) pour définir des options de configuration et exécuter d'autres tâches de configuration d'instance pendant les déploiements. Les options de configuration peuvent être [spécifiques à la plate-forme](command-options-specific.md) ou s'appliquer à [toutes les plateformes](command-options-general.md) du service Elastic Beanstalk dans son ensemble. Les options de configuration sont organisées en *espaces de noms.*

La plateforme Python définit des options dans les espaces de noms `aws:elasticbeanstalk:environment:proxy`, `aws:elasticbeanstalk:environment:proxy:staticfiles` et `aws:elasticbeanstalk:container:python`.

L'exemple suivant de fichier de configuration spécifie des paramètres d'option de configuration pour créer une propriété d'environnement nommée `DJANGO_SETTINGS_MODULE`, deux options de fichiers statiques qui mappent un répertoire nommé `statichtml` avec le chemin d'accès `/html`, un répertoire nommé `staticimages` avec le chemin d'accès `/images` et des paramètres supplémentaires dans l'espace de noms `[aws:elasticbeanstalk:container:python](command-options-specific.md#command-options-python)`. Cet espace de noms contient des options qui vous permettent de spécifier l'emplacement du script WSGI dans votre code source et le nombre de threads et de processus à exécuter dans WSGI.

```
option_settings:
  aws:elasticbeanstalk:application:environment:
    DJANGO_SETTINGS_MODULE: production.settings
  aws:elasticbeanstalk:environment:proxy:
    ProxyServer: apache
  aws:elasticbeanstalk:environment:proxy:staticfiles:
    /html: statichtml
    /images: staticimages
  aws:elasticbeanstalk:container:python:
    WSGIPath: ebdjango.wsgi:application
    NumProcesses: 3
    NumThreads: 20
```

**Remarques**  
Si vous utilisez une version de plateforme AMI Python Amazon Linux (antérieure à Amazon Linux 2), remplacez la valeur `WSGIPath` par `ebdjango/wsgi.py`. La valeur de l'exemple fonctionne avec le serveur WSGI Gunicorn, qui n'est pas pris en charge sur les versions de la plateforme AMI Amazon Linux.
De plus, ces anciennes versions de plateforme utilisent un espace de noms différent pour configurer les fichiers statiques `aws:elasticbeanstalk:container:python:staticfiles`. Il a les mêmes noms d'option et la même sémantique que l'espace de noms de fichier statique standard.

Les fichiers de configuration prennent également en charge plusieurs clés permettant de [modifier davantage le logiciel sur les instances de votre environnement](customize-containers-ec2.md). Cet exemple utilise la clé de [packages](customize-containers-ec2.md#linux-packages) pour installer Memcached avec `yum` et des [commandes de conteneur](customize-containers-ec2.md#linux-container-commands) pour exécuter des commandes qui configurent le serveur durant le déploiement :

```
packages:
  yum:
    libmemcached-devel: '0.31'

container_commands:
  collectstatic:
    command: "django-admin.py collectstatic --noinput"
  01syncdb:
    command: "django-admin.py syncdb --noinput"
    leader_only: true
  02migrate:
    command: "django-admin.py migrate"
    leader_only: true
  03wsgipass:
    command: 'echo "WSGIPassAuthorization On" >> ../wsgi.conf'
  99customize:
    command: "scripts/customize.sh"
```

Elastic Beanstalk fournit de nombreuses options de configuration pour personnaliser votre environnement. En plus des fichiers de configuration, vous pouvez également définir des options de configuration à l'aide de la console, de configurations enregistrées, de la CLI EB ou d' AWS CLI. Pour plus d’informations, consultez [Options de configuration](command-options.md).

## L'`python3`exécutable
<a name="python3-executable"></a>

La version de l'`python3`exécutable disponible sur les EC2 instances dans les environnements Python d'Elastic Beanstalk ne correspondra pas toujours à la même version de Python utilisée par la plateforme. Par exemple, sur la plate-forme Python 3.12 AL2 023, `/usr/bin/python3` pointe vers Python 3.9. Cela est dû au fait que Python 3.9 est le *système Python* sur AL2 023. Pour plus d'informations, consultez [Python in AL2 023](https://docs.aws.amazon.com/linux/al2023/ug/python.html) dans le *guide de l'utilisateur Amazon Linux 2023*. Vous pouvez accéder à un exécutable correspondant à la version de Python utilisée par la plateforme à un emplacement versionné (par exemple`/usr/bin/python3.12`) ou dans le `bin` répertoire de l'environnement virtuel de l'application (par exemple`/var/app/venv/staging-LQM1lest/bin/python3`). La plate-forme utilise le bon exécutable Python correspondant à la branche de plate-forme. 

# Configuration du serveur WSGI avec un profil sur Elastic Beanstalk
<a name="python-configuration-procfile"></a>

Vous pouvez ajouter un [`Procfile`](platforms-linux-extend.build-proc.md#platforms-linux-extend.proc) à votre solution groupée source pour spécifier et configurer le serveur WSGI pour votre application. Vous pouvez spécifier des commandes de démarrage et d'exécution personnalisées dans le`Procfile`.

Lorsque vous utilisez un `Procfile`, il remplace les options d'espace de noms `aws:elasticbeanstalk:container:python` que vous définissez à l'aide des fichiers de configuration.

L'exemple suivant utilise un `Procfile` pour spécifier UWSGi comme serveur et le configurer.

**Example Procfile**  

```
web: uwsgi --http :8000 --wsgi-file application.py --master --processes 4 --threads 2
```

L'exemple suivant utilise un `Procfile` pour configurer Gunicorn, le serveur WSGI par défaut.

**Example Procfile**  

```
web: gunicorn --bind :8000 --workers 3 --threads 2 project.wsgi:application
```

**Remarques**  
Si vous configurez un serveur WSGI autre que Gunicorn, assurez-vous de le spécifier également en tant que dépendance de votre application, afin qu'il soit installé sur vos instances d'environnement. Pour plus d'informations sur la spécification de dépendance, consultez [Spécification des dépendances à l'aide d'un fichier d'exigences sur Elastic Beanstalk](python-configuration-requirements.md).
Le port par défaut du serveur WSGI est 8 000. Si vous spécifiez un numéro de port différent dans votre commande `Procfile`, définissez également la [propriété d'environnement](environments-cfg-softwaresettings.md) `PORT` sur ce numéro de port.

# Spécification des dépendances à l'aide d'un fichier d'exigences sur Elastic Beanstalk
<a name="python-configuration-requirements"></a>

Cette rubrique décrit comment configurer votre application pour installer les autres packages Python dont elle a besoin. Une application Python classique comporte des dépendances par rapport à d'autres packages Python tiers. Avec la plateforme Elastic Beanstalk Python, vous disposez de plusieurs méthodes pour spécifier les packages Python dont dépend votre application.

## Utilisation de `pip` et `requirements.txt`
<a name="python-configuration-requirements.txt"></a>

L'outil standard pour installer les packages Python est `pip`. Il s'agit d'une fonctionnalité qui vous permet de spécifier tous les packages dont vous avez besoin (ainsi que leurs versions) dans un fichier Requirements unique. Pour plus d'informations sur le fichier d'exigences, consultez [Format du fichier d'exigences](https://pip.pypa.io/en/latest/reference/requirements-file-format/#requirements-file-format) (français non garanti) sur le site web de documentation de pip.

Créez un fichier `requirements.txt` et placez-le dans le répertoire de niveau supérieur de votre solution groupée source. Voici un exemple de fichier `requirements.txt` pour Django.

```
Django==2.2
mysqlclient==2.0.3
```

Dans votre environnement de développement, vous pouvez utiliser la commande `pip freeze` pour générer votre fichier Requirements.

```
~/my-app$ pip freeze > requirements.txt
```

Pour vous assurer que votre fichier Requirements contient uniquement des packages qui sont réellement utilisés par votre application, utilisez un [environnement virtuel](python-development-environment.md#python-common-setup-venv) sur lequel seuls ces packages sont installés. En dehors d'un environnement virtuel, le résultat de `pip freeze` comprendra tous les packages `pip` installés sur votre ordinateur de développement, y compris ceux livrés avec votre système d'exploitation.

**Note**  
Sur les versions de la plateforme AMI Python Amazon Linux, Elastic Beanstalk ne prend pas en charge nativement Pipenv ou Pipfiles. Si vous utilisez Pipenv pour gérer les dépendances de votre application, exécutez la commande suivante pour générer un fichier `requirements.txt`.  

```
~/my-app$ pipenv lock -r > requirements.txt
```
Pour en savoir plus, consultez [Generating a requirements.txt](https://pipenv.readthedocs.io/en/latest/advanced/#generating-a-requirements-txt) dans la documentation.

## Utilisation de Pipenv et `Pipfile`
<a name="python-configuration-requirements.pipenv"></a>

Pipenv est un outil d'emballage Python moderne. Il combine l'installation de packages avec la création et la gestion d'un fichier de dépendance et d'un environnement virtuel pour votre application. Pour plus d'informations, consultez [Pipenv: Python Dev Workflow for Humans](https://pipenv.readthedocs.io/en/latest/).

Pipenv maintient deux fichiers : 
+ `Pipfile` – Ce fichier contient différents types de dépendances et d'exigences.
+ `Pipfile.lock` – Ce fichier contient un instantané de version qui permet des créations déterministes.

Vous pouvez créer ces fichiers dans votre environnement de développement et les inclure dans le répertoire de premier niveau de la solution groupée source que vous déployez sur Elastic Beanstalk. Pour plus d'informations sur ces deux fichiers, consultez [Exemples de Pipfile et de Pipfile.lock](https://pipenv.pypa.io/en/latest/basics/#) (français non garanti).



L'exemple suivant utilise Pipenv pour installer Django et le framework REST Django. Ces commandes créent les fichiers `Pipfile` et `Pipfile.lock`.

```
~/my-app$ pipenv install django
~/my-app$ pipenv install djangorestframework
```

 

## Priorité
<a name="python-configuration-requirements.precedence"></a>

Si vous incluez plusieurs fichiers d'exigences décrits dans cette rubrique, Elastic Beanstalk n'en utilise qu'un. La liste suivante montre la priorité, par ordre décroissant.

1. `requirements.txt`

1. `Pipfile.lock`

1. `Pipfile`

**Note**  
À partir de la version de la plateforme Amazon Linux 2 du 7 mars 2023, si vous fournissez plusieurs de ces fichiers, Elastic Beanstalk émettra un message de console indiquant lequel des fichiers de dépendances a été utilisé lors d'un déploiement.

Les étapes suivantes décrivent la logique suivie par Elastic Beanstalk pour installer les dépendances lors du déploiement d'une instance.
+ S'il existe un fichier `requirements.txt`, nous utilisons la commande `pip install -r requirements.txt`.
+ À partir de la version de la plateforme Amazon Linux 2 du 7 mars 2023, s'il n'y a pas de fichier `requirements.txt`, mais qu'il y a un fichier `Pipfile.lock`, nous utilisons la commande `pipenv sync`. Avant cette version, nous utilisions `pipenv install --ignore-pipfile`.
+ S'il n'y a ni fichier `requirements.txt` ni fichier `Pipfile.lock`, mais qu'il y en a un fichier `Pipfile`, on utilise la commande `pipenv install --skip-lock`.
+ Si aucun des trois fichiers d'exigences n'est trouvé, nous n'installons aucune dépendance d'application.

# 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).

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

Ce didacticiel vous guide tout au long du déploiement d'un site web [Django](https://www.djangoproject.com/) par défaut, généré automatiquement, sur un environnement AWS Elastic Beanstalk exécutant Python. Ce tutoriel vous montre comment héberger une application web Python dans le cloud à l'aide d'un environnement Elastic Beanstalk. 

Dans le cadre de ce didacticiel, vous effectuerez les tâches suivantes :
+ [Configuration d'un environnement virtuel Python et installation de Django](#python-django-setup-venv)
+ [Création d'un projet Django](#python-django-create-app)
+ [Configurer votre application Django pour Elastic Beanstalk](#python-django-configure-for-eb) 
+ [Déploiement de votre site avec l'interface de ligne de commande (CLI) EB](#python-django-deploy) 
+ [Mise à jour de votre application](#python-django-update-app) 
+ [Nettoyage](#python-django-stopping)

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

Pour suivre ce didacticiel, la [Configuration de votre environnement de développement Python](python-development-environment.md) doit être terminée et les packages suivants installés :
+ Python 3.7 ou version ultérieure
+ `pip`
+ `virtualenv`
+ `awsebcli`

L'infrastructure [Django](https://www.djangoproject.com/) est installée dans le cadre de ce tutoriel.

**Note**  
Créer des environnements avec l'interface de ligne de commande (CLI) EB nécessite un [rôle de service](concepts-roles-service.md). Vous pouvez créer un rôle de service en créant un environnement dans la console Elastic Beanstalk. Si vous n'avez pas de rôle de service, l'interface de ligne de commande (CLI) EB essaie d'en créer un lorsque vous exécutez `eb create`.

## Configuration d'un environnement virtuel Python et installation de Django
<a name="python-django-setup-venv"></a>

Créez un environnement virtuel avec `virtualenv` et utilisez-le pour installer Django et ses dépendances. En utilisant un environnement virtuel, vous pouvez savoir exactement de quels packages votre application a besoin, afin que les packages requis soient installés sur les EC2 instances Amazon qui exécutent votre application. 

Les étapes suivantes illustrent les commandes que vous devez entrer pour les systèmes Unix et Windows, affichées sur des onglets distincts.

**Pour configurer votre environnement virtuel**

1. Créez un environnement virtuel nommé `eb-virt`.

------
#### [ Unix-based systems ]

   ```
   ~$ virtualenv ~/eb-virt
   ```

------
#### [ Windows ]

   ```
   C:\> virtualenv %HOMEPATH%\eb-virt
   ```

------

1. Activez l’environnement virtuel.

------
#### [ Unix-based systems ]

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

------
#### [ Windows ]

   ```
   C:\>%HOMEPATH%\eb-virt\Scripts\activate
   (eb-virt) C:\>
   ```

------

   Vous verrez `(eb-virt)` ajouté à votre invite de commande, ce qui indique que vous êtes dans un environnement virtuel.
**Note**  
Les instructions restantes montrent l'invite de commande Linux dans votre répertoire de base `~$`. Sous Windows`C:\Users\USERNAME>`, voici où se *USERNAME* trouve votre nom de connexion Windows.

1. Utilisez `pip` pour installer Django.

   ```
   (eb-virt)~$ pip install django==2.2
   ```
**Note**  
La version Django que vous installez doit être compatible avec la version Python sur la configuration Elastic Beanstalk Python que vous choisissez pour déployer votre application. Pour plus d'informations sur le déploiement, consultez [Déploiement de votre site avec l'interface de ligne de commande (CLI) EB](#python-django-deploy) dans cette rubrique.  
Pour plus d'informations sur les versions actuelles de la plateforme Python, consultez [Python](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) dans le document *Plateformes prises en charge par AWS Elastic Beanstalk *.  
Pour plus d'informations sur la compatibilité de la version Django avec Python, consultez [Quelle version de Python puis-je utiliser avec Django ?](https://docs.djangoproject.com/en/3.1/faq/install/#what-python-version-can-i-use-with-django)

1. Pour vérifier que Django est installé, entrez ce qui suit.

   ```
   (eb-virt)~$ pip freeze
   Django==2.2
   ...
   ```

   Cette commande répertorie tous les packages installés dans votre environnement virtuel. Plus tard, vous utiliserez le résultat de cette commande pour configurer votre projet à utiliser avec Elastic Beanstalk.

## Création d'un projet Django
<a name="python-django-create-app"></a>

Vous êtes maintenant prêt à créer un projet Django et à l'exécuter sur votre ordinateur, à l'aide de l'environnement virtuel.

**Note**  
Ce didacticiel utilise SQLite un moteur de base de données inclus dans Python. La base de données est déployée avec vos fichiers de projet. Pour les environnements de production, nous vous recommandons d'utiliser Amazon Relational Database Service (Amazon RDS) et de le séparer de votre environnement. Pour de plus amples informations, veuillez consulter [Ajouter une instance de base de données Amazon RDS à votre environnement Python Elastic Beanstalk](create-deploy-python-rds.md).

**Pour générer une application Django**

1. Activez votre environnement virtuel.

------
#### [ Unix-based systems ]

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

------
#### [ Windows ]

   ```
   C:\>%HOMEPATH%\eb-virt\Scripts\activate
   (eb-virt) C:\>
   ```

------

   Vous verrez le préfixe `(eb-virt)` ajouté à votre invite de commande, ce qui indique que vous êtes dans un environnement virtuel.
**Note**  
Les instructions restantes montrent l'invite de commande Linux `~$` dans votre répertoire de base et le répertoire de base Linux `~/`. Sous Windows`C:\Users\USERNAME>`, voici où se *USERNAME* trouve votre nom de connexion Windows.

1. Utilisez la commande `django-admin startproject` pour créer un projet Django nommé `ebdjango`.

   ```
   (eb-virt)~$ django-admin startproject ebdjango
   ```

   Cette commande crée un site Django standard nommé **ebdjango** avec la structure de répertoires suivante.

   ```
   ~/ebdjango
     |-- ebdjango
     |   |-- __init__.py
     |   |-- settings.py
     |   |-- urls.py
     |   `-- wsgi.py
     `-- manage.py
   ```

1. Exécutez votre site Django localement avec `manage.py runserver`.

   ```
   (eb-virt) ~$ cd ebdjango
   ```

   ```
   (eb-virt) ~/ebdjango$ python manage.py runserver
   ```

1. Dans un navigateur web, ouvrez `http://127.0.0.1:8000/` pour afficher le site.

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

   ```
   Django version 2.2, using settings 'ebdjango.settings'
   Starting development server at http://127.0.0.1:8000/
   Quit the server with CONTROL-C.
   [07/Sep/2018 20:14:09] "GET / HTTP/1.1" 200 16348
   Ctrl+C
   ```

## Configurer votre application Django pour Elastic Beanstalk
<a name="python-django-configure-for-eb"></a>

Maintenant que vous avez un site Django résidant sur votre ordinateur local, vous pouvez le configurer pour le déploiement avec Elastic Beanstalk.

Par défaut, Elastic Beanstalk recherche un fichier nommé `application.py` pour démarrer votre application. Comme il n'existe pas dans le projet Django que vous avez créé, vous devez apporter quelques modifications à l'environnement de votre application. Vous devez également définir des variables d'environnement afin que les modules de votre application puissent être chargés.

**Pour configurer votre site pour Elastic Beanstalk**

1. Activez votre environnement virtuel.

------
#### [ Unix-based systems ]

   ```
   ~/ebdjango$ source ~/eb-virt/bin/activate
   ```

------
#### [ Windows ]

   ```
   C:\Users\USERNAME\ebdjango>%HOMEPATH%\eb-virt\Scripts\activate
   ```

------

1. Exécutez `pip freeze`, puis enregistrez les données de sortie dans un fichier nommé `requirements.txt`.

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

   Elastic `requirements.txt` Beanstalk permet de déterminer le package à installer EC2 sur les instances qui exécutent votre application.

1. Créez un répertoire nommé `.ebextensions`.

   ```
   (eb-virt) ~/ebdjango$ mkdir .ebextensions
   ```

1. Dans le répertoire `.ebextensions`, ajoutez un [fichier de configuration](ebextensions.md) nommé `django.config` avec le texte suivant.  
**Example \$1/ebdjango/.ebextensions/django.config**  

   ```
   option_settings:
     aws:elasticbeanstalk:container:python:
       WSGIPath: ebdjango.wsgi:application
   ```

   Ce paramètre, `WSGIPath`, spécifie l'emplacement du script WSGI qu'Elastic Beanstalk utilise pour lancer votre application.
**Note**  
Si vous utilisez une version de plateforme AMI Python Amazon Linux (antérieure à Amazon Linux 2), remplacez la valeur `WSGIPath` par `ebdjango/wsgi.py`. La valeur de l'exemple fonctionne avec le serveur WSGI Gunicorn, qui n'est pas pris en charge sur les versions de la plateforme AMI Amazon Linux.

1. Désactivez votre environnement virtuel avec la commande `deactivate`.

   ```
   (eb-virt) ~/ebdjango$ deactivate
   ```

   Réactivez votre environnement virtuel chaque fois que vous devez ajouter des packages à votre application ou exécuter votre application localement.

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

Vous avez ajouté tout ce dont vous avez besoin pour déployer votre application sur Elastic Beanstalk. Le répertoire de votre projet devrait maintenant se présenter comme suit.

```
~/ebdjango/
|-- .ebextensions
|   `-- django.config
|-- ebdjango
|   |-- __init__.py
|   |-- settings.py
|   |-- urls.py
|   `-- wsgi.py
|-- db.sqlite3
|-- manage.py
`-- requirements.txt
```

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

Immédiatement après le déploiement, vous allez modifier la configuration de Django afin d'ajouter le nom de domaine attribué par Elastic Beanstalk à votre application au code `ALLOWED_HOSTS` de Django. Ensuite, vous redéploierez votre application. Il s'agit d'une exigence de sécurité de Django, conçue pour empêcher les attaques de l'en-tête HTTP `Host`. Pour plus d'informations, consultez la section [Validation de l'en-tête Host](https://docs.djangoproject.com/en/2.2/topics/security/#host-headers-virtual-hosting).

**Pour créer un environnement et déployer votre application Django**
**Note**  
Ce tutoriel utilise l'interface de ligne de commande (CLI) EB comme mécanisme de déploiement, mais vous pouvez également utiliser la console Elastic Beanstalk pour déployer un fichier ZIP où se trouve le contenu de votre projet. 

1. Initialisez votre référentiel de la CLI EB avec la commande **eb init** :

   ```
   ~/ebdjango$ eb init -p python-3.7 django-tutorial
   Application django-tutorial has been created.
   ```

   Cette commande crée une application nommée `django-tutorial`. Elle configure également votre référentiel local pour créer des environnements avec la dernière version de la plateforme Python 3.7.

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

   ```
   ~/ebdjango$ 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**.

   ```
   ~/ebdjango$ eb create django-env
   ```
**Note**  
Si un message d'erreur « rôle de service requis » s'affiche, exécutez `eb create` de manière interactive (sans spécifier de nom d'environnement) et l'interface de ligne de commande (CLI) EB créera le rôle pour vous.

   Cette commande crée un environnement Elastic Beanstalk équilibré en charge nommé `django-env`. La création d'un environnement prend environ 5 minutes. Lorsqu'Elastic Beanstalk crée les ressources nécessaires pour exécuter votre application, il génère des messages d'information que l'interface de ligne de commande (CLI) EB relaie à votre terminal.

1. Lorsque le processus de création de l'environnement est terminé, recherchez le nom de domaine de votre nouvel environnement en exécutant **eb status**.

   ```
   ~/ebdjango$ eb status
   Environment details for: django-env
     Application name: django-tutorial
     ...
     CNAME: eb-django-app-dev.elasticbeanstalk.com
     ...
   ```

   Le nom de domaine de votre environnement est la valeur de la propriété `CNAME`.

1. Ouvrez le fichier `settings.py` dans le répertoire `ebdjango`. Recherchez le paramètre `ALLOWED_HOSTS`, puis ajoutez le nom de domaine de votre application que vous avez trouvé à l'étape précédente à la valeur de ce paramètre. Si vous ne trouvez pas ce paramètre dans le fichier, ajoutez-le sur une nouvelle ligne.

   ```
   ...
   ALLOWED_HOSTS = ['eb-django-app-dev.elasticbeanstalk.com']
   ```

1. Enregistrez le fichier, puis déployez votre application en exécutant **eb deploy**. Lorsque vous exécutez **eb deploy**, l'interface de ligne de commande (CLI) EB crée un bundle avec le contenu de votre répertoire de projet et le déploie dans votre environnement.

   ```
   ~/ebdjango$ eb deploy
   ```
**Note**  
Si vous utilisez Git avec votre projet, veuillez consulter [Utilisation de l'interface de ligne de commande EB avec Git](eb3-cli-git.md).

1. Lorsque le processus de mise à jour de l'environnement est terminé, ouvrez votre site web avec la commande **eb open**.

   ```
   ~/ebdjango$ eb open
   ```

   Celle-ci ouvre une fenêtre de navigation en utilisant le nom de domaine créé pour votre application. Vous devez voir le même site web Django que celui que vous avez créé et testé localement.

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 Django avec Elastic Beanstalk \$1

## Mise à jour de votre application
<a name="python-django-update-app"></a>

Maintenant que vous disposez d'une application en cours d'exécution sur Elastic Beanstalk, vous pouvez mettre à jour et redéployer votre application ou sa configuration, et Elastic Beanstalk va effectuer les tâches de mise à jour de vos instances et de démarrage de la nouvelle version de votre application.

Pour cet exemple, nous activerons la console d'administration Django et configurerons quelques autres paramètres.

### Modification des paramètres de votre site
<a name="python-django-modify-site"></a>

Par défaut, votre site web Django utilise le fuseau horaire UTC pour afficher l'heure. Vous pouvez modifier cela en spécifiant un fuseau horaire dans `settings.py`.

**Pour modifier le fuseau horaire de votre site**

1. Modifiez le paramètre `TIME_ZONE` dans `settings.py`.  
**Example \$1/ .py ebdjango/ebdjango/settings**  

   ```
   ...
   # Internationalization
   LANGUAGE_CODE = 'en-us'
   TIME_ZONE = 'US/Pacific'
   USE_I18N = True
   USE_L10N = True
   USE_TZ = True
   ```

   Pour obtenir une liste des fuseaux horaires, consultez [cette page](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones).

1. Déployez l'application dans votre environnement Elastic Beanstalk.

   ```
   ~/ebdjango/$ eb deploy
   ```

### Création d'un administrateur de site
<a name="python-django-create-admin"></a>

Vous pouvez créer un administrateur de site pour votre application Django afin d'accéder à la console d'administration directement à partir du site web. Les informations de connexion administrateur sont stockées en toute sécurité dans l'image de base de données locale incluse dans le projet par défaut que Django génère.

**Pour créer un administrateur de site**

1. Initialisez la base de données locale de votre application Django.

   ```
   (eb-virt) ~/ebdjango$ python manage.py migrate
   Operations to perform:
     Apply all migrations: admin, auth, contenttypes, sessions
   Running migrations:
     Applying contenttypes.0001_initial... OK
     Applying auth.0001_initial... OK
     Applying admin.0001_initial... OK
     Applying admin.0002_logentry_remove_auto_add... OK
     Applying admin.0003_logentry_add_action_flag_choices... OK
     Applying contenttypes.0002_remove_content_type_name... OK
     Applying auth.0002_alter_permission_name_max_length... OK
     Applying auth.0003_alter_user_email_max_length... OK
     Applying auth.0004_alter_user_username_opts... OK
     Applying auth.0005_alter_user_last_login_null... OK
     Applying auth.0006_require_contenttypes_0002... OK
     Applying auth.0007_alter_validators_add_error_messages... OK
     Applying auth.0008_alter_user_username_max_length... OK
     Applying auth.0009_alter_user_last_name_max_length... OK
     Applying sessions.0001_initial... OK
   ```

1. Exécutez `manage.py createsuperuser` pour créer un administrateur.

   ```
   (eb-virt) ~/ebdjango$ python manage.py createsuperuser
   Username: admin
   Email address: me@mydomain.com
   Password: ********
   Password (again): ********
   Superuser created successfully.
   ```

1. Pour dire à Django où stocker les fichiers statiques, définissez `STATIC_ROOT` dans `settings.py`.  
**Example \$1/ .py ebdjango/ebdjango/settings**  

   ```
   # Static files (CSS, JavaScript, Images)
   # https://docs.djangoproject.com/en/2.2/howto/static-files/
   STATIC_URL = '/static/'
   STATIC_ROOT = 'static'
   ```

1. Exécutez `manage.py collectstatic` pour remplir le `static` répertoire avec des ressources statiques (JavaScript, CSS et images) pour le site d'administration.

   ```
   (eb-virt) ~/ebdjango$ python manage.py collectstatic
   119 static files copied to ~/ebdjango/static
   ```

1. Déployez votre application.

   ```
   ~/ebdjango$ eb deploy
   ```

1. Affichez la console d'administration en ouvrant le site dans votre navigateur, en ajoutant `/admin/` à l'URL du site, comme suit.

   ```
   http://djang-env.p33kq46sfh.us-west-2.elasticbeanstalk.com/admin/
   ```  
![\[Entrez le nom d'utilisateur et le mot de passe que vous avez créés à l'étape 2 afin de vous connecter à la console d'administration.\]](http://docs.aws.amazon.com/fr_fr/elasticbeanstalk/latest/dg/images/eb_django_admin_login.png)

1. Connectez-vous avec le nom utilisateur et le mot de passe que vous avez configurés à l'étape 2.  
![\[La console d'administration Django de votre site web Django déployé avec Elastic Beanstalk\]](http://docs.aws.amazon.com/fr_fr/elasticbeanstalk/latest/dg/images/eb_django_admin_console.png)

Vous pouvez utiliser une procédure similaire de local updating/testing suivie de**eb deploy**. Elastic Beanstalk prend en charge les tâches de mise à jour de vos serveurs en direct, afin que vous puissiez vous concentrer sur le développement d'applications au lieu de l'administration du serveur \$1

### Ajout d'un fichier de configuration de migration de base de données
<a name="python-django-migrate-site"></a>

Vous pouvez ajouter des commandes à votre script `.ebextensions`, qui sont exécutées lors de la mise à jour de votre site. Cela vous permet de générer automatiquement des migrations de base de données.

**Pour ajouter une étape de migration lorsque votre application est déployée**

1. Créez un [fichier de configuration](ebextensions.md) nommé `db-migrate.config` avec le contenu suivant.  
**Example \$1/ebdjango/.ebextensions/db-migrate.config**  

   ```
   container_commands:
     01_migrate:
       command: "source /var/app/venv/*/bin/activate && python3 manage.py migrate"
       leader_only: true
   option_settings:
     aws:elasticbeanstalk:application:environment:
       DJANGO_SETTINGS_MODULE: ebdjango.settings
   ```

   Ce fichier de configuration active l'environnement virtuel du serveur et exécute la commande `manage.py migrate` lors du processus de déploiement, avant le démarrage de votre application. Étant donné que cette commande est exécutée avant le démarrage de l'application, vous devez également configurer la variable d'environnement `DJANGO_SETTINGS_MODULE` explicitement (généralement, `wsgi.py` s'occupe de cette tâche pour vous pendant le démarrage). La spécification de `leader_only: true` dans la commande garantit qu'elle est exécutée une seule fois lors d'un déploiement sur plusieurs instances.

1. Déployez votre application.

   ```
   ~/ebdjango$ eb deploy
   ```

## Nettoyage
<a name="python-django-stopping"></a>

Pour économiser des heures d'instance et d'autres AWS ressources entre les sessions de développement, mettez fin à votre environnement Elastic Beanstalk avec. **eb terminate**

```
~/ebdjango$ eb terminate django-env
```

Cette commande met fin à l'environnement et à toutes les AWS ressources qui s'y exécutent. Cependant, elle ne supprime pas l'application. Vous pouvez donc toujours créer d'autres environnements avec la même configuration en exécutant à nouveau **eb create**.

Si vous en avez terminé avec l'exemple d'application, vous pouvez également supprimer le dossier du projet et l'environnement virtuel.

```
~$ rm -rf ~/eb-virt
~$ rm -rf ~/ebdjango
```

## Étapes suivantes
<a name="python-django-next-steps"></a>

Pour plus d'informations sur Django, y compris un didacticiel approfondi, consultez [la documentation officielle](https://docs.djangoproject.com/en/2.2/).

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

# Ajouter une instance de base de données Amazon RDS à votre environnement Python Elastic Beanstalk
<a name="create-deploy-python-rds"></a>

Cette rubrique fournit des instructions pour créer un Amazon RDS à l'aide de la console Elastic Beanstalk. Vous pouvez utiliser une instance de base de données Amazon Relational Database Service (Amazon RDS) pour stocker les données collectées et modifiées par votre application. La base de données peut être liée à votre environnement et gérée par Elastic Beanstalk, ou elle peut être créée comme déliée et gérée en externe par un autre service. Dans ces instructions, la base de données est couplée à votre environnement et gérée par Elastic Beanstalk. Pour plus d'informations sur l'intégration d'un Amazon RDS avec Elastic Beanstalk, consultez [Ajout d'une base de données à votre environnement Elastic Beanstalk](using-features.managing.db.md).

**Topics**
+ [Ajout d'une instance de base de données à votre environnement](#python-rds-create)
+ [Téléchargement d'un pilote](#python-rds-drivers)
+ [Connexion à une base de données](#python-rds-connect)

## Ajout d'une instance de base de données à votre environnement
<a name="python-rds-create"></a>

**Pour ajouter une instance DB à votre environnement**

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. Dans le panneau de navigation, choisissez **Configuration**.

1. Dans la catégorie de configuration **Database (Base de données)**, choisissez **Edit (Modifier)**.

1. Choisissez un moteur de base de données, puis saisissez un nom d'utilisateur et un mot de passe.

1. Pour enregistrer les modifications, cliquez sur **Appliquer** en bas de la page.

L'ajout d'une instance DB prend environ 10 minutes. Une fois la mise à jour de l'environnement terminée, le nom d'hôte de l'instance DB et les autres informations de connexion sont disponibles dans votre application, via les propriétés d'environnement suivantes :


| Nom de la propriété | Description | Valeur de la propriété | 
| --- | --- | --- | 
|  `RDS_HOSTNAME`  |  Nom d'hôte de l'instance DB.  |  Sous l'onglet **Connectivity & security** (Connectivité et sécurité) de la console Amazon RDS : **Endpoint** (Point de terminaison).  | 
|  `RDS_PORT`  |  Port sur lequel l'instance de base de données accepte des connexions. La valeur par défaut varie selon les moteurs de base de données.  |  Sous l'onglet **Connectivity & security (Connectivité et sécurité)** de la console Amazon RDS : **Port**.  | 
|  `RDS_DB_NAME`  |  Nom de la base de données, **ebdb**.  |  Sous l'onglet **Configuration** de la console Amazon RDS : **DB Name (Nom de base de données)**.  | 
|  `RDS_USERNAME`  |  Nom d'utilisateur que vous avez configuré pour votre base de données.  |  Sous l'onglet **Configuration** de la console Amazon RDS : **Master username (Identifiant principal)**.  | 
|  `RDS_PASSWORD`  |  Mot de passe que vous avez configuré pour votre base de données.  |  Non disponible pour référence dans la console Amazon RDS.  | 

Pour plus d'informations sur la configuration d'une instance de base de données liée à un environnement Elastic Beanstalk, consultez [Ajout d'une base de données à votre environnement Elastic Beanstalk](using-features.managing.db.md).

## Téléchargement d'un pilote
<a name="python-rds-drivers"></a>

Ajoutez le pilote de base de données au [fichier Requirements](python-configuration-requirements.md) de votre projet.

**Example requirements.txt – Django avec MySQL**  

```
Django==2.2
mysqlclient==2.0.3
```

**Packages de pilotes courants pour Python**
+ **MySQL** – `mysqlclient`
+ **PostgreSQL** – `psycopg2`
+ **Oracle** – `cx_Oracle`
+ **SQL Server** – `adodbapi`

Pour plus d'informations, consultez [Python DatabaseInterfaces](https://wiki.python.org/moin/DatabaseInterfaces) et [Django 2.2 : bases de données prises en charge](https://docs.djangoproject.com/en/2.2/ref/databases).

## Connexion à une base de données
<a name="python-rds-connect"></a>

Elastic Beanstalk fournit des informations de connexion pour les instances de base de données attachées dans les propriétés de l'environnement. Utilisez `os.environ['VARIABLE']` pour lire les propriétés et configurer une connexion de base de données.

**Example Fichier de paramètres Django – Dictionnaire DATABASES**  

```
import os

if 'RDS_HOSTNAME' in os.environ:
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.mysql',
            'NAME': os.environ['RDS_DB_NAME'],
            'USER': os.environ['RDS_USERNAME'],
            'PASSWORD': os.environ['RDS_PASSWORD'],
            'HOST': os.environ['RDS_HOSTNAME'],
            'PORT': os.environ['RDS_PORT'],
        }
    }
```

# Outils et ressources Python
<a name="create-deploy-python-tools-resources"></a>

Il existe plusieurs endroits auxquels vous pouvez accéder pour obtenir une aide supplémentaire lors du développement de vos applications Python :


****  

| Ressource | Description | 
| --- | --- | 
| [AWS SDK pour Python (Boto3) sur GitHub](https://github.com/boto/boto3) | Installez Boto3 à partir de. GitHub | 
| [AWS SDK pour Python (Boto3) page d'accueil](https://aws.amazon.com//sdk-for-python/) | La AWS SDK pour Python (Boto3) page d'accueil. | 
| [Centre pour développeurs Python](https://aws.amazon.com/python/) | Guichet unique pour l'exemple de code, la documentation, les outils et les ressources supplémentaires. |