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 Java con Elastic Beanstalk
<a name="create_deploy_Java"></a>

En este capítulo se proporcionan instrucciones para configurar e implementar sus aplicaciones Java en. AWS Elastic Beanstalk Elastic Beanstalk facilita la implementación, administración y escalado de sus aplicaciones web Java con 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 las step-by-step instrucciones [QuickStart para Java](java-quickstart.md) para crear e implementar una aplicación web Java de *Hello World* con la CLI de EB. Si está interesado en step-by-step obtener instrucciones para crear una aplicación Java JSP sencilla de *Hello World* para implementarla con la CLI de EB en nuestra plataforma basada en Tomcat, pruebe la. [QuickStart para Java en Tomcat](tomcat-quickstart.md)

**Ramificaciones de la plataforma Java**  
AWS Elastic Beanstalk admite dos plataformas para aplicaciones Java.
+ **Tomcat**: plataforma basada en *Apache Tomcat*, un contenedor web de código abierto para aplicaciones que utilizan servlets de Java y JavaServer Pages (JSPs) para atender solicitudes HTTP. Tomcat facilita el desarrollo de aplicaciones web proporcionando varios subprocesos, configuración de seguridad declarativa y amplia capacidad de personalización. Elastic Beanstalk tiene ramas de plataforma para cada una de las versiones principales actuales de Tomcat. Para obtener más información, consulte [La plataforma Tomcat](java-tomcat-platform.md).
+ **Java SE**: plataforma para aplicaciones que no utilizan un contenedor web o utilizan otro que no sea Tomcat, como Jetty o. GlassFish Puede incluir cualquier biblioteca de Archivos Java (JARs) que utilice la aplicación en el paquete de código fuente que implemente en Elastic Beanstalk. Para obtener más información, consulte [La plataforma Java SE](java-se-platform.md).

Las ramas recientes de las plataformas Tomcat y Java SE se basan en Amazon Linux 2 y versiones posteriores, y utilizan *Corretto*, la distribución de Java AWS SE. Los nombres de estas ramificaciones de la plataforma incluyen la palabra *Corretto* en lugar de* Java*.

Para obtener una lista de las versiones actuales de la plataforma, consulte [Tomcat](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.java) y [Java SE](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.javase) en la guía *AWS Elastic Beanstalk Platforms*.

