Compartir vía

Configuración de orígenes de datos para una aplicación Tomcat, JBoss o Java SE en Azure App Service

  • Artículo

En este artículo se muestra cómo configurar orígenes de datos en una aplicación Java SE, Tomcat o JBoss en App Service.

Azure App Service ejecuta aplicaciones web Java en un servicio totalmente administrado en tres variantes:

  • Java SE: puede ejecutar una aplicación implementada como un paquete JAR que contenga un servidor incrustado (como Spring Boot, Dropwizard, Quarkus o uno con un servidor de Tomcat o Jetty incrustado).
  • Tomcat: el servidor de Tomcat integrado puede ejecutar una aplicación implementada como un paquete WAR.
  • JBoss EAP: admitido para aplicaciones Linux en los niveles de precios, Premium v3 y Aislado v2. El servidor JBoss EAP integrado puede ejecutar una aplicación implementada como un paquete WAR o EAR.

Nota:

Para las aplicaciones de Spring, se recomienda usar Azure Spring Apps. No obstante, todavía puede usar Azure App Service como destino. Consulte guía de destino de carga de trabajo de Java para obtener consejos.

Configuración del origen de datos

Para conectarse a orígenes de datos en aplicaciones de Spring Boot, se recomienda crear cadenas de conexión e insertarlas en su archivo application.properties.

  1. En la sección "Configuración" de la página de App Service, establezca un nombre para la cadena, pegue la cadena de conexión de JDBC en el campo de valor y establezca el tipo en "Custom" (Personalizado). Opcionalmente, puede establecer esta cadena de conexión como configuración de ranura.

    Nuestra aplicación puede acceder a cadena de conexión como una variable de entorno denominada CUSTOMCONNSTR_<your-string-name>. Por ejemplo, CUSTOMCONNSTR_exampledb.

  2. En su archivo application.properties, haga referencia a esta cadena de conexión con el nombre de variable de entorno. En nuestro ejemplo, se usaría el siguiente código:

    app.datasource.url=${CUSTOMCONNSTR_exampledb}

Para obtener más información, consulte la documentación de Spring Boot relativa al acceso a datos y configuraciones externalizadas .

Sugerencia

De forma predeterminada, los contenedores de Tomcat de Linux pueden configurar automáticamente orígenes de datos compartidos por usted en el servidor de Tomcat. Lo único que debe hacer es agregar una configuración de aplicación que contenga una cadena de conexión JDBC válida a una base de datos Oracle, SQL Server, PostgreSQL o MySQL (incluyendo las credenciales de conexión) y App Service agrega automáticamente la base de datos compartida que corresponde a /usr/local/tomcat/conf/context.xml, mediante un controlador adecuado disponible en el contenedor. Para ver un escenario completo mediante este enfoque, consulte Tutorial: Compilación de una aplicación web de Tomcat con Azure App Service en Linux y MySQL.

Estas instrucciones se aplican a todas las conexiones de base de datos. Debe rellenar los marcadores de posición con el nombre de clase de controlador de la base de datos elegido y con el archivo JAR. Se proporciona una tabla con los nombres de clase y las descargas de controladores de las bases de datos más habituales.

Base de datos Nombre de clase de controlador Controlador JDBC
PostgreSQL org.postgresql.Driver Descargar
MySQL com.mysql.jdbc.Driver Descargar (seleccione "Platform Independent")
SQL Server com.microsoft.sqlserver.jdbc.SQLServerDriver Descargar

Para configurar Tomcat para que use Java Database Connectivity (JDBC) o Java Persistence API (JPA), personalice primero la variable de entorno CATALINA_OPTS que lee Tomcat al iniciarse. Establezca estos valores a través de un valor de la aplicación en el complemento de Maven de App Service:

<appSettings>
    <property>
        <name>CATALINA_OPTS</name>
        <value>"$CATALINA_OPTS -Ddbuser=${DBUSER} -Ddbpassword=${DBPASSWORD} -DconnURL=${CONNURL}"</value>
    </property>
</appSettings>

O bien establezca las variables de entorno en la página Configuración>Configuración de la aplicación de Azure Portal.

A continuación, determine si el origen de datos debe estar disponible para una aplicación o para todas las aplicaciones que se ejecutan en el servlet de Tomcat.

Orígenes de datos de nivel de aplicación

  1. Cree un archivo context.xml en el directorio META-INF / del proyecto. Si el directorio META-INF/ no existe, créelo.

  2. En , context.xml, agregue un elemento Context para vincular el origen de datos a una dirección JNDI. Reemplace el marcador de posición driverClassName por el nombre de clase de su controlador de la tabla anterior.

    <Context>
    <Resource
        name="jdbc/dbconnection"
        type="javax.sql.DataSource"
        url="${connURL}"
        driverClassName="<insert your driver class name>"
        username="${dbuser}"
        password="${dbpassword}"
    />
