Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Implementación de aplicaciones Python con Elastic Beanstalk
<a name="create-deploy-python-apps"></a>

Este capítulo proporciona instrucciones para configurar e implementar su aplicación web Python en AWS Elastic Beanstalk. Elastic Beanstalk facilita la implementación, administración y escalado de sus aplicaciones web Python que utilizan Amazon Web Services.

Puede implementar la aplicación en solo unos minutos mediante la interfaz de línea de comandos de Elastic Beanstalk (CLI de EB) o mediante la consola de Elastic Beanstalk. Después de implementar la aplicación de Elastic Beanstalk, puede seguir utilizando la CLI de EB para administrar la aplicación y el entorno, o puede usar la consola de Elastic Beanstalk o la. AWS CLI APIs

Siga los pasos de step-by-step las instrucciones [QuickStart para Python](python-quickstart.md) para crear e implementar una aplicación web Python *Hello World* con la CLI de EB.

**Topics**
+ [QuickStart: Implementar una aplicación de Python en Elastic Beanstalk](python-quickstart.md)
+ [Configuración del entorno de desarrollo de Python para Elastic Beanstalk](python-development-environment.md)
+ [Uso de la plataforma Elastic Beanstalk Python](create-deploy-python-container.md)
+ [Implementación de una aplicación Flask en Elastic Beanstalk](create-deploy-python-flask.md)
+ [Implementación de una aplicación Django en Elastic Beanstalk](create-deploy-python-django.md)
+ [Adición de una instancia de base de datos de Amazon RDS a su entorno de Python de Elastic Beanstalk](create-deploy-python-rds.md)
+ [Herramientas y recursos de Python](create-deploy-python-tools-resources.md)

# QuickStart: Implementar una aplicación de Python en Elastic Beanstalk
<a name="python-quickstart"></a>

En este QuickStart tutorial se explica el proceso de creación de una aplicación de Python y su despliegue en un AWS Elastic Beanstalk entorno.

**No válido para uso en producción**  
Los ejemplos se presentan solo con fines de demostración. No utilice aplicaciones de ejemplo en producción.