**AWS herramientas**  
AWS proporciona varias herramientas para trabajar con Java y Elastic Beanstalk. Independientemente de la rama de plataforma que elija, puede usar el [AWS SDK para Java para](java-development-environment.md#java-development-environment-sdk) usar otros AWS servicios desde su aplicación Java. El AWS SDK para Java es un conjunto de bibliotecas que le permiten utilizar el código AWS APIs de su aplicación sin tener que escribir las llamadas HTTP sin procesar desde cero.

Si prefiere administrar sus aplicaciones desde la línea de comandos, instale la [interfaz de línea de comandos de Elastic Beanstalk](eb-cli3.md) (CLI de EB) y úsela para crear, supervisar y administrar sus entornos de Elastic Beanstalk. Si ejecuta varios entornos para su aplicación, la CLI de EB se integra con Git para que pueda asociar cada uno de los entornos con una ramificación de Git diferente.

**Topics**
+ [

# QuickStart: Implementar una aplicación Java en Elastic Beanstalk
](java-quickstart.md)
+ [

# QuickStart: Implemente una aplicación web Java JSP para Tomcat en Elastic Beanstalk
](tomcat-quickstart.md)
+ [

# Configuración del entorno de desarrollo de Java
](java-development-environment.md)
+ [

# Más ejemplos de tutoriales y aplicaciones de Elastic Beanstalk para Java
](java-getstarted.md)
+ [

# Uso de la plataforma Tomcat de Elastic Beanstalk
](java-tomcat-platform.md)
+ [

# Uso de la plataforma Java SE de Elastic Beanstalk
](java-se-platform.md)
+ [

# Adición de una instancia de base de datos de Amazon RDS a su entorno de Java Elastic Beanstalk
](java-rds.md)
+ [

# Herramientas y recursos de Java
](create_deploy_Java.resources.md)

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

Este QuickStart tutorial explica el proceso de creación de una aplicación Java e implementarla 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
](#java-quickstart-aws-account)
+ [

## Requisitos previos
](#java-quickstart-prereq)
+ [

## Paso 1: crear una aplicación Java
](#java-quickstart-create-app)
+ [

## Paso 2: ejecutar la aplicación a nivel local
](#java-quickstart-run-local)
+ [

## Paso 3: implementar la aplicación Java con la CLI de EB
](#java-quickstart-deploy)
+ [

## Paso 4: ejecutar la aplicación en Elastic Beanstalk
](#java-quickstart-run-eb-ap)
+ [

## Paso 5: Eliminar
](#java-tutorial-cleanup)
+ [

## AWS recursos para su aplicación
](#java-quickstart-eb-resources)
+ [

## Siguientes pasos
](#java-quickstart-next-steps)
+ [

## Implementar con la consola de Elastic Beanstalk
](#java-quickstart-console)

## Tu AWS cuenta
<a name="java-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](#java-quickstart-prereq)

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

#### Inscríbase para obtener 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 inscribirte en 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="java-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="java-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).

### Java y Maven
<a name="java-quickstart-prereq.runtime"></a>

Si no tiene Amazon Corretto instalado en su máquina local, puede instalarlo según las [instrucciones de instalación](https://docs.aws.amazon.com/corretto/latest/corretto-21-ug/amazon-linux-install.html) de la *Guía del usuario de Amazon Corretto*.

Verifique la instalación de Java con el siguiente comando.

```
~$ java -version 
```

En este tutorial se utiliza Maven. Siga las instrucciones de [descarga](https://maven.apache.org/download.cgi) e [instalación](https://maven.apache.org/install.html) del sitio web del proyecto Apache Maven. Para obtener más información sobre Maven, consulte el [Centro de usuarios de Maven](https://maven.apache.org/users/index.html) en el sitio web del Proyecto Apache Maven:

Verifique la instalación de Maven con el siguiente comando.

```
~$ mvn -v
```

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

Cree el directorio del proyecto.

```
~$ mkdir eb-java
~$ cd eb-java
```

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

En este ejemplo se utiliza el marco [Spring Boot](https://spring.io/projects/spring-boot). Esta aplicación abre un oyente en el puerto 5000. De forma predeterminada, Elastic Beanstalk configura el proxy para reenviar las solicitudes a la aplicación en el puerto 5000.

Cree los siguientes archivos:

Este archivo crea una aplicación Spring Boot sencilla.

**Example `~/eb-java/src/main/java/com/example/Application.java`**  

```
package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
```

Este archivo crea un mapeo que devuelve una cadena que definimos aquí.

**Example `~/eb-java/src/main/java/com/example/Controller.java`**  

```
package com.example;
    
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
    
@RestController
public class Controller {
    
    @GetMapping("/")
    public String index() {
       return "Hello Elastic Beanstalk!";
    }
}
```

Este archivo define la configuración del proyecto Maven.

**Example `~/eb-java/pom.xml`**  

```
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.3</version>
  </parent>

  <groupId>com.example</groupId>
  <artifactId>BeanstalkJavaExample</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <java.version>21</java.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-rest</artifactId>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

</project>
```

Este archivo de propiedades anula el puerto predeterminado para que sea 5000. Este es el puerto predeterminado al que Elastic Beanstalk envía el tráfico para las aplicaciones Java.

**Example `~/eb-java/application.properties`**  

```
server.port=5000
```

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

Empaquete la aplicación con el siguiente comando:

```
~/eb-java$ mvn clean package
```

Ejecute su aplicación a nivel local con el siguiente comando:

```
~/eb-java$ java -jar target/BeanstalkJavaExample-1.0-SNAPSHOT.jar
```

Mientras la aplicación está en ejecución, vaya a `http://127.0.0.1:5000/` en su navegador. Debería ver el texto “Hola, Elastic Beanstalk”.

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

Antes de implementar la aplicación Java en Elastic Beanstalk, limpiaremos la aplicación de compilación del directorio y creemos un [Buildfile](java-se-buildfile.md) y un [Procfile](java-se-procfile.md) para controlar cómo se crea y ejecuta la aplicación en el entorno de Elastic Beanstalk.

**Cómo preparar y configurar una aplicación para su implementación.**

1. Limpie la aplicación creada.

   ```
   ~/eb-java$ mvn clean
   ```

1. Cree su `Buildfile`.  
**Example `~/eb-java/Buildfile`**  

   ```
   build: mvn clean package
   ```

   `Buildfile` especifica el comando utilizado para compilar la aplicación. Si no incluye `Buildfile` para una aplicación Java, Elastic Beanstalk no intentará compilar la aplicación.

1. Cree su `Procfile`.  
**Example `~/eb-java/Procfile`**  

   ```
   web: java -jar target/BeanstalkJavaExample-1.0-SNAPSHOT.jar
   ```

   `Procfile` especifica el comando utilizado para ejecutar la aplicación. Si no incluye `Procfile` para una aplicación Java, Elastic Beanstalk asume que hay un archivo JAR en la raíz del paquete de código fuente e intenta ejecutarlo con el comando `java -jar`.

 Ahora que ha configurado los archivos de configuración para compilar e iniciar la aplicación, está listo para implementarla. 

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

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

   ```
   ~/eb-java eb init -p corretto java-tutorial --region us-east-2
           
   Application java-tutorial has been created.
   ```

   Este comando crea una aplicación llamada `java-tutorial` y configura el repositorio local para crear entornos con la última versión de la plataforma de Java.

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-java$ 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-java$ eb create java-env
   ```

   Elastic Beanstalk tarda aproximadamente cinco minutos en crear el entorno.

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

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

```
~/eb-java eb open
```

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

## Paso 5: Eliminar
<a name="java-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-java$ eb terminate
```

## AWS recursos para su aplicación
<a name="java-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="java-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 ejemplo, consulte [Ejemplos de tutoriales y aplicaciones](java-getstarted.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 Java de forma local, consulte [Configuración del entorno de desarrollo de Java](java-development-environment.md). 

## Implementar con la consola de Elastic Beanstalk
<a name="java-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.

# QuickStart: Implemente una aplicación web Java JSP para Tomcat en Elastic Beanstalk
<a name="tomcat-quickstart"></a>

Este tutorial explica el proceso de creación de una aplicación web Java sencilla mediante JavaServer Pages ()JSPs. Si desea agrupar varias aplicaciones web en forma de archivos WAR en un único entorno de Elastic Beanstalk, consulte [Agrupación de varios archivos WAR en entornos Tomcat](java-tomcat-multiple-war-files.md).

**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
](#tomcat-quickstart-aws-account)
+ [

## Requisitos previos
](#tomcat-quickstart-prereq)
+ [

## Paso 1: crear una aplicación Java JSP
](#tomcat-quickstart-create-app)
+ [

## Paso 2: implementar la aplicación Java JSP con la CLI de EB
](#tomcat-quickstart-deploy)
+ [

## Paso 3: ejecutar la aplicación en Elastic Beanstalk
](#tomcat-quickstart-run-eb-ap)
+ [

## Paso 4: Limpiar
](#go-tutorial-cleanup)
+ [

## AWS recursos para su aplicación
](#tomcat-quickstart-eb-resources)
+ [

## Siguientes pasos
](#tomcat-quickstart-next-steps)
+ [

## Implementar con la consola de Elastic Beanstalk
](#tomcat-quickstart-console)

## ¿Tu AWS cuenta
<a name="tomcat-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](#tomcat-quickstart-prereq)

### Crea una AWS cuenta
<a name="tomcat-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 suscribirte 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="tomcat-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="tomcat-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).

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

Cree el directorio del proyecto.

```
~$ mkdir eb-tomcat
~$ cd eb-tomcat
```

A continuación, vamos a crear una aplicación que implementará con Elastic Beanstalk. Creación deemos una aplicación web “Hello World”.

Cree un archivo JSP simple llamado `index.jsp`.

**Example `~/eb-tomcat/index.jsp`**  

```
<html>
  <body>
    <%out.println("Hello Elastic Beanstalk!");%>
  </body>
</html>
```

## Paso 2: implementar la aplicación Java JSP con la CLI de EB
<a name="tomcat-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 de Java JSP**

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

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

   Este comando crea una aplicación llamada `tomcat-tutorial` y configura el repositorio local para crear entornos con la última versión de la plataforma de Tomcat.

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-go$ 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-tomcat$ eb create tomcat-env
   ```

   Elastic Beanstalk tarda aproximadamente cinco minutos en crear el entorno.

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

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

```
~/eb-tomcat$ eb open
```

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

## Paso 4: Limpiar
<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-tomcat$ eb terminate
```

## AWS recursos para su aplicación
<a name="tomcat-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="tomcat-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 ejemplo, consulte [Ejemplos de tutoriales y aplicaciones](java-getstarted.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 Java en un contenedor web de Tomcat local, consulte [Configuración del entorno de desarrollo de Java](java-development-environment.md). 

## Implementar con la consola de Elastic Beanstalk
<a name="tomcat-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 Java
<a name="java-development-environment"></a>

Este tema proporciona instrucciones para configurar el entorno de desarrollo de Java 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.

**Topics**
+ [

## Instalación del kit de desarrollo de Java
](#java-development-environment-jdk)
+ [

## Instalación de un contenedor web
](#java-development-environment-tomcat)
+ [

## Descarga de bibliotecas
](#java-development-environment-libraries)
+ [

## Instalación del AWS SDK para Java
](#java-development-environment-sdk)
+ [

## Instalación de un IDE o un editor de texto
](#java-development-environment-ide)

## Instalación del kit de desarrollo de Java
<a name="java-development-environment-jdk"></a>

Instale el kit de desarrollo de Java (JDK). Si no tiene ninguna preferencia, obtenga la versión más reciente. Descargue JDK en [oracle.com](http://www.oracle.com/technetwork/java/javase/downloads/index.html) 

JDK incluye el compilador de Java, que se puede utilizar para crear archivos de origen en los archivos de clases que se pueden ejecutar en un servidor web de Elastic Beanstalk.

## Instalación de un contenedor web
<a name="java-development-environment-tomcat"></a>

Si aún no tiene otro marco o contenedor web, instale una versión de Tomcat compatible con Elastic Beanstalk para su sistema operativo Amazon Linux. Para obtener una lista de las versiones actuales de Apache Tomcat compatibles con Elastic Beanstalk, consulte [Tomcat](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.java) en el documento *Plataformas de AWS Elastic Beanstalk *. Descargue la versión de Tomcat que se aplique a su entorno desde el sitio web de [Apache Tomcat](http://tomcat.apache.org). 

## Descarga de bibliotecas
<a name="java-development-environment-libraries"></a>

Las plataformas Elastic Beanstalk contienen algunas bibliotecas de forma predeterminada. Descargue las bibliotecas que la aplicación va a utilizar y guárdelas en la carpeta de proyecto para implementar el paquete de código fuente de la aplicación.

Si ha instalado Tomcat localmente, puede copiar la API de servlets y las bibliotecas de API de JavaServer Pages (JSP) de la carpeta de instalación. Si la implementación se realiza con una versión de plataforma de Tomcat, no tiene que incluir estos archivos en el paquete de código fuente, aunque deben estar en `classpath` para poder compilar las clases que los utilizan.

JUnit, Google Guava y Apache Commons proporcionan varias bibliotecas útiles. Visite sus páginas de inicio para obtener más información:
+  [Download JUnit](https://github.com/junit-team/junit/wiki/Download-and-Install) 
+  [Download Google Guava](https://code.google.com/p/guava-libraries/) 
+  [Download Apache Commons](http://commons.apache.org/downloads/) 

## Instalación del AWS SDK para Java
<a name="java-development-environment-sdk"></a>

Si necesita administrar AWS los recursos desde la aplicación, instale el AWS SDK for Java. Por ejemplo, con el AWS SDK para Java, puede utilizar Amazon DynamoDB (DynamoDB) para compartir los estados de sesión de las aplicaciones de Apache Tomcat en varios servidores web. Para obtener más información, consulte [Administrar el estado de la sesión de Tomcat con Amazon](https://docs.aws.amazon.com/AWSSdkDocsJava/latest/DeveloperGuide/java-dg-tomcat-session-manager.html) DynamoDB en la documentación del SDK AWS for Java.

Visite la [página de inicio del SDK de AWS para Java](https://aws.amazon.com/sdk-for-java/) si desea obtener más información e instrucciones de instalación.

## Instalación de un IDE o un editor de texto
<a name="java-development-environment-ide"></a>

Los entornos de desarrollo integrados (IDEs) proporcionan una amplia gama de funciones que facilitan el desarrollo de aplicaciones. Si no ha utilizado un IDE para el desarrollo de Java, pruebe Eclipse e IntelliJ y determine cuál es el que mejor se adapta a sus necesidades.
+  [Instalar Eclipse IDE for Java EE Developers](https://www.eclipse.org/downloads/) 
+  [Instalar IntelliJ](https://www.jetbrains.com/idea/) 

Un IDE podría agregar archivos a la carpeta de proyectos que tal vez no quiera confirmar en el control de código fuente. Para evitar confirmar estos archivos en el control de código fuente, utilice `.gitignore` o la característica equivalente de la herramienta de control de código fuente.

Si simplemente quiere comenzar a escribir el código y no necesita todas las características de un IDE, considere la posibilidad de [instalar Sublime Text](http://www.sublimetext.com/).

**nota**  
El 31 de mayo de 2023, el [AWS Toolkit for Eclipse](https://docs.aws.amazon.com//toolkit-for-eclipse/v1/user-guide/welcome.html) llegó al final de su vida útil y ya no es compatible con AWS. Para obtener más información sobre el final del ciclo de vida del AWS Toolkit for Eclipse, consulte el archivo [README.md](https://github.com/aws/aws-toolkit-eclipse) del repositorio. AWS Toolkit for Eclipse GitHub 

# Más ejemplos de tutoriales y aplicaciones de Elastic Beanstalk para Java
<a name="java-getstarted"></a>

En esta sección se proporcionan más aplicaciones y tutoriales. En los temas [QuickStart para Java en Tomcat](tomcat-quickstart.md) y [QuickStart para Java](java-quickstart.md) descritos anteriormente, se explica cómo lanzar un aplicación de muestra Java con la CLI de EB.

Para empezar a utilizar las aplicaciones Java AWS Elastic Beanstalk, lo único que necesita es un [paquete de código fuente](applications-sourcebundle.md) de la aplicación para cargarlo como primera versión de la aplicación e implementarlo en un entorno. Cuando crea un entorno, Elastic Beanstalk asigna todos los recursos de AWS necesarios para ejecutar una aplicación web escalable.

## Lanzar un entorno con una aplicación Java de ejemplo
<a name="java-getstarted-samples"></a>

Elastic Beanstalk proporciona aplicaciones de muestra de una sola página para cada plataforma, así como ejemplos más complejos que muestran el uso de recursos AWS adicionales, como Amazon RDS y características específicas de cada idioma o plataforma y. APIs

Los ejemplos de una sola página muestran el mismo código que obtiene cuando crea un entorno sin proporcionar su propio código fuente. Los ejemplos más complejos se alojan en un entorno de Elastic Beanstalk GitHub y es posible que deban compilarse o crearse antes de implementarlos en un entorno de Elastic Beanstalk.

 


**Muestras**  

|  Name  |  Versiones compatibles  |  Tipo de entorno  |  Fuente  |  Descripción  | 
| --- | --- | --- | --- | --- | 
|  Tomcat (página única)  |  Todas las ramas de plataforma *Tomcat con Corretto*  |  Servidor web Entorno de trabajo  |   [tomcat.zip](samples/tomcat.zip)   |  Aplicación web Tomcat con una sola página (`index.jsp`) configurada para mostrarse en la raíz del sitio web. Para los [entornos de trabajo](using-features-managing-env-tiers.md), este ejemplo incluye un archivo `cron.yaml` que configura una tarea programada que llama a `scheduled.jsp` una vez por minuto. Cuando se llama `scheduled.jsp`, se escribe un archivo log en `/tmp/sample-app.log`. Por último, se incluye un archivo de configuración en `.ebextensions` que copia los registros de `/tmp/` a las ubicaciones que Elastic Beanstalk lee cuando solicita registros del entorno. Si [habilita la integración de X-Ray](environment-configuration-debugging.md) en un entorno que ejecute este ejemplo, la aplicación muestra contenido adicional sobre X-Ray y proporciona una opción para generar información de depuración que puede ver en la consola de X-Ray.  | 
|  Corretto (página única)  |  Corretto 11 Corretto 8  |  Servidor web  |  [corretto.zip](samples/corretto.zip)  |  Aplicación Corretto con archivos de configuración `Buildfile` y `Procfile`. Si [habilita la integración de X-Ray](environment-configuration-debugging.md) en un entorno que ejecute este ejemplo, la aplicación muestra contenido adicional sobre X-Ray y proporciona una opción para generar información de depuración que puede ver en la consola de X-Ray.  | 
|  Scorekeep  | Java 8 | Servidor web | [Clona el repositorio en .com GitHub](https://github.com/awslabs/eb-java-scorekeep) |  *Scorekeep* es una API RESTful web que utiliza el marco Spring para proporcionar una interfaz para crear y administrar usuarios, sesiones y juegos. La API está empaquetada con una aplicación web de Angular 1.5 que utiliza la API a través de HTTP. La aplicación utiliza características de la plataforma de Java SE para descargar dependencias y compilarse en la instancia, lo que minimiza el tamaño del paquete de código fuente. La aplicación incluye también archivos de configuración nginx que invalidan la configuración predeterminada para servir la aplicación web frontend estáticamente en el puerto 80 a través del proxy y dirigir las solicitudes dirigidas a las rutas incluidas bajo `/api` a la API que se ejecuta en `localhost:5000`. Scorekeep también incluye una ramificación `xray` que muestra cómo instrumentar una aplicación Java para usar con AWS X-Ray. Muestra la instrumentación de las solicitudes HTTP entrantes con un filtro de servlets, la instrumentación automática y manual del cliente del AWS SDK, la configuración de la grabadora y la instrumentación de las solicitudes HTTP y los clientes SQL salientes. Consulte el archivo readme para obtener instrucciones o use el [Tutorial de introducción de AWS X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/xray-gettingstarted.html) para probar la aplicación con X-Ray.  | 
|  Does it Have Snakes?  | Tomcat 8 con Java 8 | Servidor web | [Clona el repositorio en .com GitHub](https://github.com/awslabs/eb-tomcat-snakes) |  *¿Tiene serpientes?* es una aplicación web de Tomcat que muestra el uso de los archivos de configuración de Elastic Beanstalk, Amazon RDS, JDBC, PostgreSQL, JSPs Servlets, Simple Tag Support, Tag Files, Log4J, Bootstrap y Jackson. El código fuente de este proyecto incluye un script de compilación mínimo que compila los servlets y modelos en archivos de clases y empaqueta los archivos necesarios en un archivo web que puede implementar en un entorno de Elastic Beanstalk. Consulte el archivo readme del repositorio del proyecto para obtener instrucciones completas.  | 
| Locust Load Generator | Java 8 | Servidor web | [Clona el repositorio en .com GitHub](https://github.com/awslabs/eb-locustio-sample) |  Aplicación web que puede utilizar para realizar una prueba de carga de otra aplicación web que se ejecute en un entorno de Elastic Beanstalk diferente. Muestra el uso de los archivos `Buildfile` y `Procfile`, DynamoDB y [Locust](http://locust.io/), una herramienta de pruebas de carga de código abierto.  | 

Descargue cualquiera de las aplicaciones de ejemplo e impleméntelas en Elastic Beanstalk siguiendo estos pasos:

**Cómo lanzar un entorno con una aplicación (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 **Aplicaciones**. Seleccione una aplicación existente de la lista. También puede elegir crear una según las instrucciones de [Administración de las aplicaciones de ](applications.md).

1. En la página de información general de la aplicación, seleccione **Crear entorno**.

   Esto abre el asistente de **Create environment** (Creación de entorno). El asistente proporciona un conjunto de pasos para crear un entorno nuevo.

1. Para el **Nivel de entorno**, elija el [nivel de entorno](concepts.md#concepts-tier) **Entorno del servidor web** o **Entorno de empleado**. Una vez creado, no se puede cambiar la capa del entorno.
**nota**  
La [plataforma .NET en Windows Server](create_deploy_NET.md) no admite la capa del entorno de trabajo.

   Los campos **Información de la aplicación** se establecen por defecto según la aplicación que haya elegido anteriormente.

   En la agrupación **Información del entorno**, el **nombre del entorno** se establece por defecto según el nombre de la aplicación. Si prefiere un nombre de entorno diferente, puede introducir otro valor en el campo. Si lo desea, puede introducir un nombre de **dominio**; de lo contrario, Elastic Beanstalk generará automáticamente un valor. También puede introducir una **descripción del entorno**.

1. En **Platform (Plataforma)**, seleccione la plataforma y la ramificación de la plataforma que coincidan con el lenguaje utilizado por la aplicación.
**nota**  
Elastic Beanstalk admite varias [versiones](concepts.platforms.md) para la mayoría de las plataformas que se indican. De forma predeterminada, la consola selecciona la versión recomendada para la plataforma y la ramificación de la plataforma que elija. Si la aplicación requiere una versión diferente, puede seleccionarla aquí. Para obtener más información acerca de las versiones compatibles de la plataforma, consulte [Plataformas compatibles con Elastic Beanstalk](concepts.platforms.md).

1. Para el **Código de la aplicación**, tiene varias opciones para continuar.
   + Para iniciar el aplicación de muestra predeterminado sin proporcionar el código fuente, seleccione **Aplicación de muestra**. Esta acción elige la aplicación de una sola página que Elastic Beanstalk proporciona para la plataforma que seleccionó previamente.
   + Si descargó una aplicación de muestra de esta guía o tiene su propio código fuente para una aplicación, siga estos pasos.

     1. Seleccione **Cargar el código**.

     1. A continuación, seleccione **Archivo local** y, en **Cargar aplicación**, seleccione **Elegir archivo**.

     1. El sistema operativo del equipo de su cliente mostrará una interfaz para seleccionar el archivo local que descargó. Seleccione el archivo del paquete de agrupación y continúe.

1. La elección de los **Elementos preestablecidos** dependerá del uso que se le quiera dar al entorno.
   + Si va a crear un entorno de muestra para aprender sobre Elastic Beanstalk o un entorno de desarrollo, elija **Instancia individual (apta para el nivel gratuito)**.
   + Si va a crear un entorno de producción o un entorno para aprender sobre el equilibrio de carga, elija una de las opciones de **Alta disponibilidad**.

1. Elija **Siguiente**.

**Cómo configurar el acceso al servicio**  
A continuación, necesita dos roles. Un *rol de servicio* permite a Elastic Beanstalk monitorear las instancias de EC2 y actualizar la plataforma del entorno. Un rol de *perfil de instancia de EC2* permite realizar tareas como escribir registros e interactuar con otros servicios.

**Cómo crear o seleccionar el rol de servicio**

1. Si ya ha creado un **rol de servicio** y desea elegir uno existente, seleccione el valor en el menú desplegable **Rol de servicio** y omita el resto de estos pasos para crear un rol de servicio.

1. Si no ve ningún valor en **Rol de servicio** o si desea crear uno nuevo, siga estos pasos.

1. Para el **rol de servicio**, elija **Crear rol**.

1. En **Tipo de entidad de confianza**, elija **Servicio de AWS **.

1. En **Caso de uso**, elija **Elastic Beanstalk - Entorno**.

1. Elija **Siguiente**.

1. Compruebe que las **Políticas de permisos** incluyan lo siguiente y, a continuación, seleccione **Siguiente**:
   + `AWSElasticBeanstalkEnhancedHealth`
   + `AWSElasticBeanstalkManagedUpdatesCustomerRolePolicy`

1. Elija **Crear rol**.

1. Vuelva a la pestaña **Configurar el acceso al servicio**, actualice la lista y, a continuación, seleccione el rol de servicio recién creado.

**Cómo crear o seleccionar un perfil de instancia de EC2**

1. Si ya ha creado un **perfil de instancia de EC2** y desea elegir uno existente, seleccione el valor en el menú desplegable **Perfil de instancia de EC2** y omita el resto de estos pasos para crear un perfil de instancia de EC2.

1. Si no ve ningún valor en **Perfil de instancia de EC2** o si desea crear uno nuevo, siga estos pasos.

1. Elija **Crear rol**.

1. En **Tipo de entidad de confianza**, elija **Servicio de AWS **.

1. En **Caso de uso**, elija **Elastic Beanstalk – Computación**.

1. Elija **Siguiente**.

1. Compruebe que las **Políticas de permisos** incluyan lo siguiente y, a continuación, seleccione **Siguiente**:
   + `AWSElasticBeanstalkWebTier`
   + `AWSElasticBeanstalkWorkerTier`
   + `AWSElasticBeanstalkMulticontainerDocker`

1. Elija **Crear rol**.

1. Vuelva a la pestaña **Configurar el acceso al servicio**, actualice la lista y, a continuación, seleccione el perfil de instancia de EC2 recién creado.

**Cómo terminar de configurar y crear la aplicación**

1. (Opcional) Si ha creado previamente un par de claves de EC2, puede seleccionarlo en el menú desplegable del campo **Par de claves de EC2**. Puede utilizar para iniciar sesión de forma segura en la instancia de Amazon EC2 aprovisionada por la aplicación de Elastic Beanstalk en su aplicación. Si se salta este paso, puede crear y asignar un par de claves de EC2 tras crear el entorno. Para obtener más información, consulte [EC2 key pair](using-features.managing.security.md#using-features.managing.security.keypair).

1. Seleccione **Skip to review** (Saltar a revisión) en la página **Configure service access** (Configuración de el acceso al servicio).

1. En la página **Review** (Revisar), se muestra un resumen de todas sus elecciones.

   Para personalizar aún más su entorno, elija **Edit** (Edición de) junto al paso que incluye los elementos que desee configurar. Solo puede establecer las siguientes opciones durante la creación del entorno:
   + Environment name
   + Nombre de dominio
   + Versión de la plataforma
   + Procesador
   + Tipo de equilibrador de carga
   + datos y búsqueda

   Puede modificar los siguientes ajustes después de crear el entorno, pero requieren que se aprovisionen nuevas instancias u otros recursos, lo que puede llevar algún tiempo:
   + Tipo de instancia, volumen raíz, key pair y rol AWS Identity and Access Management (IAM)
   + Base de datos interna de Amazon RDS
   + VPC

   Para obtener más información sobre los ajustes disponibles, consulte [El asistente de creación de nuevo entorno](environments-create-wizard.md).

1. Elija **Submit** (Enviar) en la parte inferior de la página para iniciar la creación del nuevo entorno.

## Siguientes pasos
<a name="java-getstarted-next"></a>

Una vez que disponga de un entorno que ejecute una aplicación, podrá [implementar una nueva versión](using-features.deploy-existing-version.md) de la aplicación o una aplicación totalmente diferente 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.

Después de haber implementado una o dos aplicaciones de ejemplo y una vez que esté preparado para empezar a desarrollar y ejecutar aplicaciones Java localmente, consulte [la siguiente sección](java-development-environment.md) para configurar un entorno de desarrollo de Java con todas las herramientas y bibliotecas que va a necesitar.

# Uso de la plataforma Tomcat de Elastic Beanstalk
<a name="java-tomcat-platform"></a>

En este tema se describe cómo configurar, crear y ejecutar las aplicaciones Java que se ejecutan en la plataforma Elastic Beanstalk Tomcat.

La plataforma AWS Elastic Beanstalk Tomcat es un conjunto de [versiones de plataforma](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.java) para aplicaciones web Java que se pueden ejecutar en un contenedor web Tomcat. Tomcat se ejecuta detrás de un servidor proxy nginx. Cada ramificación de la plataforma corresponde a una versión principal de Tomcat.

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.

Las plataforma Tomcat de Elastic Beanstalk incluye un proxy inverso que reenvía las solicitudes a su aplicación. Puede usar [opciones de configuración](#java-tomcat-namespaces) para configurar el servidor proxy para servir recursos estáticos de una carpeta del código fuente con el fin de reducir la carga en su aplicación. Para escenarios avanzados, puede [incluir sus propios archivos `.conf`](java-tomcat-proxy.md) en el paquete de código fuente para ampliar la configuración del proxy de Elastic Beanstalk o sobrescribirla completamente.

**nota**  
Elastic Beanstalk admite [nginx](https://www.nginx.com/) (el valor predeterminado) y [Apache HTTP Server](https://httpd.apache.org/) como servidores proxy en la plataforma Tomcat. Si su entorno Tomcat de Elastic Beanstalk utiliza una rama de plataforma de la AMI de Amazon Linux (anterior a Amazon Linux 2), también tiene la opción de utilizar [Apache HTTP Server versión 2.2](https://httpd.apache.org/docs/2.2/). Apache (el más reciente) es el valor predeterminado en estas ramas de plataforma más antiguas.   
 [El 18 de julio de 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk estableció el estado de todas las ramas de plataforma basadas en la AMI AL1 de Amazon Linux () como retiradas.** Para obtener más información sobre la migración a una ramificación de la plataforma Amazon Linux 2023 actual y totalmente compatible, consulte [Migración de su aplicación de Linux de Elastic Beanstalk a Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).

Debe empaquetar las aplicaciones Java en un archivo de aplicación web (WAR) con una estructura específica. Para obtener información sobre la estructura necesaria y su relación con la estructura de directorios de su proyecto, consulte [Estructuración de la carpeta de proyectos](java-tomcat-platform-directorystructure.md).

Para ejecutar varias aplicaciones en el mismo servidor web, puede [agrupar varios archivos WAR](java-tomcat-multiple-war-files.md) en un solo paquete de código fuente. Cada aplicación de un paquete múltiple de código fuente WAR se ejecuta en la ruta raíz (`ROOT.war` se ejecuta en `myapp.elasticbeanstalk.com/`) o en una ruta directamente debajo de ella (`app2.war` se ejecuta en `myapp.elasticbeanstalk.com/app2/`), según lo especifique el nombre del paquete WAR. En un único paquete de código fuente WAR, la aplicación siempre se ejecuta en la ruta raíz.

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

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

**Topics**
+ [

## Configuración del entorno de Tomcat
](#java-tomcat-options)
+ [

## Espacios de nombres de configuración de Tomcat
](#java-tomcat-namespaces)
+ [

# Agrupación de varios archivos WAR en entornos Tomcat
](java-tomcat-multiple-war-files.md)
+ [

# Estructuración de la carpeta de proyectos
](java-tomcat-platform-directorystructure.md)
+ [

# Configuración del servidor proxy
](java-tomcat-proxy.md)

## Configuración del entorno de Tomcat
<a name="java-tomcat-options"></a>

La plataforma Tomcat de Elastic Beanstalk proporciona algunas opciones específicas de la plataforma, además de las opciones estándar que tienen todas las plataformas. Estas opciones le permiten configurar la máquina virtual Java (JVM) que se ejecuta en los servidores web del entorno y definir las propiedades del sistema que proporcionan las cadenas de configuración a su aplicación.

Puede utilizar la consola de Elastic Beanstalk para habilitar la rotación de registros en Amazon S3 y configurar variables que la aplicación pueda leer desde el entorno.

**Para configurar el entorno Tomcat 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**.

### Opciones de contenedor
<a name="java-tomcat-options-container"></a>

Puede especificar estas opciones específicas de la plataforma:
+ **Proxy server (Servidor proxy)**: el servidor proxy que utilizar en las instancias del entorno. De forma predeterminada, se utiliza nginx.

### Opciones del contenedor de JVM
<a name="java-tomcat-options-jvm"></a>

El tamaño de montón de la máquina virtual Java (JVM) determina la cantidad de objetos que su aplicación puede crear en memoria antes de que se produzca la *[recopilación de elementos no utilizados](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/introduction.html)*. Puede modificar **Initial JVM Heap Size ** (`-Xms option`) y **Maximum JVM Heap Size** (opción `-Xmx`). Un tamaño de montón inicial mayor permite que se creen más objetos antes de que se recopilen los elementos no utilizados, pero también implica que el recolector de elementos no utilizados tardará más tiempo en compactar el montón. El tamaño de montón máximo especifica la cantidad máxima de memoria que la JVM puede asignar al ampliar el montón durante un periodo de actividad intensa.

**nota**  
La memoria disponible depende del tipo de instancia de Amazon EC2. Para obtener más información acerca de los tipos de instancias EC2 disponibles para su entorno de Elastic Beanstalk. consulte [Tipos de instancias](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) en la *Guía del usuario de Amazon Elastic Compute Cloud para las instancias de Linux*.

La *generación permanente* es una sección del montón de JVM que almacena definiciones de clases y metadatos asociados. Para modificar el tamaño de la generación permanente, escriba el nuevo tamaño en la opción ** PermGen Tamaño máximo de la JVM** (`-XX:MaxPermSize`). Esta configuración solo se aplica a Java 7 y versiones anteriores. **Esta opción quedó obsoleta en el JDK 8 y fue reemplazada por la MaxMetaspace opción Size ().** `-XX:MaxMetaspaceSize`

**importante**  
JDK 17 eliminó la compatibilidad con la opción `-XX:MaxPermSize` de Java. El uso de esta opción con un entorno que se ejecuta en una ramificación de la plataforma de Elastic Beanstalk con Corretto 17 generará un error. Elastic Beanstalk publicó su primera ramificación de la plataforma que ejecuta Tomcat con Corretto 17 el [13 de julio de 2023.](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2023-07-13-al2023.html)  
Para obtener más información, consulte los recursos siguientes.  
Sitio web de documentación de Oracle Java: [opciones de Java eliminadas](https://docs.oracle.com/en/java/javase/17/docs/specs/man/java.html#removed-java-options) 
Sitio web de documentación de Oracle Java: sección de *Metadatos de clase* en [Otras consideraciones](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/considerations.html)

*Para obtener más información sobre las plataformas de Elastic Beanstalk y sus componentes, consulte [Plataformas compatibles](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html) en la guía de Plataformas de AWS Elastic Beanstalk .*

### Log Options (Opciones de registro)
<a name="java-tomcat-options-logs"></a>

La sección **Log Options (Opciones de registro)** 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.
+ **Enable log file rotation to Amazon S3 (Habilitar la rotación de archivos de registro para Amazon S3)**: especifica si los archivos de registro de las instancias de Amazon EC2 de la aplicación se copian en el bucket de Amazon S3 asociado a la aplicación.

### Archivos estáticos
<a name="java-tomcat-options-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).

### Propiedades del entorno
<a name="java-tomcat-options-properties"></a>

En la sección **Environment Properties (Propiedades de entorno)**, puede especificar opciones de configuración del entorno en las instancias de Amazon EC2 que ejecutan su aplicación. Las propiedades del entorno se pasan como pares de clave-valor a la aplicación. 

La plataforma Tomcat define una propiedad comodín denominada `JDBC_CONNECTION_STRING` para los entornos Tomcat para pasar una cadena de conexión a una base de datos externa.

**nota**  
Si asocia una instancia de base de datos de RDS a su entorno, cree la cadena de conexión de JDBC dinámicamente desde las propiedades del entorno de Amazon Relational Database Service (Amazon RDS) proporcionadas por Elastic Beanstalk. Utilice JDBC\$1CONNECTION\$1STRING solo para las instancias de base de datos que no se aprovisionan con Elastic Beanstalk.  
Para obtener más información sobre el uso de Amazon RDS con su aplicación Java, consulte [Adición de una instancia de base de datos de Amazon RDS a su entorno de Java Elastic Beanstalk](java-rds.md).

Para las versiones de la plataforma Tomcat publicadas antes del [26 de marzo de 2025](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2025-03-26-windows.html), se puede acceder a las variables de entorno mediante `System.getProperty()`. Por ejemplo, podría leer una propiedad denominada `API_ENDPOINT` en una variable con el siguiente código.

```
String endpoint = System.getProperty("API_ENDPOINT");
```

En las versiones de la plataforma Tomcat publicadas a partir del [26 de marzo de 2025](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2025-03-26-windows.html) también se puede utilizar `System.getenv` para acceder a variables de entorno de texto sin formato. Puede seguir utilizando `System.getProperty` para acceder a las variables de entorno de texto sin formato. Sin embargo, [las variables de entorno almacenadas como secretas](AWSHowTo.secrets.env-vars.md) solo están disponibles mediante `System.getenv`. Por ejemplo, podría leer una variable de entorno denominada `API_KEY` con el siguiente código.

```
String apiKey = System.getenv("API_KEY");
```

**importante**  
Al añadir acceso `System.getenv()` a las variables de entorno en las versiones de la plataforma Tomcat publicadas a partir del [26 de marzo de 2025](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2025-03-26-windows.html), puede producirse un comportamiento inesperado en las aplicaciones que dan prioridad a las variables de entorno sobre las propiedades del sistema Java o al cambiar explícitamente de `System.getProperty()` a `System.getenv()`.  
Dado que las propiedades del sistema (que se transmiten mediante línea de comandos) requieren aplicar un escape en el intérprete de comandos para los caracteres especiales, mientras que las variables de entorno no, es posible que los valores se resuelvan de forma diferente cuando se utilizan variables de entorno en lugar de propiedades del sistema Java.  
Si su aplicación se ve afectada, considere lo siguiente:  
Eliminar los caracteres de escape de los valores de propiedad del entorno al usar `System.getenv()`.
Configurar la aplicación para utilizar `System.getProperty()` de forma explícita.
Probar minuciosamente la aplicación al actualizar para garantizar un comportamiento coherente.

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 Tomcat
<a name="java-tomcat-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 Tomcat admite las opciones de los siguientes espacios de nombres, además de las [opciones admitidas para todos los entornos de Elastic Beanstalk](command-options-general.md):
+ `aws:elasticbeanstalk:container:tomcat:jvmoptions`: modificar la configuración de JVM. Las opciones de este espacio de nombres se corresponden con las opciones de la consola de administración de la siguiente manera:
  + `Xms` – **JVM command line options (opciones de la línea de comandos de JVM)**
  + `JVM Options` – **JVM command line options (opciones de la línea de comandos de JVM)**
+ `aws:elasticbeanstalk:environment:proxy`: elija el servidor proxy del entorno.

El siguiente archivo de configuración de ejemplo muestra el uso de las opciones de configuración específicas de Tomcat.

**Example .ebextensions/tomcat-settings.config**  

```
option_settings:
  aws:elasticbeanstalk:container:tomcat:jvmoptions:
    Xms: 512m
    JVM Options: '-Xmn128m'
  aws:elasticbeanstalk:application:environment:
    API_ENDPOINT: mywebapi.zkpexsjtmd.us-west-2.elasticbeanstalk.com
  aws:elasticbeanstalk:environment:proxy:
    ProxyServer: apache
```

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

## Plataforma Tomcat de la AMI de Amazon Linux (anterior a Amazon Linux 2)
<a name="tomcat.alami"></a>

Si su entorno Tomcat de Elastic Beanstalk utiliza una versión de la plataforma de la AMI de Amazon Linux (anterior a Amazon Linux 2), lea la información adicional de esta sección.

**Notas**  
La información de este tema solo se aplica a las ramas de plataforma basadas en la AMI de Amazon Linux (AL1). AL2023/las ramas de la AL2 plataforma son incompatibles con las versiones anteriores de la plataforma AMI (AL1) de Amazon Linux y *requieren ajustes de configuración diferentes*.
 [El 18 de julio de 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk estableció el estado de todas las ramas de plataforma basadas en la AMI AL1 de Amazon Linux () como retiradas.** Para obtener más información sobre la migración a una ramificación de la plataforma Amazon Linux 2023 actual y totalmente compatible, consulte [Migración de su aplicación de Linux de Elastic Beanstalk a Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).

### Espacios de nombres de configuración de Tomcat: AMI de Amazon Linux () AL1
<a name="tomcat.alami.namespaces"></a>

La plataforma Tomcat de la AMI de Amazon Linux admite opciones adicionales en los siguientes espacios de nombres:
+ `aws:elasticbeanstalk:container:tomcat:jvmoptions`: además de las opciones mencionadas anteriormente en esta página para este espacio de nombres, las versiones más antiguas de la plataforma de la AMI de Amazon Linux también admiten:
  + `XX:MaxPermSize` – **Maximum JVM permanent generation size (Máximo de generación permanente de JVM)**
+ `aws:elasticbeanstalk:environment:proxy`: además de elegir el servidor proxy, configure también la compresión de respuesta.

El siguiente archivo de configuración de ejemplo muestra el uso de las opciones de configuración de los espacios de nombre del proxy.

**Example .ebextensions/tomcat-settings.config**  

```
option_settings:
  aws:elasticbeanstalk:environment:proxy:
    GzipCompression: 'true'
    ProxyServer: nginx
```

### Incluir archivos de configuración de Elastic Beanstalk: AMI de Amazon Linux () AL1
<a name="java-tomcat-ebextensions"></a>

Para implementar los archivos de configuración de `.ebextensions`, incluirlos en código fuente de la aplicación. Para una sola aplicación, añada `.ebextensions` a un archivo WAR comprimido ejecutando el siguiente comando:

**Example**  

```
zip -ur your_application.war .ebextensions
```

Si se trata de una aplicación que necesite varios archivos WAR, consulte [Agrupación de varios archivos WAR en entornos Tomcat](java-tomcat-multiple-war-files.md) para obtener información más detallada.

# Agrupación de varios archivos WAR en entornos Tomcat
<a name="java-tomcat-multiple-war-files"></a>

Si la aplicación web contiene varios componentes de aplicaciones web, puede simplificar las implementaciones y reducir los costos operativos ejecutando los componentes en un único entorno, en lugar de ejecutar un entorno diferente para cada componente. Esta estrategia resulta eficaz con aplicaciones ligeras que no requieren una gran cantidad de recursos y con entornos de desarrollo y pruebas.

Para implementar varias aplicaciones web en el entorno, combine los archivos WAR (archivo de aplicación web) de cada componente en un único [paquete de código fuente](applications-sourcebundle.md).

Para crear un paquete de código fuente de la aplicación que contenga varios archivos WAR, organice estos archivos utilizando la siguiente estructura.

```
MyApplication.zip
├── .ebextensions
├── .platform
├── foo.war
├── bar.war
└── ROOT.war
```

Al implementar un paquete de código fuente que contiene varios archivos WAR en un AWS Elastic Beanstalk entorno, se puede acceder a cada aplicación desde una ruta diferente a la del nombre de dominio raíz. El ejemplo anterior contenía tres aplicaciones: `foo`, `bar` y `ROOT`. `ROOT.war` es un nombre de archivo especial que le indica a Elastic Beanstalk que ejecute esa aplicación en el dominio raíz, por lo que las tres aplicaciones estarán disponibles en `http://MyApplication.elasticbeanstalk.com/foo`, `http://MyApplication.elasticbeanstalk.com/bar` y `http://MyApplication.elasticbeanstalk.com`.

El paquete fuente puede incluir archivos WAR, una carpeta `.ebextensions` opcional y una carpeta `.platform` opcional. Para obtener información detallada sobre estas carpetas de configuración opcionales, consulte [Ampliación de las plataformas Linux de Elastic Beanstalk](platforms-linux-extend.md).

**Para lanzar un entorno (consola)**

1. [Abra la consola de Elastic Beanstalk con este enlace preconfigurado: console.aws.amazon. com/elasticbeanstalk/home\$1/newApplication? ApplicationName=Tutorials&EnvironmentType= LoadBalanced](https://console.aws.amazon.com/elasticbeanstalk/home#/newApplication?applicationName=tutorials&environmentType=LoadBalanced)

1. En **Platform (Plataforma)**, seleccione la plataforma y la ramificación de plataforma que coincidan con el idioma utilizado por su aplicación, o la plataforma Docker para aplicaciones basadas en contenedores.

1. En **Código de la aplicación**, seleccione **Cargar su propio código**.

1. Elija **Local file (Archivo local)**, seleccione **Choose file (Seleccionar archivo)** y abra el paquete de código fuente.

1. Elija **Review and launch (Revisar y lanzar)**.

1. Revise la configuración disponible y, a continuación, elija **Create app (Creación de aplicación)**.

Para obtener más información sobre la creación de paquetes de código fuente, consulte [Creación de una agrupación de orígenes de aplicación en Elastic Beanstalk.](applications-sourcebundle.md).

# Estructuración de la carpeta de proyectos
<a name="java-tomcat-platform-directorystructure"></a>

Para que todo funcione al realizar la implementación en un servidor Tomcat, los archivos de aplicación web (archivos WAR) compilados con Java Platform Enterprise Edition (*Java EE*) deben estar estructurados de acuerdo con ciertas [directrices](https://docs.oracle.com/javaee/7/tutorial/packaging003.htm). El directorio de proyectos no tiene que ajustarse a los mismos estándares, pero es recomendable estructurarlo de la misma manera para simplificar la compilación y el empaquetado. Estructurar la carpeta de proyectos igual que el contenido del archivo WAR también le ayuda a comprender cómo se relacionan los archivos y cómo se comportan en un servidor web.

En la siguiente jerarquía recomendada, el código fuente de la aplicación web se coloca en un directorio `src` para aislarlo del script de compilación y del archivo WAR que genera.

```
~/workspace/my-app/
|-- build.sh            - Build script that compiles classes and creates a WAR
|-- README.MD           - Readme file with information about your project, notes
|-- ROOT.war            - Source bundle artifact created by build.sh
`-- src                 - Source code folder
    |-- WEB-INF         - Folder for private supporting files
    |   |-- classes     - Compiled classes
    |   |-- lib         - JAR libraries
    |   |-- tags        - Tag files
    |   |-- tlds        - Tag Library Descriptor files
    |   `-- web.xml     - Deployment Descriptor
    |-- com             - Uncompiled classes
    |-- css             - Style sheets
    |-- images          - Image files
    |-- js              - JavaScript files
    `-- default.jsp     - JSP (JavaServer Pages) webpage
```

El contenido del archivo `src` coincide con lo que se va a empaquetar e implementar en el servidor, a excepción de la carpeta `com`. La carpeta `com` contiene las clases no compiladas (archivos `.java`). Deben compilarse y guardarse en el directorio `WEB-INF/classes` para que estén accesibles desde el código de la aplicación.

El directorio `WEB-INF` contiene código y configuraciones que no se proporcionan públicamente en el servidor web. Las demás carpetas de la raíz del directorio de código fuente (`css`, `images` y `js`) están disponibles públicamente en la ruta correspondiente del servidor web.

El siguiente ejemplo es idéntico al directorio de proyectos anterior, salvo que contiene más archivos y subdirectorios. En este ejemplo, el proyecto contiene etiquetas sencillas, un modelo y clases de compatibilidad, así como un archivo de Java Server Pages (JSP) para un recurso `record`. También incluye una hoja de estilos y, JavaScript para [Bootstrap](http://getbootstrap.com/), un archivo JSP predeterminado y una página de errores para los errores 404.

`WEB-INF/lib` contiene un archivo de Java Archive (JAR) con el controlador de Java Database Connectivity (JDBC) para PostgreSQL. `WEB-INF/classes` está vacío, ya que no se han compilado todavía los archivos de clase.

```
~/workspace/my-app/
|-- build.sh
|-- README.MD
|-- ROOT.war
`-- src
    |-- WEB-INF
    |   |-- classes
    |   |-- lib
    |   |   `-- postgresql-9.4-1201.jdbc4.jar
    |   |-- tags
    |   |   `-- header.tag
    |   |-- tlds
    |   |   `-- records.tld
    |   `-- web.xml
    |-- com
    |   `-- myapp
    |       |-- model
    |       |   `-- Record.java
    |       `-- web
    |           `-- ListRecords.java
    |-- css
    |   |-- bootstrap.min.css
    |   `-- myapp.css
    |-- images
    |   `-- myapp.png
    |-- js
    |   `-- bootstrap.min.js
    |-- 404.jsp
    |-- default.jsp
    `-- records.jsp
```

## Compilación de un archivo WAR con un script de shell
<a name="java-tomcat-platform-directorystructure-building"></a>

`build.sh` es un script de shell muy sencillo que compila las clases de Java, construye un archivo WAR y lo copia en el directorio `webapps` de Tomcat para las pruebas locales.

```
cd src
javac -d WEB-INF/classes com/myapp/model/Record.java
javac -classpath WEB-INF/lib/*:WEB-INF/classes -d WEB-INF/classes com/myapp/model/Record.java
javac -classpath WEB-INF/lib/*:WEB-INF/classes -d WEB-INF/classes com/myapp/web/ListRecords.java

jar -cvf ROOT.war *.jsp images css js WEB-INF
cp ROOT.war /Library/Tomcat/webapps
mv ROOT.war ../
```

Dentro del archivo WAR, encontrará la misma estructura que en el directorio `src` del ejemplo anterior, a excepción de la carpeta `src/com`. El comando `jar` crea automáticamente el archivo `META-INF/MANIFEST.MF`.

```
~/workspace/my-app/ROOT.war
|-- META-INF
|   `-- MANIFEST.MF
|-- WEB-INF
|   |-- classes
|   |   `-- com
|   |       `-- myapp
|   |           |-- model
|   |           |   `-- Records.class
|   |           `-- web
|   |               `-- ListRecords.class
|   |-- lib
|   |   `-- postgresql-9.4-1201.jdbc4.jar
|   |-- tags
|   |   `-- header.tag
|   |-- tlds
|   |   `-- records.tld
|   `-- web.xml
|-- css
|   |-- bootstrap.min.css
|   `-- myapp.css
|-- images
|   `-- myapp.png
|-- js
|   `-- bootstrap.min.js
|-- 404.jsp
|-- default.jsp
`-- records.jsp
```

## Uso `.gitignore`
<a name="java-tomcat-platform-gitignore"></a>

Para evitar que se validen los archivos de clases compiladas y los archivos WAR en su repositorio de Git o que aparezcan mensajes cuando ejecute comandos Git, agregue los tipos de archivo pertinentes en un archivo denominado `.gitignore` en la carpeta de su proyecto.

**\$1/workspace/myapp/.gitignore**

```
*.zip
*.class
```

# Configuración del servidor proxy
<a name="java-tomcat-proxy"></a>

La plataforma Tomcat utiliza [nginx](https://www.nginx.com/) (el valor predeterminado) o [Apache HTTP Server](https://httpd.apache.org/) como proxy inverso para transmitir las solicitudes del puerto 80 de la instancia al contenedor web Tomcat que está a la escucha en el puerto 8080. Elastic Beanstalk proporciona una configuración de proxy predeterminada que puede ampliar o anular por completo con su propia configuración.

**Configuración del servidor proxy en la versión de su plataforma**  
Todas las AL2 plataformas AL2023/admiten una función de configuración de proxy uniforme. Para obtener más información sobre la configuración del servidor proxy en las versiones de su plataforma que ejecutan AL2023/AL2, consulte[Configuración del proxy inverso](platforms-linux-extend.proxy.md). 

## Configuración del proxy en la plataforma Tomcat de la AMI de Amazon Linux (anterior a Amazon Linux 2)
<a name="java-tomcat-proxy.alami"></a>

Si su entorno Tomcat de Elastic Beanstalk utiliza una versión de la plataforma de la AMI de Amazon Linux (anterior a Amazon Linux 2), lea la información adicional de esta sección.

**Notas**  
La información de este tema solo se aplica a las ramas de plataforma basadas en la AMI de Amazon Linux (AL1). AL2023/las ramas de la AL2 plataforma son incompatibles con las versiones anteriores de la plataforma AMI (AL1) de Amazon Linux y *requieren ajustes de configuración diferentes*.
 [El 18 de julio de 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk estableció el estado de todas las ramas de plataforma basadas en la AMI AL1 de Amazon Linux () como retiradas.** Para obtener más información sobre la migración a una ramificación de la plataforma Amazon Linux 2023 actual y totalmente compatible, consulte [Migración de su aplicación de Linux de Elastic Beanstalk a Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).

### Elección de un servidor proxy para su entorno Tomcat — AMI de Amazon Linux () AL1
<a name="java-tomcat-proxy.alami"></a>

Las versiones de la plataforma Tomcat basadas en la AMI de Amazon Linux (anterior a Amazon Linux 2) utilizan [Apache 2.4](https://httpd.apache.org/docs/2.4/) para el proxy de forma predeterminada. Puede elegir usar [Apache 2.2](https://httpd.apache.org/docs/2.2/) o [nginx](https://www.nginx.com/) incluyendo un [archivo de configuración](ebextensions.md) en el código fuente. El siguiente ejemplo configura Elastic Beanstalk para usar nginx.

**Example .ebextensions/nginx-proxy.config**  

```
option_settings:
  aws:elasticbeanstalk:environment:proxy:
    ProxyServer: nginx
```

### Migración de Apache 2.2 a Apache 2.4 — AMI de Amazon Linux () AL1
<a name="java-tomcat-proxy-apache-migrate"></a>

Si la aplicación se desarrolló para [Apache 2.2](https://httpd.apache.org/docs/2.2/), lea esta sección para obtener información sobre la migración a [Apache 2.4](https://httpd.apache.org/docs/2.4/).

A partir de las configuraciones de la versión 3.0.0 de la plataforma Tomcat, que se publicaron con la [actualización de Java con la plataforma Tomcat el 24 de mayo de 2018](https://aws.amazon.com/releasenotes/release-aws-elastic-beanstalk-platform-update-for-the-java-with-tomcat-platform-on-may-24-2018/), Apache 2.4 es el proxy predeterminado de la plataforma Tomcat. Los archivos `.conf` de Apache 2.4 son en su mayoría, pero no todos, compatibles con los de Apache 2.2. Elastic Beanstalk incluye archivos `.conf` predeterminados que funcionan correctamente con cada versión de Apache. Si la aplicación no personaliza la configuración de Apache, tal y como se explica en [Ampliación y anulación de la configuración predeterminada de Apache: AMI de Amazon Linux () AL1](#java-tomcat-proxy-apache), debería migrar a Apache 2.4 sin problemas.

Si la aplicación amplía o anula la configuración de Apache, es posible que tenga que realizar algunos cambios para migrar a Apache 2.4. Para obtener más información, consulte [Upgrading to 2.4 from 2.2](https://httpd.apache.org/docs/current/upgrading.html) en el sitio web de *The Apache Software Foundation*. Como medida temporal, hasta que migre correctamente a Apache 2.4, puede utilizar Apache 2.2 con su aplicación; para ello, incluya el segmento [archivo de configuración](ebextensions.md) en el código fuente.

**Example .ebextensions/ .config apache-legacy-proxy**  

```
option_settings:
  aws:elasticbeanstalk:environment:proxy:
    ProxyServer: apache/2.2
```

Para obtener una solución rápida, también puede seleccionar el servidor proxy en la consola de Elastic Beanstalk.

**Para seleccionar el proxy en el entorno Tomcat 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**.

1. En **Proxy server (Servidor proxy)**, elija `Apache 2.2 (deprecated)`.

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

![\[Selección del proxy para un entorno Tomcat en la categoría de configuración de software de la consola de Elastic Beanstalk\]](http://docs.aws.amazon.com/es_es/elasticbeanstalk/latest/dg/images/java-tomcat-proxy-selection.png)


### Ampliación y anulación de la configuración predeterminada de Apache: AMI de Amazon Linux () AL1
<a name="java-tomcat-proxy-apache"></a>

Puede ampliar la configuración de Apache predeterminada de Elastic Beanstalk con archivos de configuración adicionales. Si lo prefiere, puede anular por completo la configuración de Apache predeterminada de Elastic Beanstalk.

**nota**  
Todas las plataformas de Amazon Linux 2 admiten una característica de configuración de proxy uniforme. Para obtener más información sobre la configuración del servidor proxy en las versiones de la plataforma Tomcat que ejecutan Amazon Linux 2, consulte [Configuración del proxy inverso](platforms-linux-extend.proxy.md).
Si va a migrar su aplicación de Elastic Beanstalk a una plataforma de Amazon Linux 2, asegúrese de leer también la información en [Migración de su aplicación de Linux de Elastic Beanstalk a Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).

Para ampliar la configuración de Apache predeterminada de Elastic Beanstalk, añada los archivos de configuración `.conf` a una carpeta con el nombre `.ebextensions/httpd/conf.d` en el paquete de código fuente de su aplicación. La configuración de Apache de Elastic Beanstalk incluye archivos `.conf` en esta carpeta automáticamente.

```
~/workspace/my-app/
|-- .ebextensions
|   -- httpd
|      -- conf.d
|         -- myconf.conf
|         -- ssl.conf
-- index.jsp
```

Por ejemplo, la siguiente configuración de Apache 2.4 agrega un agente de escucha en el puerto 5000.

**Example . ebextensions/httpd/conf.d/port5000.conf**  

```
listen 5000
<VirtualHost *:5000>
  <Proxy *>
    Require all granted
  </Proxy>
  ProxyPass / http://localhost:8080/ retry=0
  ProxyPassReverse / http://localhost:8080/
  ProxyPreserveHost on

  ErrorLog /var/log/httpd/elasticbeanstalk-error_log
</VirtualHost>
```

Para anular por completo la configuración de Apache predeterminada de Elastic Beanstalk, incluya una configuración en el paquete de código fuente en `.ebextensions/httpd/conf/httpd.conf`.

```
~/workspace/my-app/
|-- .ebextensions
|   `-- httpd
|       `-- conf
|           `-- httpd.conf
`-- index.jsp
```

Si anula la configuración de Apache de Elastic Beanstalk, agregue las siguientes líneas a su `httpd.conf` para extraer las configuraciones de Elastic Beanstalk de [Informes y monitoreo de estado mejorados de Elastic Beanstalk](health-enhanced.md), la compresión de respuesta y los archivos estáticos.

```
IncludeOptional conf.d/*.conf
IncludeOptional conf.d/elasticbeanstalk/*.conf
```

Si su entorno utiliza Apache 2.2 como proxy, reemplace las directivas `IncludeOptional` por `Include`. Para obtener más información sobre el comportamiento de estas dos directivas en las dos versiones de Apache, consulte [Incluir en Apache 2.4](https://httpd.apache.org/docs/2.4/mod/core.html#include), [IncludeOptional en Apache 2.4](https://httpd.apache.org/docs/2.4/mod/core.html#includeoptional) e [Incluir en](https://httpd.apache.org/docs/2.2/mod/core.html#include) Apache 2.2.

**nota**  
Para anular el agente de escucha predeterminado en el puerto 80, incluya un archivo denominado `00_application.conf` en `.ebextensions/httpd/conf.d/elasticbeanstalk/` para sobrescribir la configuración de Elastic Beanstalk.

Para consultar un ejemplo funcional, eche un vistazo al archivo de configuración predeterminado de Elastic Beanstalk en `/etc/httpd/conf/httpd.conf` en una instancia de su entorno. Todos los archivos de la carpeta `.ebextensions/httpd` del paquete de código fuente se copian en `/etc/httpd` durante las implementaciones.

### Ampliación de la configuración de nginx predeterminada: AMI de Amazon Linux () AL1
<a name="java-tomcat-proxy-nginx"></a>

Para ampliar la configuración predeterminada de nginx de Elastic Beanstalk, añada los archivos de configuración `.conf` a una carpeta con el nombre `.ebextensions/nginx/conf.d/` en el paquete de código fuente de su aplicación. La configuración de nginx de Elastic Beanstalk incluye archivos `.conf` en esta carpeta automáticamente.

```
~/workspace/my-app/
|-- .ebextensions
|   `-- nginx
|       `-- conf.d
|           |-- elasticbeanstalk
|           |   `-- my-server-conf.conf
|           `-- my-http-conf.conf
`-- index.jsp
```

Los archivos con la extensión .conf en la carpeta `conf.d` se incluyen en el bloque `http` de la configuración predeterminada. Los archivos de la carpeta `conf.d/elasticbeanstalk` se incluyen en el bloque `server` dentro del bloque `http`.

Para anular completamente la configuración predeterminada de nginx de Elastic Beanstalk, incluya una configuración en el paquete de código fuente de `.ebextensions/nginx/nginx.conf`.

```
~/workspace/my-app/
|-- .ebextensions
|   `-- nginx
|       `-- nginx.conf
`-- index.jsp
```

**Notas**  
Si anula la configuración de nginx de Elastic Beanstalk, añada la siguiente línea al bloque `server` de su configuración para extraer las configuraciones de Elastic Beanstalk del agente de escucha del puerto 80, la compresión de respuesta y los archivos estáticos.  

  ```
   include conf.d/elasticbeanstalk/*.conf;
  ```
Para anular el agente de escucha predeterminado en el puerto 80, incluya un archivo denominado `00_application.conf` en `.ebextensions/nginx/conf.d/elasticbeanstalk/` para sobrescribir la configuración de Elastic Beanstalk.
Incluya también la línea siguiente en el bloque `http` de su configuración para extraer las configuraciones de Elastic Beanstalk para [Informes y monitoreo de estado mejorados de Elastic Beanstalk](health-enhanced.md) y los registros.  

  ```
      include       conf.d/*.conf;
  ```

Para consultar un ejemplo funcional, eche un vistazo al archivo de configuración predeterminado de Elastic Beanstalk en `/etc/nginx/nginx.conf` en una instancia de su entorno. Todos los archivos de la carpeta `.ebextensions/nginx` del paquete de código fuente se copian en `/etc/nginx` durante las implementaciones.

# Uso de la plataforma Java SE de Elastic Beanstalk
<a name="java-se-platform"></a>

En este tema se describe cómo configurar, crear y ejecutar las aplicaciones Java que se ejecutan en la plataforma AWS Elastic Beanstalk Java SE.

La plataforma Java SE de Elastic Beanstalk es un conjunto de [versiones de plataforma](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.javase) para aplicaciones web Java que se pueden ejecutar por sí solas a partir de un archivo JAR compilado. Puede compilar su aplicación localmente o cargar el código fuente con un script de compilación para compilarlo en la instancia. Las versiones de la plataforma Java SE se agrupan en ramas de plataforma, cada una de las cuales corresponde a una versión principal de Java.

**nota**  
Elastic Beanstalk no analiza el archivo JAR de su aplicación. Mantenga los archivos que necesita Elastic Beanstalk fuera del archivo JAR. Por ejemplo, incluya el archivo `cron.yaml` de un [entorno de trabajo](using-features-managing-env-tiers.md) en la raíz del paquete de código fuente de la aplicación junto al archivo JAR.

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 plataforma Java SE de Elastic Beanstalk incluye un servidor [nginx](https://www.nginx.com/) que actúa como proxy inverso, que sirve contenido estático almacenado en caché y pasa solicitudes a su aplicación. La plataforma proporciona también opciones para configurar el servidor proxy y atender recursos estáticos de una carpeta del código fuente con el fin de reducir la carga en su aplicación. Para escenarios avanzados, puede [incluir sus propios archivos .conf](java-se-nginx.md) en el paquete de código fuente para ampliar la configuración del proxy de Elastic Beanstalk o sobrescribirla completamente. 

Si solo proporciona un único archivo JAR para el código fuente de la aplicación (por sí mismo, no dentro de un paquete de código fuente), Elastic Beanstalk cambia el nombre de su archivo JAR a `application.jar` y, a continuación, lo ejecuta usando `java -jar application.jar`. Para configurar los procesos que se ejecutan en las instancias de servidor en su entorno, incluya un [Procfile](java-se-procfile.md) opcional en su paquete de código fuente. El `Procfile` es necesario si tiene más de un JAR en la raíz del paquete de código fuente, o bien si desea personalizar el comando Java para establecer opciones de JVM.

Le recomendamos que siempre proporcione un paquete `Procfile` en el origen junto con su aplicación. De esta forma, puede controlar con precisión qué procesos ejecuta Elastic Beanstalk para su aplicación y qué argumentos reciben estos procesos.

Para compilar clases de Java y ejecutar otros comandos de compilación en las EC2 instancias de su entorno en el momento de la implementación, incluya un [archivo de compilación en el paquete](java-se-buildfile.md) de código fuente de la aplicación. A te `Buildfile` permite implementar el código fuente tal como está y compilarlo en el servidor en lugar de compilarlo localmente. JARs La plataforma Java SE incluye herramientas de compilación comunes que le permiten compilar en el servidor.

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 Java SE
<a name="java-se-options"></a>

La configuración de la plataforma Java SE le permite ajustar el comportamiento de sus 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 habilitar la rotación de registros en Amazon S3 y configurar variables que la aplicación pueda leer desde el entorno.

**Para configurar el entorno Java SE 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**.

### Log Options (Opciones de registro)
<a name="java-se-options-logs"></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="java-se-options-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).

### Propiedades del entorno
<a name="java-se-options-properties"></a>

La sección **Propiedades del entorno** le permite especificar los ajustes de configuración del entorno en las EC2 instancias de Amazon que ejecutan su aplicación. Las propiedades del entorno se pasan como pares de clave-valor a la aplicación.

Dentro del entorno de Java SE que se ejecuta en Elastic Beanstalk, es posible acceder a las variables de entorno mediante `System.getenv()`. Por ejemplo, podría leer una propiedad denominada `API_ENDPOINT` en una variable con el siguiente código:

```
String endpoint = System.getenv("API_ENDPOINT");
```

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 Java SE
<a name="java-se-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 Java SE no define ningún espacio de nombres específico de la plataforma. Puede configurar el proxy para que sirva archivos estáticos mediante el espacio de nombres `aws:elasticbeanstalk:environment:proxy:staticfiles`. Para obtener información detallada y un ejemplo, consulte [Distribución de archivos estáticos](environment-cfg-staticfiles.md).

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

## Plataforma Java SE de la AMI de Amazon Linux (anterior a Amazon Linux 2)
<a name="java-se.alami"></a>

Si su entorno Java SE de Elastic Beanstalk utiliza una versión de la plataforma de la AMI de Amazon Linux (anterior a Amazon Linux 2), lea la información adicional de esta sección.

**Notas**  
La información de este tema solo se aplica a las ramas de plataforma basadas en la AMI de Amazon Linux (AL1). AL2Las ramas de la AL2 plataforma 023/ no son compatibles con las versiones anteriores de la plataforma AMI (AL1) de Amazon Linux y *requieren ajustes de configuración diferentes*.
 [El 18 de julio de 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk estableció el estado de todas las ramas de plataforma basadas en la AMI AL1 de Amazon Linux () como retiradas.** Para obtener más información sobre la migración a una ramificación de la plataforma Amazon Linux 2023 actual y totalmente compatible, consulte [Migración de su aplicación de Linux de Elastic Beanstalk a Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).

### Espacios de nombres de configuración de Java SE: AMI de Amazon Linux () AL1
<a name="java-se.alami.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 Java SE admite un espacio de nombres de configuración específico de la plataforma, además de los [espacios de nombres compatibles con todas las plataformas](command-options-general.md). El espacio de nombres `aws:elasticbeanstalk:container:java:staticfiles` le permite definir opciones que asignen las rutas de su aplicación web a carpetas del paquete de código fuente de la aplicación que incluyen contenido estático.

Por ejemplo, este fragmento de [option\$1settings](ebextensions-optionsettings.md) define dos opciones en el espacio de nombres de archivos estáticos. La primera asigna la ruta `/public` a una carpeta con el nombre `public` y la segunda asigna la ruta `/images` a una carpeta con el nombre `img`:

```
option_settings:
  aws:elasticbeanstalk:container:java:staticfiles:
    /html: statichtml
    /images: staticimages
```

Las carpetas que se asignan a través de este espacio de nombres deben ser carpetas reales situadas en la raíz del paquete de código fuente. No puede asignar una ruta a una carpeta en un archivo JAR.

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

# Construir JARs en el servidor con un Buildfile
<a name="java-se-buildfile"></a>

Puede crear los archivos de clases y los JAR de su aplicación en las EC2 instancias de su entorno invocando un comando de compilación desde un `Buildfile` archivo de su paquete de código fuente.

Los comandos de un `Buildfile` solo se ejecutan una vez y deben terminar cuando se completen, mientras que se espera que los comandos de un [Procfile](java-se-procfile.md) se ejecuten durante el ciclo de vida de la aplicación y se reinicien si terminan. Para ejecutarlos JARs en tu aplicación, usa un`Procfile`.

Para obtener más información sobre la ubicación y la sintaxis de un `Buildfile`, consulte [Buildfile y Procfile](platforms-linux-extend.build-proc.md).

El siguiente ejemplo de `Buildfile` ejecuta Apache Maven para compilar una aplicación web a partir de código fuente. Consulte los [ejemplos de aplicaciones web Java](java-getstarted.md#java-getstarted-samples) para ver una aplicación de muestra que utilice esta característica.

**Example Buildfile**  

```
build: mvn assembly:assembly -DdescriptorId=jar-with-dependencies
```

La plataforma Java SE incluye las siguientes herramientas de compilación, que puede invocar desde un script de compilación:
+ `javac`: compilador de Java
+ `ant`: Apache Ant
+ `mvn`: Apache Maven
+ `gradle`: Gradle

# Configuración del proceso de la aplicación con un Procfile
<a name="java-se-procfile"></a>

Si tiene más de un archivo JAR en la raíz del paquete de código fuente de su aplicación, debe incluir un archivo `Procfile` que indique a Elastic Beanstalk qué archivos JAR debe ejecutar. También puede incluir un archivo `Procfile` para una sola aplicación JAR para configurar la máquina virtual Java (JVM) que ejecuta su aplicación.

Le recomendamos que siempre proporcione un paquete `Procfile` en el origen junto con su aplicación. De esta forma, puede controlar con precisión qué procesos ejecuta Elastic Beanstalk para su aplicación y qué argumentos reciben estos procesos.

Para obtener más información sobre cómo escribir y usar un `Procfile`, consulte [Buildfile y Procfile](platforms-linux-extend.build-proc.md).

**Example Procfile**  

```
web: java -Xms256m -jar server.jar 
cache: java -jar mycache.jar
web_foo: java -jar other.jar
```

El comando que ejecuta el archivo JAR principal de su aplicación debe llamarse `web` y debe ser el primer comando incluido en el archivo `Procfile`. El servidor nginx reenvía todas las solicitudes HTTP que recibe del equilibrador de carga de su entorno a esta aplicación.

Elastic Beanstalk asume que todas las entradas del archivo Procfile deben ejecutarse en todo momento y reinicia automáticamente todas las aplicaciones definidas en el archivo Procfile que termina. Para ejecutar comandos que terminan y no deben reiniciarse, utilice un [`Buildfile`](java-se-buildfile.md).

## Uso de un archivo Procfile en la AMI de Amazon Linux (anterior a Amazon Linux 2)
<a name="java-se-procfile.alami"></a>

Si su entorno Java SE de Elastic Beanstalk utiliza una versión de la plataforma de la AMI de Amazon Linux (anterior a Amazon Linux 2), lea la información adicional de esta sección.

**Notas**  
La información de este tema solo se aplica a las ramas de plataforma basadas en la AMI de Amazon Linux (AL1). AL2Las ramas de la AL2 plataforma 023/ no son compatibles con las versiones anteriores de la plataforma AMI (AL1) de Amazon Linux y *requieren ajustes de configuración diferentes*.
 [El 18 de julio de 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk estableció el estado de todas las ramas de plataforma basadas en la AMI AL1 de Amazon Linux () como retiradas.** Para obtener más información sobre la migración a una ramificación de la plataforma Amazon Linux 2023 actual y totalmente compatible, consulte [Migración de su aplicación de Linux de Elastic Beanstalk a Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).

### Transferencia de puertos: AMI de Amazon Linux (AL1)
<a name="java-se-procfile.alami.ports"></a>

De forma predeterminada, Elastic Beanstalk configura el proxy nginx para reenviar las solicitudes a la aplicación en el puerto 5000. Puede invalidar el puerto predeterminado estableciendo la [propiedad del entorno](java-se-platform.md#java-se-options) `PORT` en el puerto en el que desea que la aplicación principal esté a la escucha.

Si utiliza un `Procfile` para ejecutar varias aplicaciones, Elastic Beanstalk en las versiones de la plataforma de la AMI de Amazon Linux espera que cada aplicación adicional esté a la escucha en un puerto 100 mayor que el anterior. Elastic Beanstalk establece la variable PORT accesible desde cada aplicación en el puerto en el que espera que se ejecute la aplicación. Puede tener acceso a esta variable en el código de su aplicación llamando a `System.getenv("PORT")`.

En el `Procfile` de ejemplo anterior, la aplicación `web` está a la escucha en el puerto 5000, `cache` en el puerto 5100 y `web_foo` en el puerto 5200. `web` configura su puerto de escucha leyendo la variable `PORT` y añade 100 a dicho número para determinar en qué puerto `cache` está a la escucha para poder enviarle solicitudes.

# Configuración del servidor proxy
<a name="java-se-nginx"></a>

Elastic Beanstalk utiliza [nginx](https://www.nginx.com/) como proxy inverso para asignar su aplicación al equilibrador de carga de Elastic Load Balancing en el puerto 80. Elastic Beanstalk proporciona una configuración de nginx predeterminada que puede ampliar o anular por completo con su propia configuración.

De forma predeterminada, Elastic Beanstalk configura el proxy nginx para reenviar las solicitudes a la aplicación en el puerto 5000. Puede invalidar el puerto predeterminado estableciendo la [propiedad del entorno](java-se-platform.md#java-se-options) `PORT` en el puerto en el que desea que la aplicación principal esté a la escucha.

**nota**  
El puerto en que su aplicación está a la escucha no afecta al puerto en el que el servidor nginx está a la escucha para recibir las solicitudes del equilibrador de carga.

**Configuración del servidor proxy en la versión de su plataforma**  
Todas las AL2 plataformas AL2 023/ admiten una función de configuración de proxy uniforme. Para obtener más información sobre la configuración del servidor proxy en las versiones de su plataforma que ejecutan AL2 AL2 023/, consulte. [Configuración del proxy inverso](platforms-linux-extend.proxy.md) 

## Configuración del proxy en la AMI de Amazon Linux (anterior a Amazon Linux 2)
<a name="java-se-nginx.alami"></a>

Si su entorno Java SE de Elastic Beanstalk utiliza una versión de la plataforma de la AMI de Amazon Linux (anterior a Amazon Linux 2), lea la información adicional de esta sección.

**Notas**  
La información de este tema solo se aplica a las ramas de plataforma basadas en la AMI de Amazon Linux (AL1). AL2Las ramas de la AL2 plataforma 023/ no son compatibles con las versiones anteriores de la plataforma AMI (AL1) de Amazon Linux y *requieren ajustes de configuración diferentes*.
 [El 18 de julio de 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk estableció el estado de todas las ramas de plataforma basadas en la AMI AL1 de Amazon Linux () como retiradas.** Para obtener más información sobre la migración a una ramificación de la plataforma Amazon Linux 2023 actual y totalmente compatible, consulte [Migración de su aplicación de Linux de Elastic Beanstalk a Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).

### Ampliación y anulación de la configuración de proxy predeterminada: AMI de Amazon Linux () AL1
<a name="java-se-nginx.alami.extending"></a>

Para ampliar la configuración predeterminada de nginx de Elastic Beanstalk, añada los archivos de configuración `.conf` a una carpeta con el nombre `.ebextensions/nginx/conf.d/` en el paquete de código fuente de su aplicación. La configuración de nginx de Elastic Beanstalk incluye archivos `.conf` en esta carpeta automáticamente.

```
~/workspace/my-app/
|-- .ebextensions
|   `-- nginx
|       `-- conf.d
|           `-- myconf.conf
`-- web.jar
```

Para anular por completo la configuración de nginx predeterminada de Elastic Beanstalk, incluya una configuración en el paquete de código fuente en `.ebextensions/nginx/nginx.conf`:

```
~/workspace/my-app/
|-- .ebextensions
|   `-- nginx
|       `-- nginx.conf
`-- web.jar
```

Si anula la configuración de nginx de Elastic Beanstalk, agregue la siguiente línea a su `nginx.conf` para extraer las configuraciones de Elastic Beanstalk de [Informes y monitoreo de estado mejorados de Elastic Beanstalk](health-enhanced.md), los mapeos automáticos de la aplicación y los archivos estáticos.

```
 include conf.d/elasticbeanstalk/*.conf;
```

La siguiente configuración de ejemplo de la [aplicación de muestra Scorekeep](https://github.com/aws-samples/eb-java-scorekeep/) sustituye la configuración predeterminada de Elastic Beanstalk para servir una aplicación web estática desde el subdirectorio `public` de `/var/app/current`, donde la plataforma Java SE copia el código fuente de la aplicación. La ubicación `/api` reenvía el tráfico a las rutas en `/api/` a la aplicación Sprint que escucha en el puerto 5000. La aplicación web sirve el resto del tráfico en la ruta raíz.

**Example**  

```
user                    nginx;
error_log               /var/log/nginx/error.log warn;
pid                     /var/run/nginx.pid;
worker_processes        auto;
worker_rlimit_nofile    33282;

events {
    worker_connections  1024;
}

http {
  include       /etc/nginx/mime.types;
  default_type  application/octet-stream;

  log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                    '$status $body_bytes_sent "$http_referer" '
                    '"$http_user_agent" "$http_x_forwarded_for"';

  include       conf.d/*.conf;

  map $http_upgrade $connection_upgrade {
      default     "upgrade";
  }

  server {
      listen        80 default_server;
      root /var/app/current/public;

      location / {
      }git pull
      

      location /api {
          proxy_pass          http://127.0.0.1:5000;
          proxy_http_version  1.1;

          proxy_set_header    Connection          $connection_upgrade;
          proxy_set_header    Upgrade             $http_upgrade;
          proxy_set_header    Host                $host;
          proxy_set_header    X-Real-IP           $remote_addr;
          proxy_set_header    X-Forwarded-For     $proxy_add_x_forwarded_for;
      }

      access_log    /var/log/nginx/access.log main;

      client_header_timeout 60;
      client_body_timeout   60;
      keepalive_timeout     60;
      gzip                  off;
      gzip_comp_level       4;

      # Include the Elastic Beanstalk generated locations
      include conf.d/elasticbeanstalk/01_static.conf;
      include conf.d/elasticbeanstalk/healthd.conf;
  }
}
```

# Adición de una instancia de base de datos de Amazon RDS a su entorno de Java Elastic Beanstalk
<a name="java-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 los datos recopilados y modificados por la aplicación. La base de datos se puede adjuntar al entorno y administrarse con Elastic Beanstalk, o bien, crearse y administrarse de forma externa.

Si es la primera vez que utiliza Amazon RDS, añada una instancia de base de datos a un entorno de prueba con la consola de Elastic Beanstalk y verifique que su aplicación puede conectarse a ella. 

**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 cómo configurar una instancia de base de datos interna, consulte [Añadir una base de datos al entorno de Elastic Beanstalk](using-features.managing.db.md). Para obtener instrucciones sobre cómo configurar una base de datos externa para usarla con Elastic Beanstalk, consulte [Uso de Elastic Beanstalk con Amazon RDS](AWSHowTo.RDS.md).

Para conectarse a la base de datos, añada el archivo JAR del controlador correspondiente a su aplicación, cargue la clase del controlador en el código y cree un objeto de conexión con las propiedades de entorno proporcionadas por Elastic Beanstalk.

**Topics**
+ [

## Descargar el controlador JDBC
](#java-rds-drivers)
+ [

## Conexión a una base de datos (plataformas Java SE)
](#java-rds-javase)
+ [

## Conexión a una base de datos (plataformas Tomcat)
](#java-rds-tomcat)
+ [

## Resolución de problemas de conexión a la base de datos
](#create_deploy_Java.rds.troubleshooting)

## Descargar el controlador JDBC
<a name="java-rds-drivers"></a>

Necesitará el archivo JAR del controlador JDBC para el motor de base de datos que elija. Guarde el archivo JAR en su código fuente e inclúyalo en su classpath cuando compile la clase que crea las conexiones a la base de datos.

Puede encontrar el controlador más reciente para su motor de base de datos en las siguientes ubicaciones:
+ **MySQL**: [MySQL Connector/J](https://dev.mysql.com/downloads/connector/j/)
+ **Oracle SE-1**: [controlador JDBC de Oracle](http://www.oracle.com/technetwork/database/features/jdbc/index-091264.html)
+ **Postgres**: [controlador JDBC de Postgres](https://jdbc.postgresql.org/)
+ **SQL Server**: [controlador JDBC de Microsoft](https://msdn.microsoft.com/en-us/sqlserver/aa937724.aspx)

Para utilizar el controlador JDBC, llame a `Class.forName()` para cargarlo antes de crear la conexión con `DriverManager.getConnection()` en su código.

JDBC utiliza una cadena de conexión con el siguiente formato:

```
jdbc:driver://hostname:port/dbName?user=userName&password=password
```

Puede recuperar el nombre de host, el puerto, el nombre de la base de datos, el nombre de usuario y la contraseña desde las variables de entorno que Elastic Beanstalk proporciona a la aplicación. El nombre del controlador es específico del tipo de base de datos y de la versión del controlador. A continuación se muestran algunos nombres de controlador de ejemplo:
+ `mysql` para MySQL
+ `postgresql` para PostgreSQL
+ `oracle:thin` para Oracle Thin
+ `oracle:oci` para Oracle OCI
+ `oracle:oci8` para Oracle OCI 8
+ `oracle:kprb` para Oracle KPRB
+ `sqlserver` para SQL Server

## Conexión a una base de datos (plataformas Java SE)
<a name="java-rds-javase"></a>

En un entorno de Java SE, use `System.getenv()` para leer las variables de conexión del entorno. El siguiente código de ejemplo muestra una clase que crea una conexión a una base de datos PostgreSQL.

```
private static Connection getRemoteConnection() {
    if (System.getenv("RDS_HOSTNAME") != null) {
      try {
      Class.forName("org.postgresql.Driver");
      String dbName = System.getenv("RDS_DB_NAME");
      String userName = System.getenv("RDS_USERNAME");
      String password = System.getenv("RDS_PASSWORD");
      String hostname = System.getenv("RDS_HOSTNAME");
      String port = System.getenv("RDS_PORT");
      String jdbcUrl = "jdbc:postgresql://" + hostname + ":" + port + "/" + dbName + "?user=" + userName + "&password=" + password;
      logger.trace("Getting remote connection with connection string from environment variables.");
      Connection con = DriverManager.getConnection(jdbcUrl);
      logger.info("Remote connection successful.");
      return con;
    }
    catch (ClassNotFoundException e) { logger.warn(e.toString());}
    catch (SQLException e) { logger.warn(e.toString());}
    }
    return null;
  }
```

## Conexión a una base de datos (plataformas Tomcat)
<a name="java-rds-tomcat"></a>

En un entorno Tomcat, las propiedades de entorno se proporcionan como propiedades del sistema accesibles con `System.getProperty()`.

El siguiente código de ejemplo muestra una clase que crea una conexión a una base de datos PostgreSQL.

```
private static Connection getRemoteConnection() {
    if (System.getProperty("RDS_HOSTNAME") != null) {
      try {
      Class.forName("org.postgresql.Driver");
      String dbName = System.getProperty("RDS_DB_NAME");
      String userName = System.getProperty("RDS_USERNAME");
      String password = System.getProperty("RDS_PASSWORD");
      String hostname = System.getProperty("RDS_HOSTNAME");
      String port = System.getProperty("RDS_PORT");
      String jdbcUrl = "jdbc:postgresql://" + hostname + ":" + port + "/" + dbName + "?user=" + userName + "&password=" + password;
      logger.trace("Getting remote connection with connection string from environment variables.");
      Connection con = DriverManager.getConnection(jdbcUrl);
      logger.info("Remote connection successful.");
      return con;
    }
    catch (ClassNotFoundException e) { logger.warn(e.toString());}
    catch (SQLException e) { logger.warn(e.toString());}
    }
    return null;
  }
```

Si tiene problemas para obtener una conexión o ejecutar instrucciones SQL, pruebe a colocar el siguiente código en un archivo JSP. Este código establece una conexión con una instancia de base de datos, crea una tabla y escribe en ella.

```
<%@ page import="java.sql.*" %>
<%
  // Read RDS connection information from the environment
  String dbName = System.getProperty("RDS_DB_NAME");
  String userName = System.getProperty("RDS_USERNAME");
  String password = System.getProperty("RDS_PASSWORD");
  String hostname = System.getProperty("RDS_HOSTNAME");
  String port = System.getProperty("RDS_PORT");
  String jdbcUrl = "jdbc:mysql://" + hostname + ":" +
    port + "/" + dbName + "?user=" + userName + "&password=" + password;
  
  // Load the JDBC driver
  try {
    System.out.println("Loading driver...");
    Class.forName("com.mysql.jdbc.Driver");
    System.out.println("Driver loaded!");
  } catch (ClassNotFoundException e) {
    throw new RuntimeException("Cannot find the driver in the classpath!", e);
  }

  Connection conn = null;
  Statement setupStatement = null;
  Statement readStatement = null;
  ResultSet resultSet = null;
  String results = "";
  int numresults = 0;
  String statement = null;

  try {
    // Create connection to RDS DB instance
    conn = DriverManager.getConnection(jdbcUrl);
    
    // Create a table and write two rows
    setupStatement = conn.createStatement();
    String createTable = "CREATE TABLE Beanstalk (Resource char(50));";
    String insertRow1 = "INSERT INTO Beanstalk (Resource) VALUES ('EC2 Instance');";
    String insertRow2 = "INSERT INTO Beanstalk (Resource) VALUES ('RDS Instance');";
    
    setupStatement.addBatch(createTable);
    setupStatement.addBatch(insertRow1);
    setupStatement.addBatch(insertRow2);
    setupStatement.executeBatch();
    setupStatement.close();
    
  } catch (SQLException ex) {
    // Handle any errors
    System.out.println("SQLException: " + ex.getMessage());
    System.out.println("SQLState: " + ex.getSQLState());
    System.out.println("VendorError: " + ex.getErrorCode());
  } finally {
    System.out.println("Closing the connection.");
    if (conn != null) try { conn.close(); } catch (SQLException ignore) {}
  }

  try {
    conn = DriverManager.getConnection(jdbcUrl);
    
    readStatement = conn.createStatement();
    resultSet = readStatement.executeQuery("SELECT Resource FROM Beanstalk;");

    resultSet.first();
    results = resultSet.getString("Resource");
    resultSet.next();
    results += ", " + resultSet.getString("Resource");
    
    resultSet.close();
    readStatement.close();
    conn.close();

  } catch (SQLException ex) {
    // Handle any errors
    System.out.println("SQLException: " + ex.getMessage());
    System.out.println("SQLState: " + ex.getSQLState());
    System.out.println("VendorError: " + ex.getErrorCode());
  } finally {
       System.out.println("Closing the connection.");
      if (conn != null) try { conn.close(); } catch (SQLException ignore) {}
  }
%>
```

Para mostrar los resultados, coloque el siguiente código en el cuerpo de la parte HTML del archivo JSP.

```
<p>Established connection to RDS. Read first two rows: <%= results %></p>
```

## Resolución de problemas de conexión a la base de datos
<a name="create_deploy_Java.rds.troubleshooting"></a>

**Pruebe la CLI de Amazon Q Developer para solucionar problemas con ayuda de la IA**  
 La CLI de Amazon Q Developer puede ayudarle a solucionar rápidamente los problemas de entorno. La CLI de Q permite solucionar problemas comprobando el estado del entorno, revisando eventos, analizando registros y formulando preguntas aclaratorias. Para obtener más información y tutoriales detallados, consulte [Solución de problemas de entornos de Elastic Beanstalk con Amazon](https://aws.amazon.com/blogs/devops/troubleshooting-elastic-beanstalk-environments-with-amazon-q-developer-cli/) Q Developer CLI en los blogs. AWS 

Si surgen problemas al conectarse a una base de datos desde la aplicación, examine el archivo log del contenedor web y la base de datos.

### Consulta de logs
<a name="create_deploy_Java.rds.troubleshooting.logs"></a>

Puede ver todos los registros de su entorno de Elastic Beanstalk desde Eclipse. **Si no tiene abierta la vista del AWS explorador, elija la flecha situada junto al AWS icono naranja de la barra de herramientas y, a continuación, elija Mostrar vista del explorador. AWS ** Expanda **AWS Elastic Beanstalk** y el nombre de su entorno y, a continuación, abra el menú contextual (haga clic con el botón derecho) del servidor. Elija **Open in WTP Server Editor (Abrir en el editor del servidor de WTP)**. 

 Elija la pestaña **Log (Registro)** de la vista **Server (Servidor)** para ver los registros acumulados de su entorno. Para abrir los últimos registros, seleccione el botón **Refresh (Actualización de)** en la esquina superior derecha de la página. 

 Desplácese hacia abajo para localizar los logs de Tomcat en `/var/log/tomcat7/catalina.out`. Si ha cargado la página web desde nuestro ejemplo anterior varias veces, es posible que vea lo siguiente. 

```
-------------------------------------
/var/log/tomcat7/catalina.out
-------------------------------------
INFO: Server startup in 9285 ms
Loading driver...
Driver loaded!
SQLException: Table 'Beanstalk' already exists
SQLState: 42S01
VendorError: 1050
Closing the connection.
Closing the connection.
```

Toda la información que la aplicación web envía a la salida estándar aparece en el log del contenedor web. En el ejemplo anterior, la aplicación intenta crear la tabla cada vez que se carga la página. Esto produce una excepción SQL en cada carga de página después de la primera. 

Esto es aceptable porque se trata de un ejemplo. Pero en las aplicaciones reales mantenga las definiciones de base de datos en objetos del esquema, realice las transacciones desde las clases del modelo y coordine las solicitudes con servlets de controlador.

### Conexión a una instancia de base de datos de RDS
<a name="create_deploy_Java.rds.troubleshooting.connecting"></a>

 Puede conectarse directamente a la instancia de base de datos de RDS en su entorno de Elastic Beanstalk usando la aplicación cliente de MySQL. 

 En primer lugar, abra el grupo de seguridad en su instancia de base de datos de RDS para permitir el tráfico desde su equipo. 

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. Junto a **Endpoint (Punto de conexión)**, elija el enlace de la consola de Amazon RDS.

1. En la página de detalles de la instancia de **RDS Dashboard (Panel RDS)**, bajo **Security and Network (Seguridad y red)**, elija el grupo de seguridad que empieza por *rds-* situado junto a **Security Groups (Grupos de seguridad)**.
**nota**  
La base de datos podría tener varias entradas etiquetadas como **Security Groups (Grupos de seguridad)**. Utilice la primera, que comienza con *awseb*, solo si tiene una cuenta anterior que no dispone de una [Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/) (Amazon VPC) predeterminada.

1. En **Security group details (Detalles del grupo de seguridad)**, elija la pestaña **Inbound (Entrada)** y, a continuación, elija **Edit (Edición de)**.

1. Añada una regla para MySQL (puerto 3306) que permita el tráfico procedente de la dirección IP, especificada en formato CIDR.

1. Seleccione **Save (Guardar)**. Los cambios surtirán efecto de inmediato.

 Consulte de nuevo los datos de configuración de Elastic Beanstalk para el entorno y anote el punto de conexión. Utilizará el nombre de dominio para conectarse a la instancia de base de datos de RDS. 

 Instale el cliente de MySQL e inicie una conexión con la base de datos en el puerto 3306. En Windows, instale MySQL Workbench desde la página de inicio de MySQL y siga las instrucciones. 

 En Linux, instale el cliente de MySQL con el administrador de paquetes de su distribución. El siguiente ejemplo funciona en Ubuntu y otros derivados de Debian. 

```
// Install MySQL client
$ sudo apt-get install mysql-client-5.5
...
// Connect to database
$ mysql -h aas839jo2vwhwb.cnubrrfwfka8.us-west-2.rds.amazonaws.com -u username -ppassword ebdb
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 117
Server version: 5.5.40-log Source distribution
...
```

Una vez que se haya conectado, puede ejecutar comandos SQL para ver el estado de la base de datos, si se crearon las tablas y las filas y otra información. 

```
mysql> SELECT Resource from Beanstalk;
+--------------+
| Resource     |
+--------------+
| EC2 Instance |
| RDS Instance |
+--------------+
2 rows in set (0.01 sec)
```

# Herramientas y recursos de Java
<a name="create_deploy_Java.resources"></a>

Existen varios lugares a los que puede acudir para obtener ayuda adicional con el desarrollo de las aplicaciones Java.


****  

|  Recurso  |  Description (Descripción)  | 
| --- | --- | 
|  [El foro de desarrollo de AWS Java](https://forums.aws.amazon.com/forum.jspa?forumID=70)  | Publique sus preguntas y obtenga comentarios.  | 
|  [Centro de desarrolladores de Java](https://aws.amazon.com/java/)  | Un único lugar para obtener código de ejemplo, documentación, herramientas y recursos adicionales. |