</Context>

  3. Actualice el archivo web.xml de la aplicación para que use el origen de datos de su aplicación.

    <resource-env-ref>
    <resource-env-ref-name>jdbc/dbconnection</resource-env-ref-name>
    <resource-env-ref-type>javax.sql.DataSource</resource-env-ref-type>
</resource-env-ref>

Recursos de nivel de servidor compartidos

Para agregar un origen de datos compartido de nivel de servidor, es necesario editar el archivo server.xml de Tomcat. La manera más confiable de hacerlo es la siguiente:

  1. Cargue un script de inicio y establezca la ruta de acceso al script en Configuración>Comando de inicio. Puede cargar el script de inicio mediante FTP.

El script de inicio realizará una transformación XSL al archivo server.xml y generará el archivo XML resultante en /usr/local/tomcat/conf/server.xml. El script de inicio debe instalar libxslt a través de APK. El archivo XSL y el script de inicio se pueden cargar a través de FTP. A continuación se muestra un script de inicio de ejemplo.

# Install libxslt. Also copy the transform file to /home/tomcat/conf/
apk add --update libxslt

# Usage: xsltproc --output output.xml style.xsl input.xml
xsltproc --output /home/tomcat/conf/server.xml /home/tomcat/conf/transform.xsl /usr/local/tomcat/conf/server.xml

El siguiente archivo XSL agrega un nuevo nodo de conector al archivo server.xml de Tomcat.

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="xml" indent="yes"/>

  <xsl:template match="@* | node()" name="Copy">
    <xsl:copy>
      <xsl:apply-templates select="@* | node()"/>
    </xsl:copy>
  </xsl:template>

  <xsl:template match="@* | node()" mode="insertConnector">
    <xsl:call-template name="Copy" />
  </xsl:template>

  <xsl:template match="comment()[not(../Connector[@scheme = 'https']) and
                                 contains(., '&lt;Connector') and
                                 (contains(., 'scheme=&quot;https&quot;') or
                                  contains(., &quot;scheme='https'&quot;))]">
    <xsl:value-of select="." disable-output-escaping="yes" />
  </xsl:template>

  <xsl:template match="Service[not(Connector[@scheme = 'https'] or
                                   comment()[contains(., '&lt;Connector') and
                                             (contains(., 'scheme=&quot;https&quot;') or
                                              contains(., &quot;scheme='https'&quot;))]
                                  )]
                      ">
    <xsl:copy>
      <xsl:apply-templates select="@* | node()" mode="insertConnector" />
    </xsl:copy>
  </xsl:template>

  <!-- Add the new connector after the last existing Connector if there's one -->
  <xsl:template match="Connector[last()]" mode="insertConnector">
    <xsl:call-template name="Copy" />

    <xsl:call-template name="AddConnector" />
  </xsl:template>

  <!-- ... or before the first Engine if there's no existing Connector -->
  <xsl:template match="Engine[1][not(preceding-sibling::Connector)]"
                mode="insertConnector">
    <xsl:call-template name="AddConnector" />

    <xsl:call-template name="Copy" />
  </xsl:template>

  <xsl:template name="AddConnector">
    <!-- Add new line -->
    <xsl:text>&#xa;</xsl:text>
    <!-- This is the new connector -->
    <Connector port="8443" protocol="HTTP/1.1" SSLEnabled="true" 
               maxThreads="150" scheme="https" secure="true" 
               keystoreFile="${{user.home}}/.keystore" keystorePass="changeit"
               clientAuth="false" sslProtocol="TLS" />
  </xsl:template>

</xsl:stylesheet>

Finalización de la configuración

Por último, coloque los archivos JAR del controlador en la classpath de Tomcat y reinicie App Service.

  1. Asegúrese de que los archivos del controlador JDBC estén disponibles para el cargador de clases de Tomcat. Para ello, colóquelos en el directorio /home/site/lib. En Cloud Shell, ejecute az webapp deploy --type=lib para cada archivo JAR del controlador:
az webapp deploy --resource-group <group-name> --name <app-name> --src-path <jar-name>.jar --type=lib --path <jar-name>.jar

Si ha creado un origen de datos de nivel de servidor, reinicie la aplicación App Service de Linux. Tomcat restablece CATALINA_BASE a /home/tomcat y usa la configuración actualizada.

Sugerencia