**Topics**
+ [Tu AWS cuenta](#python-quickstart-aws-account)
+ [Requisitos previos](#python-quickstart-prereq)
+ [Paso 1: crear una aplicación Python](#python-quickstart-create-app)
+ [Paso 2: ejecutar la aplicación a nivel local](#python-quickstart-run-local)
+ [Paso 3: implementar la aplicación Python con la CLI de EB](#python-quickstart-deploy)
+ [Paso 4: ejecutar la aplicación en Elastic Beanstalk](#python-quickstart-run-eb-ap)
+ [Paso 5: Eliminar](#go-tutorial-cleanup)
+ [AWS recursos para su aplicación](#python-quickstart-eb-resources)
+ [Siguientes pasos](#python-quickstart-next-steps)
+ [Implementar con la consola de Elastic Beanstalk](#python-quickstart-console)

## Tu AWS cuenta
<a name="python-quickstart-aws-account"></a>

Si aún no eres AWS cliente, debes crear una AWS cuenta. El registro le permite acceder a Elastic Beanstalk AWS y a otros servicios que necesite.

Si ya tiene una AWS cuenta, puede pasar a. [Requisitos previos](#python-quickstart-prereq)

### Crea una AWS cuenta
<a name="python-quickstart-aws-account-procedure"></a>

#### Inscríbase en una Cuenta de AWS
<a name="sign-up-for-aws"></a>

Si no tiene uno Cuenta de AWS, complete los siguientes pasos para crearlo.

**Para suscribirse a una Cuenta de AWS**

1. Abrir [https://portal.aws.amazon.com/billing/registro](https://portal.aws.amazon.com/billing/signup).

1. Siga las instrucciones que se le indiquen.

   Parte del procedimiento de registro consiste en recibir una llamada telefónica o mensaje de texto e indicar un código de verificación en el teclado del teléfono.

   Cuando te registras en un Cuenta de AWS, *Usuario raíz de la cuenta de AWS*se crea un. El usuario raíz tendrá acceso a todos los Servicios de AWS y recursos de esa cuenta. Como práctica recomendada de seguridad, asigne acceso administrativo a un usuario y utilice únicamente el usuario raíz para realizar [Tareas que requieren acceso de usuario raíz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS te envía un correo electrónico de confirmación una vez finalizado el proceso de registro. En cualquier momento, puede ver la actividad de su cuenta actual y administrarla accediendo a [https://aws.amazon.com/](https://aws.amazon.com/)y seleccionando **Mi cuenta**.

#### Creación de un usuario con acceso administrativo
<a name="create-an-admin"></a>

Después de crear un usuario administrativo Cuenta de AWS, asegúrelo Usuario raíz de la cuenta de AWS AWS IAM Identity Center, habilite y cree un usuario administrativo para no usar el usuario root en las tareas diarias.

**Proteja su Usuario raíz de la cuenta de AWS**

1.  Inicie sesión [Consola de administración de AWS](https://console.aws.amazon.com/)como propietario de la cuenta seleccionando el **usuario root** e introduciendo su dirección de Cuenta de AWS correo electrónico. En la siguiente página, escriba su contraseña.

   Para obtener ayuda para iniciar sesión con el usuario raíz, consulte [Iniciar sesión como usuario raíz](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) en la *Guía del usuario de AWS Sign-In *.

1. Active la autenticación multifactor (MFA) para el usuario raíz.

   Para obtener instrucciones, consulte [Habilitar un dispositivo MFA virtual para el usuario Cuenta de AWS raíz (consola)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) en la Guía del usuario de *IAM*.

**Creación de un usuario con acceso administrativo**

1. Activar IAM Identity Center.

   Consulte las instrucciones en [Activar AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) en la *Guía del usuario de AWS IAM Identity Center *.

1. En IAM Identity Center, conceda acceso administrativo a un usuario.

   Para ver un tutorial sobre su uso Directorio de IAM Identity Center como fuente de identidad, consulte [Configurar el acceso de los usuarios con la configuración predeterminada Directorio de IAM Identity Center en la](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) Guía del *AWS IAM Identity Center usuario*.

**Inicio de sesión como usuario con acceso de administrador**
+ Para iniciar sesión con el usuario de IAM Identity Center, use la URL de inicio de sesión que se envió a la dirección de correo electrónico cuando creó el usuario de IAM Identity Center.

  Para obtener ayuda para iniciar sesión con un usuario del Centro de identidades de IAM, consulte [Iniciar sesión en el portal de AWS acceso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) en la *Guía del AWS Sign-In usuario*.

**Concesión de acceso a usuarios adicionales**

1. En IAM Identity Center, cree un conjunto de permisos que siga la práctica recomendada de aplicar permisos de privilegios mínimos.

   Para conocer las instrucciones, consulte [Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) en la *Guía del usuario de AWS IAM Identity Center *.

1. Asigne usuarios a un grupo y, a continuación, asigne el acceso de inicio de sesión único al grupo.

   Para conocer las instrucciones, consulte [Add groups](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) en la *Guía del usuario de AWS IAM Identity Center *.

## Requisitos previos
<a name="python-quickstart-prereq"></a>

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema (\$1) y del nombre del directorio actual, si es aplicable.

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

En Linux y macOS, puede utilizar el administrador de shell y paquetes preferido. En Windows, puede [instalar Windows Subsystem para Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) para obtener una versión de Ubuntu y Bash integrada con Windows.

### CLI DE EB
<a name="python-quickstart-prereq.ebcli"></a>

En este tutorial también se utiliza la interfaz de línea de comandos de Elastic Beanstalk (CLI de EB). Para obtener detalles sobre la instalación y configuración de la CLI de EB, consulte [Instalación de la CLI de EB con el script de configuración (recomendado)](eb-cli3.md#eb-cli3-install) y [Configuración de la CLI de EB](eb-cli3-configuration.md).

### Marco de Python y Flask
<a name="python-quickstart-prereq.runtime"></a>

Confirme que tiene una versión de Python con `pip` instalado mediante los siguientes comandos.

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

Si alguno de los comandos anteriores devuelve “*Python no se encontró*”, ejecute los siguientes comandos que utilizan `python` en lugar de `python3`. La configuración de los alias y los enlaces simbólicos puede variar según el sistema operativo y las personalizaciones individuales, por lo que es posible que el comando `python3` no funcione en el equipo.

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

Si no tiene Python instalado en su máquina local, puede descargarlo desde la página [Descargas de Python](https://www.python.org/downloads/) en el sitio web de Python. Para obtener una lista de versiones de lenguaje Python compatibles con Elastic Beanstalk, consulte [Plataformas Python compatibles](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) en la guía *Plataformas de AWS Elastic Beanstalk *. El sitio web *Descargas de Python* proporciona un enlace a la Guía de desarrolladores de Python, donde encontrará instrucciones de instalación y configuración.

**nota**  
El paquete `pip` de Python se incluye de forma predeterminada en Python 3.4 o versiones posteriores.

Si el resultado indica que tiene una versión compatible de Python, pero no `pip`, consulte la página [Instalación](https://pip.pypa.io/en/stable/installation/) en el sitio web *pip.pypa.io*. Proporciona una guía para instalar pip en un entorno de Python que no lo tiene.



Para confirmar que se ha instalado Flask, ejecute el comando siguiente:

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

Si Flask no está instalado, ejecute el siguiente comando para instalarlo:

```
~$ pip install Flask
```

## Paso 1: crear una aplicación Python
<a name="python-quickstart-create-app"></a>

Cree el directorio del proyecto.

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

Creación de un ejemplo de “Hola, Elastic Beanstalk” Aplicación Python que implementará con Elastic Beanstalk.

En el directorio que acaba de crear, cree un archivo de texto llamado `application.py` con el contenido siguiente:

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

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

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

Cree un archivo de texto llamado `requirements.txt` con la siguiente línea. Este archivo contiene los paquetes de `pip` necesarios para ejecutar la aplicación.

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

```
Flask
```

## Paso 2: ejecutar la aplicación a nivel local
<a name="python-quickstart-run-local"></a>

Para implementar la aplicación localmente, ejecute el siguiente comando.

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

Debería ver una salida similar a esta:

```
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 -
```

Vaya a `http://localhost:5000` en un navegador web. El navegador web debería mostrar “Hola, Elastic Beanstalk”.

## Paso 3: implementar la aplicación Python con la CLI de EB
<a name="python-quickstart-deploy"></a>

Ejecute los siguientes comandos para crear un entorno de Elastic Beanstalk en esta aplicación.

 

**Cómo crear un entorno e implementar la aplicación Python**

1. Inicialice el repositorio de la CLI de EB con el comando **eb init**.

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

   Este comando crea una aplicación llamada `python-tutorial` y configura el repositorio local para crear entornos con la versión de la plataforma de Python proporcionada.

1. (Opcional) Ejecute de nuevo **eb init** para configurar un par de claves predeterminadas de forma que pueda usar SSH para conectarse a la instancia de EC2 donde se ejecuta la aplicación.

   ```
   ~/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 ]
   ```

   Seleccione un par de claves si ya tiene uno o siga las instrucciones para crear uno. Si no ve el símbolo del sistema o más adelante necesita cambiar la configuración, ejecute **eb init -i**.

1. Cree un entorno e implemente la aplicación en él con **eb create**. Elastic Beanstalk crea automáticamente un archivo zip para su aplicación y lo inicia en el puerto 5000.

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

   Elastic Beanstalk tarda aproximadamente cinco minutos en crear el entorno.

## Paso 4: ejecutar la aplicación en Elastic Beanstalk
<a name="python-quickstart-run-eb-ap"></a>

Cuando finalice el proceso de creación del entorno, abra el sitio web con **eb open**.

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

¡Enhorabuena\$1 Ha implementado una aplicación de Python con Elastic Beanstalk. Se abre una ventana del navegador con el nombre de dominio creado para su aplicación.

## Paso 5: Eliminar
<a name="go-tutorial-cleanup"></a>

Cuando termine de trabajar con la aplicación, puede terminar el entorno. Elastic Beanstalk AWS cancela todos los recursos asociados a su entorno.

Utilice el comando siguiente de la CLI de EB para terminar su entorno de Elastic Beanstalk.

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

## AWS recursos para su aplicación
<a name="python-quickstart-eb-resources"></a>

Acaba de crear una aplicación de instancia única. Sirve como una aplicación de muestra sencilla con una sola instancia de EC2, por lo que no requiere equilibrio de carga ni escalado automático. Para las aplicaciones de instancia única, Elastic Beanstalk crea los siguientes recursos: AWS 
+ **EC2 instance (Instancia de EC2)**: máquina virtual de Amazon EC2 configurada para ejecutar aplicaciones web en la plataforma que elija.

  Cada plataforma ejecuta un conjunto distinto de software, archivos de configuración y scripts compatibles con una determinada versión de lenguaje, marco y contenedor web (o una combinación de ellos). La mayoría de las plataformas utilizan Apache o nginx como un proxy inverso que procesa el tráfico web delante de la aplicación web, reenvía las solicitudes a esta, administra los recursos estáticos y genera registros de acceso y errores.
+ **Instance security group (Grupo de seguridad de la instancia)**: grupo de seguridad de Amazon EC2 configurado para permitir el tráfico entrante en el puerto 80. Este recurso permite que el tráfico HTTP procedente del equilibrador de carga llegue a la instancia de EC2 en la que se ejecuta la aplicación web. De forma predeterminada, el tráfico no está permitido en otros puertos.
+ **Bucket de Amazon S3**: ubicación de almacenamiento para el código fuente, los registros y otros artefactos que se crean al utilizar Elastic Beanstalk.
+ ** CloudWatch Alarmas de Amazon**: dos CloudWatch alarmas que monitorean la carga de las instancias de su entorno y se activan si la carga es demasiado alta o demasiado baja. Cuando se activa una alarma, en respuesta, el grupo de escalado automático aumenta o reduce los recursos.
+ **CloudFormation pila**: Elastic CloudFormation Beanstalk se utiliza para lanzar los recursos de su entorno y propagar los cambios de configuración. Los recursos se definen en una plantilla que puede verse en la [consola de CloudFormation](https://console.aws.amazon.com/cloudformation).
+  **Nombre de dominio***: un nombre de dominio que se dirige a su aplicación web en el formulario. *subdomain* *region*.elasticbeanstalk.com*. 

Elastic Beanstalk administra todos estos recursos. Cuando termina su entorno, Elastic Beanstalk termina todos los recursos que este contiene.

## Siguientes pasos
<a name="python-quickstart-next-steps"></a>

Una vez que disponga de un entorno que ejecute una aplicación, podrá implementar una nueva versión de la aplicación o una aplicación distinta en cualquier momento. La implementación de una nueva versión de la aplicación es una tarea muy rápida, ya que no se requiere aprovisionar ni reiniciar instancias EC2. También puede explorar el nuevo entorno con la consola de Elastic Beanstalk. Para ver los pasos detallados, consulte [Explore your environment](GettingStarted.md#GettingStarted.Explore) en el capítulo *Getting started* de esta guía.

**Probar más tutoriales**  
Si desea probar otros tutoriales con diferentes aplicaciones de muestra, consulte los siguientes:  
[Implementación de una aplicación Flask en Elastic Beanstalk](create-deploy-python-flask.md)
[Implementación de una aplicación Django en Elastic Beanstalk](create-deploy-python-django.md)

Después de que implemente una aplicación de muestra o dos y esté listo para empezar a desarrollar y poner en funcionamiento las aplicaciones de Python de forma local, consulte [Configuración del entorno de desarrollo de Python para Elastic Beanstalk](python-development-environment.md). 

## Implementar con la consola de Elastic Beanstalk
<a name="python-quickstart-console"></a>

También puede utilizar la consola de Elastic Beanstalk para lanzar la aplicación de muestra. Para ver los pasos detallados, consulte [Create an example application](GettingStarted.md#GettingStarted.CreateApp) en el capítulo *Getting Started* de esta guía.

# Configuración del entorno de desarrollo de Python para Elastic Beanstalk
<a name="python-development-environment"></a>

Este tema proporciona instrucciones para configurar el entorno de desarrollo de Python para probar la aplicación localmente antes de implementarla en AWS Elastic Beanstalk. También hace referencia a sitios web que proporcionan instrucciones de instalación de herramientas útiles.

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema (\$1) y del nombre del directorio actual, si es aplicable.

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

En Linux y macOS, puede utilizar el administrador de shell y paquetes preferido. En Windows, puede [instalar Windows Subsystem para Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) para obtener una versión de Ubuntu y Bash integrada con Windows.

**Topics**
+ [Requisitos previos](#python-common-prereq)
+ [Mediante un entorno virtual](#python-common-setup-venv)
+ [Configuración de un proyecto de Python para Elastic Beanstalk](#python-common-configuring)

## Requisitos previos
<a name="python-common-prereq"></a>

La siguiente lista proporciona los requisitos previos comunes para trabajar con Elastic Beanstalk y las aplicaciones de Python:
+ **Lenguaje Python**: instale la versión del lenguaje Python que se incluye en la versión de la plataforma Python de Elastic Beanstalk que haya elegido. Para obtener una lista de nuestras versiones de lenguaje Python compatibles, consulte [Plataformas Python compatibles](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) en la guía *Plataformas de AWS Elastic Beanstalk *. Si aún no ha configurado Python en su máquina de desarrollo, consulte la página [Descargas de Python](https://www.python.org/downloads/) en el sitio web de Python.
+ **Utilidad `pip`**: la utilidad `pip` es el instalador de paquetes de Python. Instalar y muestra las dependencias de su proyecto, de forma que Elastic Beanstalk sepa cómo configurar el entorno de su aplicación. Para obtener más información sobre `pip`, consulte la [página pip](https://pip.pypa.io/en/stable/) en el sitio web *pip.pypa.io*.
+ **(Opcional) Interfaz de línea de comandos (EB CLI) de Elastic Beanstalk**: la [CLI de EB](eb-cli3.md) puede empaquetar la aplicación con los archivos de implementación necesarios. También crea un entorno Elastic Beanstalk e implementa su aplicación en él. Además, puede realizar implementaciones mediante la consola de Elastic Beanstalk, por lo que la CLI de EB no es estrictamente necesaria.
+ **Instalación de `SSH` funcional**: puede conectarse a las instancias en ejecución mediante el protocolo SSH para examinar o depurar una implementación.
+ **Paquete de `virtualenv`**: esta herramienta de `virtualenv` crea un entorno de desarrollo y prueba para la aplicación. Elastic Beanstalk puede replicar este entorno sin instalar paquetes adicionales que la aplicación no requiera. Para obtener más información, consulte el sitio web [virtualenv](https://virtualenv.pypa.io/en/latest/). Después de instalar Python, puede instalar el paquete de `virtualenv` con el siguiente comando:

  ```
  $ pip install virtualenv
  ```

## Mediante un entorno virtual
<a name="python-common-setup-venv"></a>

Una vez instalados los requisitos previos, configure un entorno virtual con `virtualenv` para instalar las dependencias de la aplicación. Al utilizar un entorno virtual, puede discernir exactamente qué paquetes necesita su aplicación para que los paquetes necesarios se instalen en las EC2 instancias en las que se ejecuta la aplicación.

**Para configurar un entorno virtual**

1. Abra una ventana de línea de comandos y escriba:

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

   *eb\$1python\$1app*Sustitúyalos por un nombre que tenga sentido para la aplicación (es una buena idea usar el nombre de la aplicación). El comando `virtualenv` crea un entorno virtual automáticamente en el directorio especificado e imprime los resultados de sus acciones:

   ```
   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. Una vez que el entorno virtual esté listo, empiece ejecutando el script `activate` ubicado en el directorio `bin` del entorno. Por ejemplo, para iniciar el entorno **eb\$1python\$1app** creado en el paso anterior, escribiría:

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

   El entorno virtual imprime su nombre (por ejemplo: `(eb_python_app)`) al principio de cada símbolo del sistema para recordarle que se encuentra en un entorno de Python virtual.

1. Para dejar de usar su entorno virtual y volver al intérprete de Python predeterminado del sistema con todas las bibliotecas instaladas, ejecute el comando `deactivate`.

   ```
   (eb_python_app) $ deactivate
   ```

**nota**  
Una vez creado, puede reiniciar el entorno virtual en cualquier momento ejecutando de nuevo el script `activate`.

## Configuración de un proyecto de Python para Elastic Beanstalk
<a name="python-common-configuring"></a>

Puede usar la CLI de Elastic Beanstalk para preparar las aplicaciones de Python para su implementación con Elastic Beanstalk.

**Para configurar una aplicación Python para su implementación con Elastic Beanstalk**

1. Desde dentro de su [entorno virtual](#python-common-setup-venv), vuelva a la parte superior del árbol de directorios de su proyecto (`python_eb_app`) y escriba:

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

   Este comando copia los nombres y las versiones de los paquetes que están instalados en su entorno virtual en `requirements.txt`. Por ejemplo, si el paquete *PyYAML*, versión *3.11* está instalado en su entorno virtual, el archivo contendrá la línea:

   ```
   PyYAML==3.11
   ```

   Esto permite que Elastic Beanstalk replique el entorno Python de su aplicación con los mismos paquetes y las mismas versiones que utilizó para desarrollar y probar su aplicación.

1. Configure el repositorio de la CLI de EB con el comando **eb init**. Siga las instrucciones para elegir una región, una plataforma y otras opciones.

De forma predeterminada, Elastic Beanstalk busca un archivo llamado `application.py` para iniciar la aplicación. Si este archivo no existe en el proyecto de Python que ha creado, tendrá que realizar algunos ajustes en el entorno de su aplicación. También necesitará configurar las variables de entorno para que puedan cargarse los módulos de la aplicación. Para obtener más información, consulte [Uso de la plataforma Elastic Beanstalk Python](create-deploy-python-container.md).

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

En este tema se describe cómo configurar, crear y ejecutar las aplicaciones Python en Elastic Beanstalk.

AWS Elastic Beanstalk admite varias ramas de plataforma para diferentes versiones del lenguaje de programación Python. Consulte [Python](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) en el documento *Plataformas de AWS Elastic Beanstalk * para ver una lista completa.

Las aplicaciones web Python se pueden ejecutar detrás de un servidor proxy con WSGI. Elastic Beanstalk proporciona [Gunicorn](https://gunicorn.org/) como el servidor WSGI predeterminado. 

Puede añadir un `Procfile` a su paquete de código fuente para especificar y configurar el servidor WSGI de su aplicación. Para obtener más información, consulte [Configuración del servidor WSGI con un archivo Procfile en Elastic Beanstalk](python-configuration-procfile.md).

Puede usar los archivos `Pipfile` y `Pipfile.lock` creados por Pipenv para especificar las dependencias del paquete de Python y otros requisitos. Para obtener más información sobre cómo especificar dependencias, consulte [Especificación de dependencias mediante un archivo de requisitos en Elastic Beanstalk](python-configuration-requirements.md).

Elastic [Beanstalk proporciona](command-options.md) opciones de configuración que puede usar para personalizar el software que se ejecuta EC2 en las instancias de su entorno de Elastic Beanstalk. Puede configurar las variables de entorno que necesita la aplicación, habilitar la rotación de logs en Amazon S3 y asignar carpetas del código fuente de la aplicación que contengan archivos estáticos a rutas proporcionadas por el servidor proxy.

En la consola de Elastic Beanstalk hay opciones de configuración disponibles para [modificar la configuración de un entorno en ejecución](environment-configuration-methods-after.md). Para evitar perder la configuración del entorno cuando lo termina, puede usar las [configuraciones guardadas](environment-configuration-savedconfig.md) para guardar la configuración y aplicarla posteriormente a otro entorno.

Para guardar la configuración en el código fuente, puede incluir [archivos de configuración](ebextensions.md). Los valores de configuración de los archivos de configuración se aplican cada vez que crea un entorno o que implementa la aplicación. También puede usar archivos de configuración para instalar paquetes, ejecutar scripts y llevar a cabo otras operaciones de personalización de instancias durante las implementaciones.

La configuración aplicada en la consola de Elastic Beanstalk anula la misma configuración en los archivos de configuración, si existe. Esto le permite tener la configuración predeterminada en los archivos de configuración y anularla con la configuración específica del entorno en la consola. Para obtener más información acerca de la prioridad y otros métodos para cambiar valores de configuración, consulte [Opciones de configuración](command-options.md).

En los paquetes de Python disponibles de `pip`, también puede incluir un archivo de requisitos en la raíz del código fuente de la aplicación. Elastic Beanstalk instala los paquetes de dependencias especificados en un archivo de requisitos durante la implementación. Para obtener más información, consulte [Especificación de dependencias mediante un archivo de requisitos en Elastic Beanstalk](python-configuration-requirements.md).

Para obtener más información sobre las diversas formas en las que puede ampliar una plataforma Elastic Beanstalk basada en Linux, consulte [Ampliación de las plataformas Linux de Elastic Beanstalk](platforms-linux-extend.md).

## Configuración del entorno de Python
<a name="create-deploy-python-container-console"></a>

La configuración de la plataforma Python te permite ajustar el comportamiento de tus instancias de Amazon EC2 . Puede editar la configuración de instancias de Amazon del entorno de Elastic Beanstalk mediante EC2 la consola de Elastic Beanstalk.

Utilice la consola de Elastic Beanstalk para configurar los AWS X-Ray ajustes del proceso de Python, habilitar y habilitar la rotación de registros a Amazon S3 y configurar las variables que la aplicación pueda leer del entorno.

**Para configurar su entorno Python en la consola de Elastic Beanstalk**

1. Abra la consola de [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) y, **en** la lista Regiones, seleccione su. Región de AWS

1. En el panel de navegación, elija **Environments** (Entornos) y, a continuación, elija el nombre del entorno en la lista.

1. En el panel de navegación, elija **Configuración**.

1. En la categoría de configuración **Actualizaciones, supervisión y registro**, seleccione **Edición de**.

### Configuración de Python
<a name="python-console-settings"></a>
+ **Proxy server (Servidor proxy)**: el servidor proxy que utilizar en las instancias del entorno. De forma predeterminada, se utiliza nginx.
+ **WSGI Path (Ruta de WSGI)**: el nombre de una ruta a su archivo de la aplicación principal. Por ejemplo, `application.py` o `django/wsgi.py`.
+ **NumProcesses**— El número de procesos que se van a ejecutar en cada instancia de la aplicación.
+ **NumThreads**— El número de subprocesos que se van a ejecutar en cada proceso.

### AWS X-Ray ajustes
<a name="python-console-xray"></a>
+ **Demonio X-Ray**: ejecute el AWS X-Ray demonio para procesar los datos de rastreo del. [AWS X-Ray SDK para Python](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html)

### Log Options (Opciones de registro)
<a name="create-deploy-python-container.console.logoptions"></a>

La sección Log Options tiene dos valores:
+ **Instance profile (Perfil de instancia)**: especifica el perfil de instancia que tiene permiso para obtener acceso al bucket de Amazon S3 asociado con la aplicación.
+ **Habilite la rotación de archivos de registro a Amazon S3**: especifica si los archivos de registro de las EC2 instancias de Amazon de su aplicación se copian en el bucket de Amazon S3 asociado a su aplicación.

### Archivos estáticos
<a name="python-platform-staticfiles"></a>

Para mejorar el rendimiento, puede utilizar la sección **Static files** (Archivos estáticos) para configurar el servidor proxy para entregar archivos estáticos de servidor (por ejemplo, HTML o imágenes) desde un conjunto de directorios dentro de su aplicación web. Para cada directorio, se establece la ruta virtual para la asignación de directorios. Cuando el servidor proxy recibe una solicitud de un archivo en la ruta especificada, proporciona directamente el archivo en lugar de direccionar la solicitud la aplicación.

Para obtener más información sobre la configuración de archivos estáticos mediante archivos de configuración o la consola de Elastic Beanstalk, consulte [Distribución de archivos estáticos](environment-cfg-staticfiles.md).

De forma predeterminada, el servidor proxy en un entorno de Python proporciona los archivos en una carpeta llamada `static` situada en la ruta `/static`. Por ejemplo, si el código fuente de la aplicación contiene un archivo llamado `logo.png` en una carpeta denominada `static`, el servidor proxy lo proporciona a los usuarios en `subdomain.elasticbeanstalk.com/static/logo.png`. Puede configurar mapeos adicionales como se explica en esta sección.

### Propiedades del entorno
<a name="create-deploy-python-custom-container-envprop"></a>

Puede utilizar las propiedades del entorno para proporcionar información a la aplicación y configurar las variables de entorno. Por ejemplo, puede crear una propiedad de entorno llamada `CONNECTION_STRING` que especifique una cadena de conexión que la aplicación pueda usar para conectarse a la base de datos.

Dentro del entorno de Python que se ejecuta en Elastic Beanstalk, estos valores son accesibles a través del diccionario `os.environ` de Python. Para obtener más información, consulte [http://docs.python. org/library/os.html](http://docs.python.org/library/os.html).

Puede utilizar un código similar al siguiente para tener acceso a las claves y los parámetros:

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

Las propiedades de entorno también pueden proporcionar información a un marco de trabajo. Por ejemplo, puede crear una propiedad llamada `DJANGO_SETTINGS_MODULE` para configurar Django de forma que utilice un módulo de configuración específico. En función del entorno, el valor podría ser `development.settings`, `production.settings`, etc.

Para obtener más información, consulte [Configuración de las variables de entorno y otras opciones de software](environments-cfg-softwaresettings.md).

## Espacios de nombres de configuración de Python
<a name="python-namespaces"></a>

Puede usar un [archivo de configuración](ebextensions.md) para definir opciones de configuración y realizar otras tareas de configuración en las instancias durante las implementaciones. Las opciones de configuración pueden ser [específicas de la plataforma](command-options-specific.md) o aplicarse a [todas las plataformas](command-options-general.md) del servicio de Elastic Beanstalk en su conjunto. Las opciones de configuración se organizan en *espacios de nombres*.

La plataforma Python define opciones en los espacios de nombres `aws:elasticbeanstalk:environment:proxy`, `aws:elasticbeanstalk:environment:proxy:staticfiles` y `aws:elasticbeanstalk:container:python`.

El siguiente archivo de configuración de muestra especifica los valores de las opciones de configuración para crear una propiedad de entorno denominada `DJANGO_SETTINGS_MODULE`, elija el servidor proxy Apache, especifique dos opciones de archivos estáticos que asignan un directorio denominado `statichtml` a la ruta `/html` y un directorio denominado `staticimages` a la ruta `/images`, así como opciones de configuración adicionales del espacio de nombres `[aws:elasticbeanstalk:container:python](command-options-specific.md#command-options-python)`. Este espacio de nombres contiene opciones que permiten especificar la ubicación del script WSGI del código fuente y el número de subprocesos y procesos que se van a ejecutar en 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
```

**Notas**  
Si está utilizando una versión de la plataforma Python AMI de Amazon Linux (anterior a Amazon Linux 2), reemplace el valor `WSGIPath` por `ebdjango/wsgi.py`. El valor del ejemplo funciona con el servidor WSGI de Gunicorn, que no es compatible con las versiones de la plataforma de la AMI de Amazon Linux.
Además, estas versiones antiguas de la plataforma utilizan un espacio de nombres diferente para configurar archivos estáticos: `aws:elasticbeanstalk:container:python:staticfiles`. Tiene los mismos nombres de opción y semántica que el espacio de nombres de archivo estático estándar.

Los archivos de configuración también admiten varias claves para [modificar aún más el software en las instancias del entorno](customize-containers-ec2.md). En este ejemplo, se utiliza la clave [packages](customize-containers-ec2.md#linux-packages) para instalar Memcached con `yum` y [container commands](customize-containers-ec2.md#linux-container-commands) para ejecutar comandos que configuren el servidor durante la implementación:

```
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 cuenta con numerosas opciones de configuración para personalizar el entorno. Además de los archivos de configuración, también puede definir opciones en la consola, configuraciones guardadas, la CLI de EB o la AWS CLI. Para obtener más información, consulte [Opciones de configuración](command-options.md).

## El ejecutable de `python3`
<a name="python3-executable"></a>

La versión del `python3` ejecutable disponible en las EC2 instancias de los entornos Python de Elastic Beanstalk no siempre corresponderá a la misma versión de Python utilizada por la plataforma. Por ejemplo, en la plataforma Python 3.12 AL2 023, `/usr/bin/python3` apunta a Python 3.9. Esto se debe a que Python 3.9 es el *sistema Python* en AL2 023. Para obtener más información, consulte [Python en AL2 023](https://docs.aws.amazon.com/linux/al2023/ug/python.html) en la *Guía del usuario de Amazon Linux 2023*. Puede acceder a un ejecutable correspondiente a la versión de Python utilizada por la plataforma en una ubicación versionada (por ejemplo, `/usr/bin/python3.12`) o en el directorio de `bin` del entorno virtual de la aplicación (por ejemplo, `/var/app/venv/staging-LQM1lest/bin/python3`). La plataforma utiliza el ejecutable de Python correcto que corresponde a la ramificación de la plataforma. 

# Configuración del servidor WSGI con un archivo Procfile en Elastic Beanstalk
<a name="python-configuration-procfile"></a>

Puede añadir un [`Procfile`](platforms-linux-extend.build-proc.md#platforms-linux-extend.proc) a su paquete de código fuente para especificar y configurar el servidor WSGI de su aplicación. Puede especificar comandos de inicio y ejecución personalizados en `Procfile`.

Cuando se utiliza un `Procfile`, este anula las opciones de espacio de nombres de `aws:elasticbeanstalk:container:python` que se establecen mediante archivos de configuración.

En el ejemplo siguiente se utiliza `Procfile` para especificar uWSGI como servidor y configurarlo.

**Example Procfile**  

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

En el ejemplo siguiente se utiliza `Procfile` para configurar Gunicorn, el servidor WSGI predeterminado.

**Example Procfile**  

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

**Notas**  
Si configura cualquier servidor WSGI que no sea Gunicorn, asegúrese de especificarlo también como una dependencia de la aplicación, de modo que esté instalado en las instancias de su entorno. Para obtener más información sobre la especificación de dependencias, consulte [Especificación de dependencias mediante un archivo de requisitos en Elastic Beanstalk](python-configuration-requirements.md).
El puerto predeterminado para el servidor WSGI es 8000. Si especifica un número de puerto diferente en el comando `Procfile`, establezca también el `PORT` [propiedad del entorno](environments-cfg-softwaresettings.md) en este número de puerto.

# Especificación de dependencias mediante un archivo de requisitos en Elastic Beanstalk
<a name="python-configuration-requirements"></a>

En este tema se describe cómo configurar la aplicación para instalar otros paquetes de Python que necesite. Una aplicación de Python típica tiene dependencias de otros paquetes de Python de terceros. Con la plataforma Python de Elastic Beanstalk, tiene varias formas de especificar paquetes Python de los que depende su aplicación.

## Utilice `pip` y `requirements.txt`
<a name="python-configuration-requirements.txt"></a>

La herramienta estándar para instalar paquetes de Python es `pip`. Esta tiene una característica que permite especificar todos los paquetes necesarios (así como las versiones) en un único archivo de requisitos. Para obtener más información sobre el archivo de requisitos, consulte [Requirements File Format](https://pip.pypa.io/en/latest/reference/requirements-file-format/#requirements-file-format) en el sitio web de documentación de pip.

Cree un archivo llamado `requirements.txt` y sitúelo en el directorio principal del paquete de código fuente. A continuación se muestra un ejemplo del archivo `requirements.txt` para Django.

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

En el entorno de desarrollo, puede utilizar el comando `pip freeze` para generar el archivo de requisitos.

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

Para asegurarse de que el archivo de requisitos solo contiene los paquetes que se utilizan realmente en la aplicación, utilice un [entorno virtual](python-development-environment.md#python-common-setup-venv) que solo tenga instalado esos paquetes. Fuera del entorno virtual, la salida de `pip freeze` incluirá todos los paquetes de `pip` instalados en el equipo de desarrollo, incluidos aquellos que venían con el sistema operativo.

**nota**  
En las versiones de la plataforma Python AMI de Amazon Linux, Elastic Beanstalk no admite de forma nativa Pipenv o Pipfiles. Si utiliza Pipenv para administrar las dependencias de la aplicación, ejecute el siguiente comando para generar un archivo `requirements.txt`.  

```
~/my-app$ pipenv lock -r > requirements.txt
```
Para obtener más información, consulte [Generación de un requirements.txt](https://pipenv.readthedocs.io/en/latest/advanced/#generating-a-requirements-txt) en la documentación de Pipenv.

## Use Pipenv y `Pipfile`
<a name="python-configuration-requirements.pipenv"></a>

Pipenv es una herramienta de empaquetado de Python moderna. Combina la instalación de paquetes con la creación y administración de un archivo de dependencia y un virtualenv para su aplicación. Para obtener más información, consulte [Pipenv: Python Dev Workflow for Humans](https://pipenv.readthedocs.io/en/latest/).

Pipenv mantiene dos archivos: 
+ `Pipfile`: este archivo contiene varios tipos de dependencias y requisitos.
+ `Pipfile.lock`: este archivo contiene una instantánea de la versión que permite compilaciones deterministas.

Puede crear estos archivos en su entorno de desarrollo e incluirlos en el directorio de nivel superior del paquete de origen que se implementa en Elastic Beanstalk. Para obtener más información sobre estos dos archivos, visite [Example Pipfile and Pipfile.lock](https://pipenv.pypa.io/en/latest/basics/#).



El siguiente ejemplo utiliza Pipenv para instalar Django y el marco REST de Django. Estos comandos crean los archivos `Pipfile` y `Pipfile.lock`.

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

 

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

Si incluye más de uno de los archivos de requisitos descritos en este tema, Elastic Beanstalk utiliza solo uno de ellos. La siguiente lista muestra la prioridad, en orden descendente.

1. `requirements.txt`

1. `Pipfile.lock`

1. `Pipfile`

**nota**  
A partir de la versión de la plataforma Amazon Linux 2 del 7 de marzo de 2023, si proporciona más de uno de estos archivos, Elastic Beanstalk emitirá un mensaje en la consola donde se indicará cuál de los archivos de dependencia se utilizó durante la implementación.

En los siguientes pasos se describe la lógica que sigue Elastic Beanstalk para instalar las dependencias al implementar una instancia.
+ Si hay un archivo `requirements.txt`, utilizamos el comando `pip install -r requirements.txt`.
+ A partir del lanzamiento de la plataforma Amazon Linux 2 del 7 de marzo de 2023, si no hay ningún archivo `requirements.txt`, pero hay un `Pipfile.lock`, utilizamos el comando `pipenv sync`. Antes de ese lanzamiento, usábamos `pipenv install --ignore-pipfile`.
+ Si no hay ni un archivo `requirements.txt` ni un `Pipfile.lock`, pero hay un `Pipfile`, entonces usamos el comando `pipenv install --skip-lock`.
+ Si no se encuentra ninguno de los tres archivos de requisitos, no instalamos ninguna de las dependencias de la aplicación.

# Implementación de una aplicación Flask en Elastic Beanstalk
<a name="create-deploy-python-flask"></a>

Este tutorial explica el proceso de generación de una aplicación Flask e implementarla en un AWS Elastic Beanstalk entorno. Flask es un marco de aplicaciones web de código abierto para Python. 

En este tutorial, hará lo siguiente:
+ [Configuración de un entorno virtual Python con Flask](#python-flask-setup-venv)
+ [Creación de una aplicación Flask](#python-flask-create-app)
+ [Implementación del sitio con la CLI de EB](#python-flask-deploy) 
+ [Limpieza](#python-flask-tutorial-cleanup) 

## Requisitos previos
<a name="python-flask-prereq"></a>

Este tutorial asume que tiene conocimiento de las operaciones básicas de Elastic Beanstalk y de la consola de Elastic Beanstalk. Si aún no lo ha hecho, siga las instrucciones que se indican en [Cómo empezar a utilizar Elastic Beanstalk](GettingStarted.md) para lanzar su primer entorno de Elastic Beanstalk.

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema (\$1) y del nombre del directorio actual, si es aplicable.

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

En Linux y macOS, puede utilizar el administrador de shell y paquetes preferido. En Windows, puede [instalar Windows Subsystem para Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) para obtener una versión de Ubuntu y Bash integrada con Windows.

En este tutorial, utilizamos Python 3.11 y la versión de plataforma Elastic Beanstalk correspondiente. Instale Python; para ello, siga las instrucciones de [Configuración del entorno de desarrollo de Python para Elastic Beanstalk](python-development-environment.md).

La instalación del marco de [Flask](http://flask.pocoo.org/) forma parte del tutorial.

En este tutorial también se utiliza la interfaz de línea de comandos de Elastic Beanstalk (CLI de EB). Para obtener detalles sobre la instalación y configuración de la CLI de EB, consulte [Instalación de la CLI de EB con el script de configuración (recomendado)](eb-cli3.md#eb-cli3-install) y [Configuración de la CLI de EB](eb-cli3-configuration.md).

## Configuración de un entorno virtual Python con Flask
<a name="python-flask-setup-venv"></a>

Cree un directorio de proyecto y un entorno virtual para su aplicación e instale Flask.

**Para configurar el entorno del proyecto**

1. Cree el directorio del proyecto.

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

1. Cree y active un entorno virtual llamado `virt`:

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

   Verá `(virt)` delante del símbolo del sistema, lo que indica que se encuentra en un entorno virtual. Utilice el entorno virtual para el resto de este tutorial.

1. Instale Flask con `pip install`:

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

1. Consulte las bibliotecas instaladas con `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
   ```

   Este comando enumera todos los paquetes instalados en su entorno virtual. Debido a que se encuentra en un entorno virtual, no se muestran los paquetes instalados globalmente como la CLI de EB.

1. Guarde la salida de `pip freeze` en un archivo llamado `requirements.txt`.

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

   Este archivo indica a Elastic Beanstalk que instale las bibliotecas durante la implementación. Para obtener más información, consulte [Especificación de dependencias mediante un archivo de requisitos en Elastic Beanstalk](python-configuration-requirements.md).

## Creación de una aplicación Flask
<a name="python-flask-create-app"></a>

A continuación, vamos a crear una aplicación que implementará con Elastic Beanstalk. Crearemos un servicio web llamado «Hello World». RESTful 

En este directorio, cree un nuevo archivo de texto llamado `application.py` con el contenido siguiente:

**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()
```

En este ejemplo, se imprime un saludo personalizado que varía en función de la ruta utilizada para obtener acceso al servicio.

**nota**  
Si se agrega `application.debug = True` antes de ejecutar la aplicación, se habilitará la salida de depuración en caso de que se produzca algún error. Esta es una práctica recomendada cuando se realizan tareas de desarrollo. Sin embargo, las instrucciones de depuración deben eliminarse en el código de producción, ya que la salida de depuración puede desvelar aspectos internos de la aplicación.

Si utiliza `application.py` como nombre de archivo y proporciona un objeto `application` al que se pueda llamar (en este caso, el objeto Flask), Elastic Beanstalk podrá encontrar fácilmente el código de la aplicación.

Ejecute `application.py` con 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
```

Abra `http://127.0.0.1:5000/` en el navegador web. Debería aparecer la página de índice de la aplicación en ejecución:

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


Compruebe el registro del servidor para ver el resultado de la solicitud. Si desea detener el servidor web y volver al entorno virtual, escriba **Ctrl\$1C**.

Si aparece la salida de depuración, solucione los errores y asegúrese de que la aplicación está ejecutándose en local antes de configurarla para Elastic Beanstalk.

## Implementación del sitio con la CLI de EB
<a name="python-flask-deploy"></a>

Ha añadido todo lo que necesita para implementar su aplicación en Elastic Beanstalk. El directorio del proyecto debe ser similar al siguiente:

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

Sin embargo, la carpeta `virt`, no es obligatoria para que la aplicación se ejecute en Elastic Beanstalk. Al realizar la implementación, Elastic Beanstalk crea un nuevo entorno virtual en las instancias de servidor e instala las bibliotecas indicadas en `requirements.txt`. Para minimizar el tamaño del paquete de código fuente que cargue durante la implementación, agregue un archivo [.ebignore](eb-cli3-configuration.md#eb-cli3-ebignore) que le indique a la CLI de EB que omita la carpeta `virt`.

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

```
virt
```

A continuación, creará el entorno de la aplicación e implementará su aplicación configurada con Elastic Beanstalk.

**Para crear un entorno e implementar la aplicación de Flask**

1. Inicialice el repositorio de la CLI de EB con el comando **eb init**:

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

   Este comando crea una nueva aplicación llamada `flask-tutorial` y configura su repositorio local para crear entornos con la última versión de la plataforma Python 3.11.

1. (opcional) **eb init** Vuelve a ejecutarlo para configurar un par de claves predeterminado que te permita conectarte a la EC2 instancia que ejecuta tu aplicación mediante 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 ]
   ```

   Seleccione un par de claves si tiene uno o siga las instrucciones para crear una nuevo par de claves. Si no ve el símbolo del sistema o más adelante necesita cambiar la configuración, ejecute **eb init -i**.

1. Cree un entorno e implemente la aplicación en él con **eb create**:

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

El entorno tarda unos cinco minutos en crearse e incluye los recursos siguientes:
+ **EC2 instancia**: una máquina virtual de Amazon Elastic Compute Cloud (Amazon EC2) configurada para ejecutar aplicaciones web en la plataforma que elijas.

  Cada plataforma ejecuta un conjunto específico de software, archivos de configuración y scripts compatibles con una determinada versión de lenguaje, marco de trabajo y contenedor web (o una combinación de estos). La mayoría de las plataformas utilizan Apache o nginx como un proxy inverso que se sitúa delante de la aplicación web, reenvía las solicitudes a esta, administra los recursos estáticos y genera registros de acceso y errores.
+ **Grupo de seguridad de instancias**: un grupo EC2 de seguridad de Amazon configurado para permitir el tráfico entrante en el puerto 80. Este recurso permite que el tráfico HTTP del balanceador de cargas llegue a la EC2 instancia que ejecuta tu aplicación web. De forma predeterminada, el tráfico no está permitido en otros puertos.
+ **Balanceador de carga**: equilibrador de carga de Elastic Load Balancing configurado para distribuir solicitudes a las instancias que se ejecutan en la aplicación. Los balanceadores de carga también permiten que las instancias no estén expuestas directamente a Internet.
+ **Grupo de seguridad del balanceador de carga**: un grupo EC2 de seguridad de Amazon configurado para permitir el tráfico entrante en el puerto 80. Este recurso permite que el tráfico HTTP procedente de Internet llegue al equilibrador de carga. De forma predeterminada, el tráfico no está permitido en otros puertos.
+ **Grupo de escalado automático**: grupo de escalado automático configurado para reemplazar una instancia si termina o deja de estar disponible.
+ **Bucket de Amazon S3**: ubicación de almacenamiento para el código fuente, los registros y otros artefactos que se crean al utilizar Elastic Beanstalk.
+ ** CloudWatch Alarmas de Amazon**: dos CloudWatch alarmas que monitorean la carga de las instancias de su entorno y que se activan si la carga es demasiado alta o demasiado baja. Cuando se activa una alarma, en respuesta, el grupo de escalado automático aumenta o reduce los recursos.
+ **CloudFormation pila**: Elastic CloudFormation Beanstalk se utiliza para lanzar los recursos de su entorno y propagar los cambios de configuración. Los recursos se definen en una plantilla que puede verse en la [consola de CloudFormation](https://console.aws.amazon.com/cloudformation).
+ **Nombre de dominio***: un nombre de dominio que se dirige a su aplicación web en el formulario. *subdomain* *region*.elasticbeanstalk.com*.
**Seguridad de dominios**  
Para aumentar la seguridad de las aplicaciones de Elastic Beanstalk, el dominio *elasticbeanstalk.com* está registrado en la [lista de sufijos públicos (PSL)](https://publicsuffix.org/).  
Para mayor seguridad, se recomienda que utilice cookies con un prefijo `__Host-` en caso de que necesite configurar cookies confidenciales en el nombre de dominio predeterminado de sus aplicaciones de Elastic Beanstalk. Esta práctica le ayuda a proteger su dominio de los intentos de falsificación de solicitudes entre sitios (CSRF). Para más información, consulte la página [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) en la red de desarrolladores de Mozilla.

Todos estos recursos los administra Elastic Beanstalk. Cuando termina su entorno, Elastic Beanstalk termina todos los recursos que este contiene.

**nota**  
El bucket de Amazon S3 que Elastic Beanstalk crea se comparte entre los entornos y no se elimina durante la terminación del entorno. Para obtener más información, consulte [Uso de Elastic Beanstalk con Amazon S3](AWSHowTo.S3.md).

Cuando finalice el proceso de creación del entorno, abra el sitio web con **eb open**:

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

Se abrirá una ventana del navegador con el nombre de dominio creado para su aplicación. Debería ver el mismo sitio web de Flask que creó y probó en local.

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


Si no ve la aplicación en ejecución o aparece un mensaje de error, consulte [Solución de problemas de implementación](troubleshooting.md#troubleshooting-deployments) para intentar determinar la causa del error.

En caso de que *sí* vea la aplicación en ejecución (le felicitamos en ese caso), habrá implementado la primera aplicación de Flask con Elastic Beanstalk.

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

Cuando finalice su trabajo con el código de demostración, puede terminar el entorno. [Elastic Beanstalk elimina todos los recursos AWS relacionados, [como las instancias de EC2 Amazon](using-features.managing.ec2.md), las [instancias de bases de datos, los balanceadores de carga,](using-features.managing.db.md)[los grupos de seguridad y las](using-features.managing.elb.md) alarmas.](using-features.alarms.md#using-features.alarms.title) 

Al eliminar recursos no se elimina la aplicación de Elastic Beanstalk, por lo que puede crear nuevos entornos para su aplicación en cualquier momento.

**Cómo terminar su entorno de Elastic Beanstalk desde la consola**

1. Abra la consola de [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) y, **en** la lista Regiones, seleccione su. Región de AWS

1. En el panel de navegación, elija **Environments** (Entornos) y, a continuación, elija el nombre del entorno en la lista.

1. Elija **Actions** (Acciones) y, a continuación, **Terminate Environment** (Terminar el entorno).

1. Utilice el cuadro de diálogo en pantalla para confirmar la terminación del entorno.

O, con la CLI de EB:

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

## Siguientes pasos
<a name="python-flask-more-info"></a>

Para obtener más información acerca de Flask, visite [flask.pocoo.org](http://flask.pocoo.org/).

Si desea probar otra plataforma web de Python, consulte [Implementación de una aplicación Django en Elastic Beanstalk](create-deploy-python-django.md).

# Implementación de una aplicación Django en Elastic Beanstalk
<a name="create-deploy-python-django"></a>

En este tutorial se explica la implementación de un sitio web de [Django](https://www.djangoproject.com/) autogenerado y predeterminado en un entorno de AWS Elastic Beanstalk que ejecuta Python. En este tutorial se muestra cómo alojar una aplicación web de Python en la nube mediante un entorno de Elastic Beanstalk. 

En este tutorial, hará lo siguiente:
+ [Configuración de un entorno virtual de Python e instalación de Django](#python-django-setup-venv)
+ [Creación de un proyecto de Django](#python-django-create-app)
+ [Configure su aplicación Django para Elastic Beanstalk](#python-django-configure-for-eb) 
+ [Implementación del sitio con la CLI de EB](#python-django-deploy) 
+ [Actualización de la aplicación](#python-django-update-app) 
+ [Limpieza](#python-django-stopping)

## Requisitos previos
<a name="python-django-prereq"></a>

Para seguir este tutorial, debe tener todos los [requisitos previos comunes](python-development-environment.md) de Python instalados, incluidos los siguientes paquetes:
+ Python 3.7 o posterior
+ `pip`
+ `virtualenv`
+ `awsebcli`

La instalación de la plataforma [Django](https://www.djangoproject.com/) forma parte del tutorial.

**nota**  
Para crear entornos con la CLI de EB, se requiere un [rol de servicio](concepts-roles-service.md). Puede crear un rol de servicio creando un entorno en la consola de Elastic Beanstalk. Si no cuenta con ningún rol de servicio, el EB CLI intentará crear uno cuando ejecute `eb create`.

## Configuración de un entorno virtual de Python e instalación de Django
<a name="python-django-setup-venv"></a>

Cree un entorno virtual con `virtualenv` y utilícelo para instalar Django y sus dependencias. Al usar un entorno virtual, puede saber exactamente qué paquetes necesita su aplicación, de modo que los paquetes necesarios se instalen en las EC2 instancias de Amazon que ejecutan su aplicación. 

Los siguientes pasos muestran los comandos que debe especificar para sistemas basados en Unix y Windows, que aparecen en pestañas independientes.

**Para configurar el entorno virtual**

1. Cree un entorno virtual llamado `eb-virt`.

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

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

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

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

------

1. Active el entorno virtual.

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

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

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

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

------

   Verá `(eb-virt)` delante del símbolo del sistema, lo que indica que se encuentra en un entorno virtual.
**nota**  
En el resto de estas instrucciones se muestra el símbolo del sistema de Linux en el directorio principal `~$`. En Windows`C:\Users\USERNAME>`, aquí es donde *USERNAME* está su nombre de inicio de sesión de Windows.

1. Use `pip` para instalar Django.

   ```
   (eb-virt)~$ pip install django==2.2
   ```
**nota**  
La versión de Django que instale debe ser compatible con la versión de Python en la configuración de Elastic Beanstalk Python que elija para implementar su aplicación. Para obtener información sobre la implementación, consulte [Implementación del sitio con la CLI de EB](#python-django-deploy) en este tema.  
Para obtener más información sobre las versiones de plataforma de Python actuales, consulte [Python](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) en el documento *AWS Elastic Beanstalk Platforms*.  
Para obtener información sobre la compatibilidad de versiones de Django con Python, consulte [¿Qué versión de Python puedo utilizar con Django?](https://docs.djangoproject.com/en/3.1/faq/install/#what-python-version-can-i-use-with-django)

1. Para comprobar que Django está instalado, escriba lo siguiente.

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

   Este comando enumera todos los paquetes instalados en su entorno virtual. Más adelante utilizará el resultado de este comando para configurar su proyecto para usarlo con Elastic Beanstalk.

## Creación de un proyecto de Django
<a name="python-django-create-app"></a>

Ahora está preparado para crear un proyecto de Django y ejecutarlo en su equipo, utilizando el entorno virtual.

**nota**  
Este tutorial utiliza SQLite, que es un motor de base de datos incluido en Python. La base de datos se implementa con los archivos del proyecto. Para entornos de producción, se recomienda utilizar Amazon Relational Database Service (Amazon RDS) y separarlo del entorno. Para obtener más información, consulte [Adición de una instancia de base de datos de Amazon RDS a su entorno de Python de Elastic Beanstalk](create-deploy-python-rds.md).

**Para generar una aplicación de Django**

1. Active el entorno virtual.

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

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

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

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

------

   Verá el prefijo `(eb-virt)` delante del símbolo del sistema, lo que indica que se encuentra en un entorno virtual.
**nota**  
En el resto de estas instrucciones se muestra el símbolo del sistema de Linux `~$` en el directorio principal y el directorio principal de Linux `~/`. En Windows, estos son`C:\Users\USERNAME>`, dónde *USERNAME* está su nombre de inicio de sesión de Windows.

1. Utilice el comando `django-admin startproject` para crear un proyecto de Django llamado `ebdjango`.

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

   Este comando crea un sitio de Django estándar denominado **ebdjango** con la siguiente estructura de directorios.

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

1. Ejecute el sitio de Django localmente con `manage.py runserver`.

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

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

1. En un navegador web, abra `http://127.0.0.1:8000/` para ver el sitio.

1. Compruebe el registro del servidor para ver el resultado de la solicitud. Para detener el servidor web y volver al entorno virtual, presione **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
   ```

## Configure su aplicación Django para Elastic Beanstalk
<a name="python-django-configure-for-eb"></a>

Ahora que ya tiene un sitio de Django en su equipo local, puede configurarlo para implementarlo con Elastic Beanstalk.

De forma predeterminada, Elastic Beanstalk busca un archivo llamado `application.py` para iniciar la aplicación. Como este archivo no existe en el proyecto de Django que ha creado, tendrá que realizar algunos ajustes en el entorno de su aplicación. También deberá configurar las variables de entorno para que puedan cargarse los módulos de la aplicación.

**Para configurar su sitio para Elastic Beanstalk**

1. Active el entorno virtual.

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

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

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

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

------

1. Ejecute `pip freeze` y, a continuación, guarde la salida en un archivo llamado `requirements.txt`.

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

   Elastic `requirements.txt` Beanstalk utiliza para determinar qué paquete instalar EC2 en las instancias que ejecutan la aplicación.

1. Cree un directorio llamado `.ebextensions`.

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

1. En el directorio `.ebextensions`, añada un [archivo de configuración](ebextensions.md) llamado `django.config` con el siguiente texto.  
**Example \$1/ebdjango/.ebextensions/django.config**  

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

   Esta configuración, `WSGIPath`, especifica la ubicación del script de WSGI que utiliza Elastic Beanstalk para iniciar su aplicación.
**nota**  
Si está utilizando una versión de la plataforma Python AMI de Amazon Linux (anterior a Amazon Linux 2), reemplace el valor `WSGIPath` por `ebdjango/wsgi.py`. El valor del ejemplo funciona con el servidor WSGI de Gunicorn, que no es compatible con las versiones de la plataforma de la AMI de Amazon Linux.

1. Desactive el entorno virtual con el comando `deactivate`.

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

   Vuelva a activar su entorno virtual siempre que necesite añadir paquetes a su aplicación o ejecutar su aplicación localmente.

## Implementación del sitio con la CLI de EB
<a name="python-django-deploy"></a>

Ha añadido todo lo que necesita para implementar su aplicación en Elastic Beanstalk. El directorio del proyecto debe ser similar al siguiente.

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

A continuación, creará el entorno de la aplicación e implementará su aplicación configurada con Elastic Beanstalk.

Inmediatamente después de la implementación, editará la configuración de Django para agregar al ajuste de Elastic Beanstalk de Django el nombre de dominio que `ALLOWED_HOSTS` asignó a su aplicación. A continuación, volverá a implementar la aplicación. Se trata de un requisito de seguridad de Django, diseñado para impedir los ataques de encabezado de `Host` HTTP. Para obtener más información, consulte [Host header validation](https://docs.djangoproject.com/en/2.2/topics/security/#host-headers-virtual-hosting).

**Para crear un entorno e implementar la aplicación de Django**
**nota**  
El tutorial utiliza la CLI de EB como un mecanismo de implementación, pero también se puede utilizar la consola de Elastic Beanstalk para implementar un archivo ZIP que incluya el contenido del proyecto. 

1. Inicialice el repositorio de la CLI de EB con el comando **eb init**.

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

   Este comando crea una aplicación llamada `django-tutorial`. También configura su repositorio local para crear entornos con la última versión de la plataforma Python 3.7.

1. (Opcional) **eb init** Vuelve a ejecutarlo para configurar un key pair predeterminado de forma que puedas usar SSH para conectarte a la EC2 instancia que ejecuta tu aplicación.

   ```
   ~/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 ]
   ```

   Seleccione un par de claves si ya tiene uno o siga las instrucciones para crear uno. Si no ve el símbolo del sistema o más adelante necesita cambiar la configuración, ejecute **eb init -i**.

1. Cree un entorno e implemente la aplicación en él con **eb create**.

   ```
   ~/ebdjango$ eb create django-env
   ```
**nota**  
Si recibe un mensaje de error “service role required” (es necesario el rol de servicio), ejecute `eb create` interactivamente (sin especificar un nombre de entorno) y la CLI de EB creará el rol.

   Este comando crea un entorno de Elastic Beanstalk con equilibrio de carga denominado `django-env`. Se tarda alrededor de cinco minutos en crear el entorno. A medida que Elastic Beanstalk crea los recursos necesarios para ejecutar la aplicación, envía mensajes informativos que la CLI de EB transmite a su terminal.

1. Cuando finalice el proceso de creación del entorno, busque el nombre de dominio de su nuevo entorno. Para ello, ejecute **eb status**.

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

   El nombre de dominio del entorno es el valor de la propiedad `CNAME`.

1. Abra el archivo `settings.py` en el directorio `ebdjango`. Localice el ajuste `ALLOWED_HOSTS` y, a continuación, agregue el nombre de dominio de la aplicación que encontró en el paso anterior al valor del ajuste. Si no encuentra este ajuste en el archivo, agréguelo en una línea nueva.

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

1. Guarde el archivo y, a continuación, vuelva a implementar la aplicación. Para ello, ejecute **eb deploy**. Cuando ejecuta **eb deploy**, la CLI de EB empaqueta el contenido del directorio del proyecto y lo implementa en su entorno.

   ```
   ~/ebdjango$ eb deploy
   ```
**nota**  
Si utiliza Git con el proyecto, consulte [Uso de la CLI de EB con Git](eb3-cli-git.md).

1. Cuando finalice el proceso de actualización del entorno, abra el sitio web con **eb open**.

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

   Se abre una ventana del navegador con el nombre de dominio creado para su aplicación. Debería ver el mismo sitio web de Django que creó y probó localmente.

Si no ve la aplicación en ejecución o aparece un mensaje de error, consulte [Solución de problemas de implementación](troubleshooting.md#troubleshooting-deployments) para intentar determinar la causa del error.

En caso de que *sí* vea la aplicación en ejecución (le felicitamos en ese caso), habrá implementado la primera aplicación de Django con Elastic Beanstalk.

## Actualización de la aplicación
<a name="python-django-update-app"></a>

Ahora que tiene una aplicación en ejecución en Elastic Beanstalk, puede actualizar y volver a implementar su aplicación o su configuración; Elastic Beanstalk se encargará de la tarea de actualizar sus instancias e iniciar la nueva versión de la aplicación.

Para este ejemplo, vamos a habilitar la consola de administración de Django y configurar otros ajustes.

### Modificación de la configuración del sitio
<a name="python-django-modify-site"></a>

De forma predeterminada, el sitio web de Django utiliza la zona horaria UTC para mostrar el tiempo. Puede cambiar esta configuración especificando una zona horaria en `settings.py`.

**Para cambiar la zona horaria del sitio**

1. Modifique el valor de `TIME_ZONE` en `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
   ```

   Para obtener una lista de zonas horarias, visite [esta página](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones).

1. Implemente la aplicación en su entorno Elastic Beanstalk.

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

### Creación de un administrador del sitio
<a name="python-django-create-admin"></a>

Puede crear un administrador del sitio para su aplicación de Django que tenga acceso a la consola de administración directamente desde el sitio web. Los detalles de inicio de sesión del administrador se almacenan de forma segura en la imagen de la base de datos local incluida en el proyecto predeterminado que genera Django.

**Para crear un administrador del sitio**

1. Inicialice la base de datos local de la aplicación de 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. Ejecute `manage.py createsuperuser` para crear un administrador.

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

1. Para indicar a Django dónde debe almacenar los archivos estáticos, defina `STATIC_ROOT` en `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. Ejecútelo `manage.py collectstatic` para rellenar el `static` directorio con activos estáticos (JavaScriptCSS e imágenes) para el sitio de administración.

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

1. Implementa la aplicación.

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

1. Consulte la consola de administración abriendo el sitio en el navegador y añadiendo `/admin/` a la dirección URL del sitio, como la siguiente.

   ```
   http://djang-env.p33kq46sfh.us-west-2.elasticbeanstalk.com/admin/
   ```  
![\[Escriba el nombre de usuario y la contraseña que creó en el paso 2 para iniciar sesión en la consola de administración.\]](http://docs.aws.amazon.com/es_es/elasticbeanstalk/latest/dg/images/eb_django_admin_login.png)

1. Inicie sesión con el nombre de usuario y la contraseña que ha configurado en el paso 2.  
![\[La consola de administración de Django para su sitio web de Django implementa con Elastic Beanstalk\]](http://docs.aws.amazon.com/es_es/elasticbeanstalk/latest/dg/images/eb_django_admin_console.png)

Puede utilizar un procedimiento similar al local updating/testing seguido **eb deploy** de. Elastic Beanstalk se encarga de la tarea de actualizar los servidores en directo, para que usted pueda centrarse en el desarrollo de la aplicación en lugar de en la administración del servidor.

### Añadir un archivo de configuración de migración de la base de datos
<a name="python-django-migrate-site"></a>

Puede añadir comandos a su script `.ebextensions` que se ejecuten cuando se actualice el sitio. Esto le permite generar automáticamente migraciones de base de datos.

**Para añadir un paso de migración cuando se implemente su aplicación**

1. Cree un [archivo de configuración](ebextensions.md) denominado `db-migrate.config` con el contenido siguiente.  
**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
   ```

   Este archivo de configuración activa el entorno virtual del servidor y ejecuta el comando `manage.py migrate` durante el proceso de implementación, antes de iniciar la aplicación. Como se ejecuta antes de iniciar la aplicación, deberá configurar la variable de entorno `DJANGO_SETTINGS_MODULE` explícitamente (normalmente `wsgi.py` se encarga de todo esto por usted durante el inicio). La especificación de `leader_only: true` en el comando garantiza que se ejecute solo una vez cuando realice la implementación en varias instancias.

1. Implementa la aplicación.

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

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

Para ahorrar horas de instancia y otros AWS recursos entre las sesiones de desarrollo, finalice su entorno de Elastic Beanstalk con. **eb terminate**

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

Este comando finaliza el entorno y todos los AWS recursos que se ejecutan en él. No elimina la aplicación. Al contrario, podrá crear más entornos con la misma configuración siempre que quiera ejecutando de nuevo **eb create**.

Si ha terminado de trabajar con la aplicación de muestra, puede eliminar también la carpeta del proyecto y el entorno virtual.

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

## Siguientes pasos
<a name="python-django-next-steps"></a>

Para obtener más información sobre Django, como un tutorial detallado, consulte [la documentación oficial](https://docs.djangoproject.com/en/2.2/).

Si desea probar otra plataforma web de Python, consulte [Implementación de una aplicación Flask en Elastic Beanstalk](create-deploy-python-flask.md).

# Adición de una instancia de base de datos de Amazon RDS a su entorno de Python de Elastic Beanstalk
<a name="create-deploy-python-rds"></a>

En este tema se proporcionan instrucciones para crear un Amazon RDS mediante la consola de Elastic Beanstalk. Puede utilizar una instancia de base de datos de Amazon Relational Database Service (Amazon RDS) para almacenar datos recopilados y modificados por su aplicación. La base de datos se puede adjuntar al entorno y administrarse con Elastic Beanstalk, o bien, crearse como desacoplada y administrarse de forma externa a través de otro servicio. En estas instrucciones, la base de datos se acoplará al entorno y se administrará con Elastic Beanstalk. Para obtener más información sobre el uso de Elastic Beanstalk con Amazon RDS, consulte [Añadir una base de datos al entorno de Elastic Beanstalk](using-features.managing.db.md).

**Topics**
+ [Añadir una instancia de base de datos al entorno](#python-rds-create)
+ [Descargar un controlador](#python-rds-drivers)
+ [Conexión a una base de datos](#python-rds-connect)

## Añadir una instancia de base de datos al entorno
<a name="python-rds-create"></a>

**Para agregar una instancia de base de datos al entorno**

1. Abra la consola de [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) y, **en** la lista Regiones, seleccione su. Región de AWS

1. En el panel de navegación, elija **Environments** (Entornos) y, a continuación, elija el nombre del entorno en la lista.

1. En el panel de navegación, elija **Configuration (Configuración)**.

1. En la categoría de configuración **Database (Base de datos)**, seleccione **Edit (Edición de)**.

1. Seleccione un motor de base de datos y escriba el nombre de usuario y la contraseña.

1. Para guardar los cambios, elija **Aplicar** en la parte inferior de la página.

Se tarda alrededor de 10 minutos en añadir una instancia de base de datos. Cuando se haya completado la actualización del entorno, el nombre de host de la instancia de base de datos y otra información de conexión estarán disponibles para su aplicación mediante las siguientes propiedades de entorno


| Nombre de la propiedad | Descripción | Valor de la propiedad | 
| --- | --- | --- | 
|  `RDS_HOSTNAME`  |  El nombre de host de la instancia de base de datos.  |  En la pestaña **Connectivity & security (Conectividad y seguridad)** de la consola de Amazon RDS: **Endpoint (Punto de conexión)**.  | 
|  `RDS_PORT`  |  El puerto en donde la instancia de base de datos acepta las conexiones. El valor predeterminado varía dependiendo del motor de base de datos.  |  En la pestaña **Connectivity & security (Conectividad y seguridad)** de la consola de Amazon RDS: **Port (Puerto)**.  | 
|  `RDS_DB_NAME`  |  El nombre de la base de dato, **ebdb**.  |  En la pestaña **Configuration (Configuración)** de la consola de Amazon RDS: **DB Name (Nombre de la base de datos)**.  | 
|  `RDS_USERNAME`  |  El nombre de usuario que ha configurado para la base de datos.  |  En la pestaña **Configuration (Configuración)** de la consola de Amazon RDS: **Master username (Nombre de usuario maestro)**.  | 
|  `RDS_PASSWORD`  |  La contraseña que ha configurado para la base de datos.  |  No está disponible como referencia en la consola de Amazon RDS.  | 

Para obtener más información sobre la configuración de una instancia de bases de datos acopladas a un entorno de Elastic Beanstalk, consulte [Añadir una base de datos al entorno de Elastic Beanstalk](using-features.managing.db.md).

## Descargar un controlador
<a name="python-rds-drivers"></a>

Añada el controlador de base de datos al [archivo de requisitos](python-configuration-requirements.md) de su proyecto.

**Example requirements.txt: Django con MySQL**  

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

**Paquetes de controladores comunes para Python**
+ **MySQL** – `mysqlclient`
+ **PostgreSQL** – `psycopg2`
+ **Oracle**: `cx_Oracle`
+ **SQL Server** – `adodbapi`

Para obtener más información, consulte [Python DatabaseInterfaces](https://wiki.python.org/moin/DatabaseInterfaces) y [Django 2.2: bases de datos compatibles](https://docs.djangoproject.com/en/2.2/ref/databases).

## Conexión a una base de datos
<a name="python-rds-connect"></a>

Elastic Beanstalk proporciona información de conexión para instancias de base de datos asociadas en propiedades de entorno. Use `os.environ['VARIABLE']` para leer las propiedades y configurar una conexión con la base de datos.

**Example Archivo de configuración de Django: DATABASES Dictionary**  

```
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'],
        }
    }
```

# Herramientas y recursos de Python
<a name="create-deploy-python-tools-resources"></a>

Existen varios lugares a los que puede acudir para obtener ayuda adicional con el desarrollo de sus aplicaciones Python:


****  

| Recurso | Description (Descripción) | 
| --- | --- | 
| [AWS SDK para Python (Boto3) en GitHub](https://github.com/boto/boto3) | Instale Boto3 procedente de. GitHub | 
| [AWS SDK para Python (Boto3) página de inicio](https://aws.amazon.com//sdk-for-python/) | La AWS SDK para Python (Boto3) página de inicio. | 
| [Centro para desarrolladores de Python](https://aws.amazon.com/python/) | Un único lugar para obtener código de ejemplo, documentación, herramientas y recursos adicionales. |