Header Ads

Publicaciones recientes

Microservicios en Payara sobre Heroku



Con este post comenzamos el mundo de Jakarta EE, que es la "evolución" de Java EE.
Hablaremos sobre cómo poner un microservicio en Payara Micro sobre Heroku.




Pero, para no inventar la rueda, usaremos el proyecto que hemos visto en la anterior serie: Payara con Arquillian.

0. Primeros pasos

Para comenzar, debemos tener una cuenta en Heroku (https://signup.heroku.com). Es bastante simple.

Luego, necesitamos descargar el Heroku CLI (https://devcenter.heroku.com/articles/heroku-cli#download-and-install) que es nuestro cliente para comunicarnos con la nube.

Otra cosa a considerar es que debemos tener instalado el Git y que esté accedible desde el PATH de nuestro Sistema Operativo.

1. Preparando la aplicación

Desde la línea de comandos del sistema operativo nos iremos a la carpeta donde se encuentra nuestro proyecto.

Lo primero que tenemos que hacer es iniciar  nuestra sesión con el comando heroku login a lo que nos pedirá nuestras credenciales que definimos al crear nuestra cuenta.



Ahora, necesitamos crear una aplicación para heroku. En la misma carpeta escribimos el comando heroku create. Adicionalmente se puede colocar el nombre que tendrá nuestro proyecto, o - si lo omitimos - nos creará un nombre aleatorio.


 Hecho esto, podemos entrar al dashboard de Heroku (https://dashboard.heroku.com/apps) y ver la aplicación que hemos creado.



2. Preparando la base de datos

Toda aplicación debe tener siempre un almacén de datos, sobretodo si estamos haciendo un microservicio. Recordemos que la aplicación que habíamos hecho usa H2 para hacer las pruebas con Arquillian, y se despliega con una base de datos MySQL.

Ahora bien, lo que vamos hacer es modificar un poco la aplicación para que, al desplegar, utilice el PostgreSQL de Heroku.

Pero antes, debemos configurar la base de datos para nuestra aplicación.

Desde el Dashboard, seleccionemos del menú de la cuenta la opción "Data".


 Como es la primera vez, nos dirá que no hemos creado nada todavía, y nos invita a crear una fuente de datos.


Se nos ofrece tres tipos de repositorio de datos:
  • Relacional, usando PostgreSQL
  • Clave / Valor, usando Redis
  • Distribuida, usando Kafka.
Por ahora veremos una base de datos relacional. Así que haremos clic en "Create one" de "Heroku Postgres".

Si es la primera vez que vamos a configurar la base de datos, nos pedirá que instalemos el Addon de PostgreSQL para Heroku.

Podemos contratar un con ciertas características, o usar uno gratuito, con las limitantes que nos ofrecen.

Comencemos por instalar el Addon


Ahora, nos pedirá que indiquemos cuál es el Plan de base de datos que usaremos. Hay varios planes, así que usaremos el gratuito: Hobby Dev - Free.



Luego, en la siguiente casilla nos pide que escribamos el nombre de la aplicación que vamos a implementar la base de datos. Así que escribimos el nombre y la seleccionaremos.



Y hacemos clic en "Provision add-on"

Finalmente, ya tenemos nuestra base de datos lista para nuestra aplicación.



No voy a entrar en detalle de Heroku, ya que el objetivo de este post es otro.

3. La conexión de la base de datos

Para que nuestra aplicación utilice la base de datos necesitamos usar sus credenciales, configurarlo en nuestra cadena de conexión del Pool (o JDBC según sea el caso) y listo.

Ahora bien ¿cuáles son las credenciales?

Entremos al panel de base de datos https://data.heroku.com/

Ahí veremos la base de datos que acabamos de crear y enlazar a nuestra aplicación.


Hacemos clic en nuestro datastore para entrar y conocer el detalle.

En la pestaña "Settings" hacemos clic en el botón "View credentials..."


Y se nos muestra lo oculto:


Estos valores debemos tenerlo en cuenta para después.

4. Preparando la aplicación para Heroku

  • ¿Usaremos estas credenciales y las pegaremos a nuestro código?
  • No
  • ¿lo pondremos en un archivo aparte para que nuestra aplicación lo lea?
  • No, bueno, casi, pero no colocaremos esas credenciales en alguna parte de nuestro código
Lo genial de Heroku es que podemos usar variables de entorno y estas serán pasadas a nuestra aplicación. Así que tendremos las siguientes y grandes ventajas:
  • Podemos ejecutar en nuestro entorno local de Heroku con unas credenciales diferentes al de la nube.
  • La nube tendrá sus variables de entorno, y solo el administrador podrá accederlas.
  • Payara Micro también puede leer variables de entorno.
 Así que, comenzaremos a modificar nuestra aplicación.

4.1 Las variables de entorno local

Este archivo solo será leído cuando ejecutamos el Heroku en nuestro ambiente local. Este archivo se llamada .env, estará en la "raiz" del proyecto, y deberá tener el siguiente contenido.
JDBC_DRIVER=com.mysql.jdbc.jdbc2.optional.MysqlXADataSource
JDBC_HOST=localhost
JDBC_DBNAME=store
JDBC_USER=store
JDBC_PASSWORD=store

Son las mismas credenciales que hemos usado para nuestro ejemplo anterior, pero solo funcionará en nuestro local

4.2 El archivo Procfile.local

Este archivo es algo parecido a un script de ejecución. Se parece a un bash o .bat, pero puede hacer varias cosas. Solo por ahora veremos lo necesario. Su contenido es el siguiente:
web: java -jar target\payara-arquillian-heroku-1.0.jar

4.3 Modificando el archivo web.xml

Ahora bien ¿cómo hacemos para que nuestra aplicación se entere las variables de entorno que estamos usando?. Pues, este archivo permite leer esas variables, así como variables de entorno. Veamos cómo se hace:
<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
  version="3.1">
    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
    <data-source>
        <name>java:app/store</name>
        <class-name>${ENV=JDBC_DRIVER}</class-name>
        <server-name>${ENV=JDBC_HOST}</server-name>
        <database-name>${ENV=JDBC_DBNAME}</database-name>
        <user>${ENV=JDBC_USER}</user>
        <password>${ENV=JDBC_PASSWORD}</password>
    </data-source>
</web-app>

4.4 Corriendo Heroku Local

Y Listo, desde la línea de comandos ejecutamos la siguiente orden:
mvn clean package -Pdist

heroku local web -f Procfile.local

La primera línea es para compiarlo y preparar para distribuir (con el perfil dist que usamos en el post anterior), y luego ejecutamos el heroku local.
Y este es el resultado.


 ¿Lo probamos?
Hacemos las mismas pruebas qué hacíamos en los post anteriores.

Con httpie
http http://localhost:9595/payara-arquillian-heroku-1.0/webresources/product


También podemos usar Postman y el resultado será el mismo.



4.5 El archivo Procfile

Este es el archivo que se ejecutará en Heroku cuando se despliegue. Recordemos que se ejecutará en un ambiente Linux, por tanto, la sintaxis de los comandos varía un poco. Este archivo también irá en la "raíz" del proyecto.

web: java -jar target/payara-arquillian-heroku-1.0.jar --port $PORT


Notemos la variable de entorno $PORT. Se le va a indicar a Payara que se exponga el servicio en ese puerto. Heroku sabrá qué hacer con ese puerto para publicarlo.

4.6 Configuracion final de pom.xml: Driver de PostgreSQL y despliegue perfil dist automático

Nos falta dos cosas para terminar: Agregar el Driver Postgresql. Nos bastará con agregar la dependencia indicada:

                <dependency>
                    <groupId>org.postgresql</groupId>
                    <artifactId>postgresql</artifactId>
                    <version>42.2.2</version>
                </dependency>

. No importa si está junto con el Driver de MySQL. Se puede mejorar el pom.xml pero por ahora puede funcionar sin problema.

Ahora bien, recordemos que para preparar la aplicación como un empaquetado con Payara Micro era necesario utilizar el perfil dist, y por eso necesitábamos ejecutar el comando de maven con el argumento -Pdist.

En heroku no se puede indicar qué perfil utilizará. Solo se le hace un push a su código y este se desplegará de manera automática, sin perfil sin nada.

Una manera es dejar siempre activo ese perfil, pero lo mejor es que sea tan inteligente el pom.xml que sepa qué hacer en determinados ambientes. Bastará con detectar una variable de ambiente y eso activará el perfil adecuado.

        <profile>
            <id>dist</id>
            <activation>
                <property>
                    <name>env.DYNO</name>
                </property>
            </activation>
            <dependencies>
...


4.7 Las variables de entorno de nuestra aplicación en Heroku

Las variables de entorno de Heroku está en la pestaña "Settings" del Dashboard. Hay un botón llamado "Reveal Config vars".



Hacemos clic allí y se nos mostrará un editor de variables de entorno. Existirá uno predefinido, pero necesitamos definir los nuestros. Debemos declarar las siguientes variables utilizando los valores que vimos en el entorno de Datastores.
  • JDBC_DRIVER : org.postgresql.ds.PGPoolingDataSource
  • JDBC_HOST
  • JDBC_DBNAME
  • JDBC_USER
  • JDBC_PASSWORD

4.8 Desplegando en la nube

Para desplegar en la nube de Heroku solo se necesita hacer push al git que tiene Heroku. Para saber cuál es el git de nuestro proyecto, debemos hacer este comando. Naturalmente, debimos de haber iniciado sesión en Heroku desde la línea de comandos. Así que este es el comando:
heroku apps:info nombre_de_la_aplicacion

En mi caso, sería este:
heroku apps:info payaramicro-heroku  

Esto me mostrará toda la info.


 Por tanto, hacemos commit a los cambios que hicimos:

git add *
git commit -m "Preparado para Heroku"



Y luego, push a la dirección git

git push  https://git.heroku.com/payaramicro-heroku.git

Veamos cómo trabaja.



Y listo, cuando veamos que terminó el maven, podemos estar casi seguros que está funcionand.

¿Cómo saberlo? Vamos al Dashboard y seleccionemos de la aplicación la opción "View logs"



Y vemos...


Tiene un final similar que cuando lo ejecutábamos en nuestro local.

4.9 Probando el servicio

Ahora sí, el momento de la verdad. Como usamos JPA configurado para crear las tablas, estamos 100% de que las tablas se crearon en PostgreSQL. Así que solo nos toca invocar al servicio pero utilizando el nuevo URL que se creó: Usando httpie, este es el resultado
 http https://payaramicro-heroku.herokuapp.com/payara-arquillian-heroku-1.0/webresources/product


Pero como no tenemos data, nos devolverá vacío.



Al menos no lanzó error, y eso quiere decir que las tablas fueron creadas correctamente porque el Query no falló.

Y listo, tenemos nuestro Microservicio con Payara funcionando en Heroku.

Como estamos con un plan gratuito, si no se utiliza el servicio este se cerrará, y debemos activarlo nuevamente desde el dashboard.

Código fuente

Como es de costumbre, el código fuente desarrollo en este post lo podrán encontrar, descargar y clonar desde aquí:
https://bitbucket.org/apuntesdejava/payara-arquillian-heroku

Y, para terminar, les dejo un Proverbio de un libro muy antiguo (La Biblia)

"Trabaja duro y serás un líder; sé un flojo y serás un esclavo." Proverbios 12:24. Hasta la próxima.