De forma predeterminada, los contenedores de JBoss de Linux pueden configurar automáticamente orígenes de datos compartidos por usted en el servidor de JBoss. Lo único que debe hacer es agregar una configuración de aplicación que contenga una cadena de conexión JDBC válida a una base de datos Oracle, SQL Server, PostgreSQL o MySQL (incluidas las credenciales de conexión) y App Service agrega automáticamente el origen de datos compartido correspondiente, mediante un controlador adecuado disponible en el contenedor. Para ver un escenario completo mediante este enfoque, consulte Tutorial: Compilación de una aplicación web de JBoss con Azure App Service en Linux y MySQL.

Hay tres pasos principales a la hora de registrar un origen de datos con JBoss EAP:

  1. Cargue el controlador JDBC.
  2. Agregue el controlador JDBC como módulo.
  3. Agregue un origen de datos con el módulo.

App Service es un servicio de hospedaje sin estado, por lo que debe colocar estos pasos en un script de inicio y ejecutarlo cada vez que se inicie el contenedor de JBoss. Uso de PostgreSQL, MySQL y SQL Database como ejemplos:

  1. Coloque los comandos de la CLI de JBoss en un archivo denominado jboss-cli-commands.cli. Los comandos de JBoss deben agregar el módulo y registrarlo como un origen de datos. En el ejemplo siguiente se muestran los comandos de la CLI de JBoss para crear un origen de datos postgreSQL con el nombre JNDI java:jboss/datasources/postgresDS.

    module add --name=org.postgresql --resources=/home/site/libs/postgresql-42.7.4.jar
/subsystem=datasources/jdbc-driver=postgresql:add(driver-name="postgresql",driver-module-name="org.postgresql",driver-class-name="org.postgresql.Driver",driver-xa-datasource-class-name="org.postgresql.xa.PGXADataSource")
data-source add --name=postgresql --driver-name="postgresql" --jndi-name="java:jboss/datasources/postgresDS" --connection-url="jdbc:postgresql://\${env.DB_HOST}:5432/postgres" --user-name="\${env.DB_USERNAME}" --password="\${env.DB_PASSWORD}" --enabled=true --use-java-context=true

    Tenga en cuenta que el comando module add usa tres variables de entorno (DB_HOST, DB_USERNAME y DB_PASSWORD), que debe agregar en App Service como configuración de la aplicación. El script los agrega sin la marca --resolve-parameter-values para que JBoss no guarde sus valores en texto no cifrado.

  2. Cree un script de inicio, startup.sh, que llame a los comandos de la CLI de JBoss. En el ejemplo siguiente se muestra cómo llamar a su jboss-cli-commands.cli. Más adelante, configurará App Service para ejecutar este script cuando se inicie el contenedor.

    $JBOSS_HOME/bin/jboss-cli.sh --connect --file=/home/site/scripts/jboss_cli_commands.cli

  3. Con una opción de implementación que prefiera, cargue el controlador JDBC, jboss-cli-commands.cli y startup.sh a las rutas de acceso especificadas en los scripts respectivos. Especialmente, cargue startup.sh como un archivo de inicio. Por ejemplo:

    export RESOURCE_GROUP_NAME=<resource-group-name>
export APP_NAME=<app-name>

# The lib type uploads to /home/site/libs by default.
az webapp deploy --resource-group $RESOURCE_GROUP_NAME --name $APP_NAME --src-path postgresql-42.7.4.jar --target-path postgresql-42.7.4.jar --type lib
az webapp deploy --resource-group $RESOURCE_GROUP_NAME --name $APP_NAME --src-path jboss_cli_commands.cli --target-path /home/site/scripts/jboss_cli_commands.cli --type static
# The startup type uploads to /home/site/scripts/startup.sh by default.
az webapp deploy --resource-group $RESOURCE_GROUP_NAME --name $APP_NAME --src-path startup.sh --type startup

    Para obtener más información, vea Implementación de archivos en App Service.

Para confirmar que el origen de datos se agregó al servidor JBoss, conéctese a su aplicación web mediante SSH y ejecute $JBOSS_HOME/bin/jboss-cli.sh --connect. Cuando se conecte a JBoss, ejecute /subsystem=datasources:read-resource para imprimir una lista de los orígenes de datos.

Tal como se define anteriormente jboss-cli-commands.cli, puede acceder a la conexión de PostgreSQL mediante el nombre JNDI java:jboss/datasources/postgresDS.

Pasos siguientes

Visite el centro de Azure para desarrolladores de Java para encontrar guías de inicio rápido de Azure, tutoriales y documentación de referencia de Java.