Crear una pila y ejecutar una aplicación

importante

La AWS OpsWorks Stacks El servicio llegó al final de su vida útil el 26 de mayo de 2024 y se ha desactivado tanto para los clientes nuevos como para los existentes. Recomendamos encarecidamente a los clientes que migren sus cargas de trabajo a otras soluciones lo antes posible. Si tiene preguntas sobre la migración, póngase en contacto con el AWS Support Equipo en AWS Re:post o mediante AWS Premium Support.

En esta sección se muestra cómo utilizar el recetario de Tomcat para implementar una configuración de pila básica que ejecute una sencilla aplicación Java server pages (JSP) denominada Simple. JSP La pila consta de una capa personalizada basada en Tomcat denominada TomCustom y una capa llamada Mi capa. SQL Simple JSP se despliega en la TomCustom base de datos My SQL y muestra cierta información de ella. Si aún no está familiarizado con los conceptos básicos de uso AWS OpsWorks Stacks, primero deberías leerIntroducción a las pilas de Linux en Chef 11.

La aplicación simple JSP

La JSP aplicación Simple muestra los conceptos básicos de cómo configurar una conexión a una base de datos y recuperar datos de la SQL base de datos My de la pila.



<html>
  <head>
    <title>DB Access</title>
  </head>
  <body>
    <%@ page language="java" import="java.sql.*,javax.naming.*,javax.sql.*" %>
    <%
      StringBuffer output = new StringBuffer();
      DataSource ds = null;
      Connection con = null;
      Statement stmt = null;
      ResultSet rs = null;
      try {
        Context initCtx = new InitialContext();
        ds = (DataSource) initCtx.lookup("java:comp/env/jdbc/mydb");
        con = ds.getConnection();
        output.append("Databases found:<br>");
        stmt = con.createStatement();
        rs = stmt.executeQuery("show databases");
        while (rs.next()) {
          output.append(rs.getString(1));
          output.append("<br>");
        }
      }
      catch (Exception e) {
        output.append("Exception: ");
        output.append(e.getMessage());
        output.append("<br>");
      }
      finally {
        try {
          if (rs != null) {
            rs.close();
          }
          if (stmt != null) {
            stmt.close();
          }
          if (con != null) {
            con.close();
          }
        }
        catch (Exception e) {
          output.append("Exception (during close of connection): ");
          output.append(e.getMessage());
          output.append("<br>");
        }
      }
    %>
    <%= output.toString() %>
  </body>
</html>

Simple JSP utiliza un DataSource objeto para comunicarse con la SQL base de datos My. Tomcat utiliza los datos del archivo de configuración de contexto de la aplicación web para crear e inicializar un objeto DataSource y enlazarlo a un nombre lógico. A continuación, registra el nombre lógico en un servicio de nombres de la Interfaz de Nombres y Directorios de Java (JNDI). Para obtener una instancia del objeto DataSource adecuado, debe crear un objeto InitialContext y pasar el nombre lógico del recurso al método lookup del objeto, que recupera el objeto adecuado. El nombre lógico del JSP ejemplo simple,java:comp/env/jdbc/mydb, tiene los siguientes componentes:

El espacio de nombres raíz, java, que se separa del resto del nombre por medio de dos puntos (:).
Cualquier otro espacio de nombres adicional, separado por barras (/).

Tomcat añade automáticamente recursos al espacio de nombres comp/env.
El nombre del recurso, que se define en el archivo de configuración de contexto de la aplicación web y se separa del espacio de nombres con una barra.

El nombre del recurso en este ejemplo es jdbc/mydb.

Para establecer una conexión a la base de datos, Simple JSP hace lo siguiente:

Abre el método DataSource del objeto getConnection, que devuelve un objeto Connection.
Llama al método Connection del objeto createStatement para crear un objeto Statement, que se utiliza para comunicarse con la base de datos.
Se comunica con la base de datos llamando al método Statement adecuado.

JSPLlamadas sencillas executeQuery para ejecutar una SHOW DATABASES consulta, en la que se enumeran las bases de datos del servidor.

El método executeQuery devuelve un objeto ResultSet, que contiene los resultados de la consulta. Simple JSP obtiene los nombres de las bases de datos del ResultSet objeto devuelto y los concatena para crear una cadena de salida. Por último, el ejemplo cierra los objetos ResultSet, Statement y Connection. Para obtener más información sobre Pages Technology JSP y BasicsJDBC, consulte JavaServer Pages Technology and JDBCBasics, respectivamente.

Para usar Simple JSP con una pila, debes colocarla en un repositorio. Puedes usar cualquiera de los repositorios compatibles, pero para usar Simple JSP con la pila de ejemplo que se describe en la siguiente sección, debes colocarla en un archivo S3 público. Para obtener más información acerca de cómo utilizar el resto de repositorios estándar, consulte Repositorios de libros de recetas.

Para colocar Simple JSP en un repositorio de archivos de S3

Copie el código de ejemplo en un archivo llamado simplejsp.jsp y ponga el archivo en un directorio llamado simplejsp.
Cree un archivo .zip del directorio simplejsp.
Cree un bucket de Amazon S3 público, cargue simplejsp.zip en el bucket y haga el archivo público.

Para obtener una descripción de cómo realizar esta tarea, consulte Comenzar a utilizar Amazon Simple Storage Service.

Crear una pila

Para ejecutar SimpleJSP, necesita una pila con las siguientes capas.

