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. # GlassFish Contenedores Docker preconfigurados en Elastic Beanstalk **nota** [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). Ya no se admite la rama de GlassFish plataforma Docker preconfigurada que se ejecuta en la AMI de Amazon Linux (AL1). Para migrar su GlassFish aplicación a una plataforma Amazon Linux 2023 compatible, despliegue GlassFish y el código de la aplicación en una imagen de Docker de Amazon Linux 2023. Para obtener más información, consulte el siguiente tema, [Implementación de una GlassFish aplicación en la plataforma Docker: una ruta de migración a Amazon Linux 2023](#docker-glassfish-tutorial). ## Introducción a los contenedores de Docker preconfigurados en la AMI de Amazon Linux (precede a Amazon Linux 2) En esta sección se muestra cómo desarrollar una aplicación de muestra localmente e implementarla después en Elastic Beanstalk con un contenedor Docker preconfigurado. ### Configuración de su entorno de desarrollo local Para este tutorial, utilizamos una GlassFish aplicación de ejemplo. **Para configurar el entorno** 1. Cree una nueva carpeta para la aplicación de muestra. ``` ~$ mkdir eb-preconf-example ~$ cd eb-preconf-example ``` 1. Descargue el código de la aplicación de muestra en la nueva carpeta. ``` ~$ wget https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/samples/docker-glassfish-v1.zip ~$ unzip docker-glassfish-v1.zip ~$ rm docker-glassfish-v1.zip ``` ### Desarrollar y probar la aplicación localmente **Para desarrollar una aplicación de ejemplo GlassFish** 1. Añada un `Dockerfile` en la carpeta raíz de la aplicación. En el archivo, especifique la imagen base de AWS Elastic Beanstalk Docker que se utilizará para ejecutar su contenedor Docker local preconfigurado. Más adelante, implementará la aplicación en una versión de plataforma Docker preconfigurada de Elastic GlassFish Beanstalk. Elija la imagen base de Docker que utiliza esta versión de la plataforma. Para averiguar la imagen de Docker actual de la versión de la plataforma, consulte la sección [Docker preconfigurado](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.dockerpreconfig) de la página *Plataformas compatibles con AWS Elastic Beanstalk * en la guía de *AWS Elastic Beanstalk Platforms*. **Example b-preconf-example\~/E /Dockerfile** ``` # For Glassfish 5.0 Java 8 FROM amazon/aws-eb-glassfish:5.0-al-onbuild-2.11.1 ``` Para obtener más información sobre cómo usar un `Dockerfile`, consulte [Preparación de la imagen de Docker para implementarla en Elastic Beanstalk](single-container-docker-configuration.md). 1. Cree la imagen de Docker. ``` ~/eb-preconf-example$ docker build -t my-app-image . ``` 1. Ejecute el contenedor Docker desde la imagen. **nota** Debe incluir la marca `-p` para asignar el puerto 8080 del contenedor al puerto 3000 del host local. Los contenedores Docker de Elastic Beanstalk siempre exponen la aplicación en el puerto 8080 del contenedor. Las marcas `-it` ejecutan la imagen como un proceso interactivo. La marca `--rm` limpia el sistema de archivos del contenedor cuando el contenedor existe. De forma opcional, puede incluir una marca `-d` para ejecutar la imagen como un daemon. ``` $ docker run -it --rm -p 3000:8080 my-app-image ``` 1. Para ver la aplicación de muestra, escriba la siguiente URL en el navegador web. ``` http://localhost:3000 ``` ![La aplicación de GlassFish ejemplo que se muestra en un navegador web](http://docs.aws.amazon.com/es_es/elasticbeanstalk/latest/dg/images/dockerpreconfig-webpage.png) ### Implementar en Elastic Beanstalk Después de probar la aplicación, ya puede implementarla en Elastic Beanstalk. **Para implementar su aplicación en Elastic Beanstalk** 1. En la carpeta raíz de la aplicación, cambie el nombre de `Dockerfile` a `Dockerfile.local`. Este paso es necesario para que Elastic Beanstalk utilice el `Dockerfile` que contiene las instrucciones correctas para que Elastic Beanstalk cree una imagen personalizada de Docker en cada instancia de Amazon EC2 en su entorno de Elastic Beanstalk. **nota** No es necesario realizar este paso si su `Dockerfile` incluye instrucciones que modifican la imagen de Docker base de la versión de la plataforma. No necesita usar un `Dockerfile` en absoluto si su `Dockerfile` incluye solo una línea `FROM` para especificar la imagen base desde la que se crea el contenedor. En tal caso, el `Dockerfile` es redundante. 1. Cree el paquete de código fuente de la aplicación. ``` ~/eb-preconf-example$ zip myapp.zip -r * ``` 1. [Abra la consola de Elastic Beanstalk con este enlace preconfigurado: console.aws.amazon. com/elasticbeanstalk/home\#/newApplication? ApplicationName=Tutorials&EnvironmentType= LoadBalanced](https://console.aws.amazon.com/elasticbeanstalk/home#/newApplication?applicationName=tutorials&environmentType=LoadBalanced) 1. En **Platform (Plataforma)**, en **Preconfigured Docker (Docker preconfigurado)**, elija **Glassfish**. 1. En **Código de la aplicación**, seleccione **Cargar su propio código** y, luego, **Cargar**. 1. Elija **Local file (Archivo local)**, seleccione **Browse (Examinar)** y abra el paquete de código fuente de la aplicación que acaba de crear. 1. Seleccione **Upload**. 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)**. 1. Cuando se crea el entorno, puede ver la aplicación implementada. Elija la URL del entorno que se muestra en la parte superior del panel de la consola. ## Implementación de una GlassFish aplicación en la plataforma Docker: una ruta de migración a Amazon Linux 2023 El objetivo de este tutorial es proporcionar a los clientes que utilizan la GlassFish plataforma Docker preconfigurada (basada en la AMI de Amazon Linux) una ruta de migración a Amazon Linux 2023. Puede migrar su GlassFish aplicación a Amazon Linux 2023 mediante la implementación GlassFish y el código de la aplicación a una imagen de Docker de Amazon Linux 2023. El tutorial explica el uso de la plataforma AWS Elastic Beanstalk Docker para implementar una aplicación basada en el [servidor de aplicaciones Java EE en un GlassFish entorno](https://www.oracle.com/middleware/technologies/glassfish-server.html) de Elastic Beanstalk. Demostramos dos enfoques para construir una imagen de Docker: + **Sencillo**: proporciona el código fuente de GlassFish la aplicación y deja que Elastic Beanstalk cree y ejecute una imagen de Docker como parte del aprovisionamiento del entorno. Esto es fácil de configurar, a costa de un mayor tiempo de aprovisionamiento de instancias. + **Avanzado**: cree una imagen de Docker personalizada que contenga el código de la aplicación y las dependencias, y proporciónela a Elastic Beanstalk para usarla en su entorno. Este enfoque es un poco más complejo y reduce el tiempo de aprovisionamiento de las instancias en su entorno. ### Requisitos previos En este tutorial, se da por sentado que usted posee algunos conocimientos sobre las operaciones básicas de la interfaz de la línea de comandos de Elastic Beanstalk (CLI de EB) y Docker. Si aún no lo ha hecho, siga las instrucciones que se indican en [Cómo empezar a utilizar Elastic Beanstalk](GettingStarted.md) para lanzar su primer entorno de Elastic Beanstalk. En este tutorial se utiliza la [CLI de EB](eb-cli3.md), pero también puede crear entornos y cargar aplicaciones mediante la consola de Elastic Beanstalk. Para realizar este tutorial, también necesitará los siguientes componentes de Docker: + Una instalación local activa de Docker. Para obtener más información, consulte [Descripción de Docker](https://docs.docker.com/install/) en la página de documentos de Docker. + Acceso a Docker Hub. Deberá crear un ID de Docker para poder acceder a Docker Hub. Para obtener más información, consulte [Compartir la aplicación](https://docs.docker.com/get-started/04_sharing_app/) en la página de documentos de Docker. Para obtener más información acerca de la configuración de los entornos Docker en las plataformas Elastic Beanstalk, consulte [Preparación de la imagen de Docker para implementarla en Elastic Beanstalk](single-container-docker-configuration.md) en este mismo capítulo. ### Ejemplo sencillo: proporcione su código de aplicación Esta es una forma sencilla de implementar la aplicación. GlassFish Proporciona el código fuente de la aplicación junto con el `Dockerfile` incluido en este tutorial. Elastic Beanstalk crea una imagen de Docker que incluye la aplicación y la pila de software. GlassFish A continuación, Elastic Beanstalk ejecuta la imagen en las instancias de su entorno. Un problema de este enfoque es que Elastic Beanstalk crea la imagen de Docker localmente cada vez que crea una instancia para su entorno. La creación de la imagen aumenta el tiempo de aprovisionamiento de instancias. Este impacto no se limita a la creación inicial del entorno, sino que también ocurre durante las acciones de escalado ascendente. **Para lanzar un entorno con una aplicación de ejemplo GlassFish** 1. Descargue el `docker-glassfish-al2-v1.zip` de ejemplo y, a continuación, expanda el archivo `.zip` en un directorio del entorno de desarrollo. ``` ~$ curl https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/samples/docker-glassfish-al2-v1.zip --output docker-glassfish-al2-v1.zip ~$ mkdir glassfish-example ~$ cd glassfish-example ~/glassfish-example$ unzip ../docker-glassfish-al2-v1.zip ``` La estructura de directorios debe ser similar a la siguiente. ``` ~/glassfish-example |-- Dockerfile |-- Dockerrun.aws.json |-- glassfish-start.sh |-- index.jsp |-- META-INF | |-- LICENSE.txt | |-- MANIFEST.MF | `-- NOTICE.txt |-- robots.txt `-- WEB-INF `-- web.xml ``` Los siguientes archivos son clave para crear y ejecutar un contenedor de Docker en su entorno: + `Dockerfile`: proporciona instrucciones que Docker utiliza para crear una imagen con la aplicación y las dependencias requeridas. + `glassfish-start.sh`: un script de shell que ejecuta la imagen de Docker para iniciar la aplicación. + `Dockerrun.aws.json`— Proporciona una clave de registro para incluir las GlassFish [solicitudes del archivo](using-features.logging.md) de registro del servidor de aplicaciones. Si no le interesan GlassFish los registros, puede omitir este archivo. 1. Configure el directorio local para su implementación en Elastic Beanstalk. ``` ~/glassfish-example$ eb init -p docker {{glassfish-example}} ``` 1. (Opcional) Utilice el comando **eb local run** para crear y ejecutar el contenedor de forma local. ``` ~/glassfish-example$ eb local run --port 8080 ``` **nota** Para obtener más información acerca del comando **eb local**, consulte [**eb local**](eb3-local.md). El comando no es compatible con Windows. Si lo prefiere, puede crear y ejecutar el contenedor con los comandos **docker build** y **docker run**. Para obtener más información, consulte la [documentación de Docker](https://docs.docker.com/). 1. (Opcional) Aunque el contenedor se está ejecutando, utilice el comando **eb local open** para ver la aplicación en un navegador web. Si lo prefiere, abra [http://localhost:8080/](http://localhost:8080/) en un navegador web. ``` ~/glassfish-example$ eb local open ``` 1. Use el comando **eb create** para crear un entorno e implementar su aplicación. ``` ~/glassfish-example$ eb create {{glassfish-example-env}} ``` 1. Una vez que se lanza el entorno, utilice el comando **eb open** para verlo en un explorador Web. ``` ~/glassfish-example$ eb open ``` Cuando termine de trabajar con el ejemplo, termine el entorno y elimine los recursos relacionados. ``` ~/glassfish-example$ eb terminate --all ``` ### Ejemplo avanzado: proporcione una imagen de Docker predefinida Esta es una forma más avanzada de implementar la GlassFish aplicación. A partir del primer ejemplo, se crea una imagen de Docker que contiene el código de la aplicación y la pila de GlassFish software, y se envía a Docker Hub. Después de realizar este paso único, puede lanzar entornos de Elastic Beanstalk basados en la imagen personalizada. Cuando lanza un entorno y proporciona la imagen de Docker, las instancias del entorno descargan y usan esta imagen directamente y no necesitan crear una imagen de Docker. Por lo tanto, se reduce el tiempo de aprovisionamiento de instancias. **Notas** Los siguientes pasos crearán una imagen de Docker disponible públicamente. Utilizará los comandos Docker de su instalación local de Docker, junto con las credenciales de Docker Hub. Para obtener más información, consulte la sección *Requisitos previos* más adelante en este tema. **Para lanzar un entorno con una imagen de Docker de una aplicación prediseñada GlassFish** 1. Descargue y expanda el ejemplo `docker-glassfish-al2-v1.zip` como en el [ejemplo sencillo](#docker-glassfish-tutorial.simple) anterior. Si ha completado dicho ejemplo, puede usar el directorio que ya tiene. 1. Cree una imagen de Docker y envíela a Docker Hub. Introduzca su ID de Docker para {{docker-id}} iniciar sesión en Docker Hub. ``` ~/glassfish-example$ docker build -t {{docker-id}}/beanstalk-glassfish-example:latest . ~/glassfish-example$ docker push {{docker-id}}/beanstalk-glassfish-example:latest ``` **nota** Antes de enviar la imagen, es posible que deba ejecutar **docker login**. Se le pedirán las credenciales de Docker Hub si ejecuta el comando sin parámetros. 1. Cree un directorio adicional. ``` ~$ mkdir glassfish-prebuilt ~$ cd glassfish-prebuilt ``` 1. Copie el siguiente ejemplo en un archivo denominado `Dockerrun.aws.json`. **Example `~/glassfish-prebuilt/Dockerrun.aws.json`** ``` { "AWSEBDockerrunVersion": "1", "Image": { "Name": "{{docker-username}}/beanstalk-glassfish-example" }, "Ports": [ { "ContainerPort": 8080, "HostPort": 8080 } ], "Logging": "/usr/local/glassfish5/glassfish/domains/domain1/logs" } ``` 1. Configure el directorio local para su implementación en Elastic Beanstalk. ``` ~/glassfish-prebuilt$ eb init -p docker {{glassfish-prebuilt$}} ``` 1. (Opcional) Utilice el comando **eb local run** para ejecutar el contenedor localmente. ``` ~/glassfish-prebuilt$ eb local run --port 8080 ``` 1. (Opcional) Aunque el contenedor se está ejecutando, utilice el comando **eb local open** para ver la aplicación en un navegador web. Si lo prefiere, abra [http://localhost:8080/](http://localhost:8080/) en un navegador web. ``` ~/glassfish-prebuilt$ eb local open ``` 1. Utilice el comando **eb create** para crear un entorno e implementar la imagen de Docker. ``` ~/glassfish-prebuilt$ eb create {{glassfish-prebuilt-env}} ``` 1. Una vez que se lanza el entorno, utilice el comando **eb open** para verlo en un explorador Web. ``` ~/glassfish-prebuilt$ eb open ``` Cuando termine de trabajar con el ejemplo, termine el entorno y elimine los recursos relacionados. ``` ~/glassfish-prebuilt$ eb terminate --all ```