Una SQL capa My, que soporta la parte trasera de My SQL server.
Una capa personalizada que utilice el libro de recetas de Tomcat para admitir las instancias del servidor Tomcat.

Para crear la pila

En el AWS OpsWorks En el panel de control de pilas, haz clic en Añadir pila para crear una pila nueva y haz clic en Avanzado >> para ver todas las opciones. Configure la pila del modo siguiente.
- Nombre: un nombre de pila definido por el usuario; en este ejemplo se utiliza. TomStack
- Usar libros de recetas personalizados de Chef: establezca la alternancia en Sí para mostrar algunas opciones adicionales.
- Tipo de repositorio: Git.
- Repositorio URL —git://github.com/amazonwebservices/opsworks-example-cookbooks.git.
- Custom Chef JSON: agregue lo siguiente: JSON
```
{
  "tomcat": {
    "base_version": 7,
    "java_opts": "-Djava.awt.headless=true -Xmx256m"
  },
  "datasources": {
    "ROOT": "jdbc/mydb"
  }
}
```
Para el resto de opciones, puede aceptar los valores predeterminados.

La costumbre JSON hace lo siguiente:
- Anula el atributo ['base_version'] del libro de recetas de Tomcat para establecer la versión de Tomcat en 7; el valor predeterminado es 6.
- Anula el ['java_opts'] atributo del libro de cocina de Tomcat para especificar que la instancia no tiene encabezado y establece el tamaño JVM máximo del montón en 256 MB; el valor predeterminado no establece ninguna opción para las instancias que ejecutan Amazon Linux.
- Especifica el valor del ['datasources] atributo, que asigna un nombre de JDBC recurso (jdbc/mydb) al nombre de contexto de la aplicación web (), como se describe en. ROOT tomcat::context
  
  Este último atributo no tiene un valor predeterminado; debe configurarlo con custom. JSON
Haga clic en Add a layer (Añadir una capa). En Tipo de capa, seleccione Mi SQL. Después, haga clic en Add Layer (Añadir capa).
Haga clic en Instances (Instancias) en el panel de navegación y, a continuación, haga clic en Add an instance (Añadir una instancia). Haga clic en Add Instance (Añadir una instancia) para aceptar la configuración predeterminada. En la línea de la instancia, haga clic en start (iniciar).
Vuelva a la página Layers (Capas) y haga clic en + Layer (+ Capa) para añadir una capa. En Layer type (Tipo de capa), haga clic en Custom (Personalizado). En el ejemplo se utiliza TomCustom y tomcustom como nombre y nombre abreviado de la capa, respectivamente.
En la página Layers (Capas), para la capa personalizada, haga clic en Recipes (Recetas) y, a continuación, haga clic en Edit (Editar). En Custom Chef Recipes (Recetas Chef personalizadas), asigne las recetas del libro de recetas de Tomcat a los eventos de ciclo de vida de la capa, como se indica a continuación:
- Para Setup (Configurar), escriba tomcat::setup y haga clic en +.
- Para Configura (Configurar), escriba tomcat::configure y haga clic en +.
- Para Deploy, escriba tomcat::deploy y haga clic en +. Después, haga clic en Save (Guardar).
  
  .
Haga clic en Apps (Aplicaciones) en el panel de navegación y, a continuación, haga clic en Add an app (Añadir una aplicación). Especifique las siguientes opciones y, a continuación, haga clic en Add App (Añadir aplicación):
- Nombre: el nombre de la aplicación; en el ejemplo se utiliza Simple JSP y el nombre corto generado por AWS OpsWorks Las pilas serán simplejsp.
- Tipo de app: establezca esta opción en Otro.
  
  AWS OpsWorks Stacks implementa automáticamente los tipos de aplicaciones estándar en las instancias de servidor asociadas. Si estableces el tipo de aplicación en otro, AWS OpsWorks Stacks simplemente ejecuta las recetas de implementación y les permite gestionar la implementación.
- Raíz del documento: establezca esta opción en ROOT.
  
  El valor de Document root (Raíz del documento) especifica el nombre del contexto.
- Tipo de repositorio: establezca esta opción en S3 Archive.
- Repositorio URL: configúrelo en el Amazon S3 de la aplicación URL que creó anteriormente.
Utilice la configuración predeterminada para el resto de las opciones.
Utilice la página Instancias para añadir una instancia a la TomCustom capa e iniciarla. AWS OpsWorks Stacks ejecuta automáticamente las recetas de implementación en una nueva instancia una vez completadas las recetas de configuración, por lo que al iniciar la instancia también se implementa Simple. JSP
Cuando la TomCustom instancia esté en línea, haz clic en el nombre de la instancia en la página Instancias para ver sus detalles. Copie la dirección IP pública. A continuación, URL construya a de la siguiente manera: http://publicIP/tc/appname.jsp. Para el ejemplo, esto URL se verá más o menos asíhttp://50.218.191.172/tc/simplejsp.jsp.

nota
El Apache URL que reenvía las solicitudes a Tomcat tiene el ['tomcat']['apache_tomcat_bind_path'] atributo predeterminado,. /tc/ Se establece la raíz simple JSP del documento, ROOT que es un valor especial que se resuelve en. / Por lo tanto, URL es «... /tc/simplejsp.jsp».
Pegue el fragmento URL del paso anterior en su navegador. Debería ver lo siguiente:
```
Databases found:
information_schema
simplejsp
test
```
nota
Si tu pila tiene una SQL instancia Mi, AWS OpsWorks Stacks crea automáticamente una base de datos para cada aplicación, con el nombre abreviado de la aplicación.