Implementación de aplicaciones Spring Boot en Heroku

Heroku es una solución generalizada para alojamiento en línea rápido y gratuito. Cubriremos varias formas de poner en funcionamiento su propia aplicación Spring Boot en la web.

Introducción

Al desarrollar una aplicación web, la progresión natural es ponerla en línea y ponerla a disposición de los usuarios finales. Para que esta tarea sea posible y más fácil, existen numerosas plataformas en la nube disponibles para elegir para alojar su aplicación: Heroku es una de ellas.

Heroku proporciona una plataforma como servicio para implementar aplicaciones de varias pilas de tecnología como Node, Java, Python, etc. Se ocupa de todos los aspectos complicados de implementación, infraestructura, escalado, actualización, seguridad, etc. y nos permite centrarnos en la lógica de la aplicación y ofrecer más valor a nuestros usuarios finales, en lugar de la implementación.

En este artículo, crearemos una aplicación API REST de Spring Boot realmente simple que expondrá un punto final, y veremos varias formas de implementar la aplicación en Heroku.

Creación de una aplicación Spring Boot

Inicializar la aplicación Spring Boot

Como siempre, la forma más fácil de comenzar con un proyecto básico de Spring Boot es usar el Inicializador de primavera:

spring_boot_initializr

Elija su herramienta de compilación preferida, usaremos Maven. La única dependencia que necesitaremos es la dependencia Spring Web.

Alternativamente, podemos crear la aplicación usando la CLI de arranque de primavera:

1
$ spring init --dependencies=web heroku-demo

Crear un punto final REST

Con nuestro esqueleto terminado, agreguemos un punto final REST simple:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
@RestController
@RequestMapping("/api/v1.0")
public class TimeController {

    @GetMapping("/time")
    @ResponseStatus(HttpStatus.OK)
    public String getCurrentTime() {

        return Instant.now().toString();
    }
}

En caso de que no esté familiarizado con la anotación @RestController, es una anotación conveniente hecha como una combinación de las anotaciones @Controller y @ResponseBody.

Este punto final simplemente devolverá la hora actual del servidor a pedido. Ejecutemos la aplicación en nuestra máquina local y probemos si funciona:

1
$ mvn spring-boot:run

O, utilizando su IDE, simplemente ejecute la aplicación y navegue hasta la dirección URL localhost:8080/api/v1.0/time de su navegador:

spring_boot_app_homepage

Alternativamente, puede usar una herramienta como curl para llegar al punto final:

1
2
$ curl -X GET 'http://localhost:8080/api/v1.0/time'
2020-01-04T13:19:30.980Z

Implementación en Heroku

Con nuestra aplicación preparada y lista, exploremos las diferentes formas en que podemos implementarla en Heroku.

Uso de la CLI de Heroku con Git

Heroku ofrece su propia CLI, que podemos usar para implementar una aplicación. Para ello necesitamos instalar CLI de Heroku y [Git](https://git-scm. com/).

Antes de intentar implementarlo, Heroku necesita que la aplicación esté en un repositorio de Git, así que vamos a crear un repositorio en nuestro directorio de proyectos:

1
$ git init

Una vez que se crea el repositorio, agreguemos y confirmemos los archivos:

1
2
$ git add src/ pom.xml
$ git commit -m "first commit with project base"

El siguiente paso es iniciar sesión en Heroku mediante la CLI de Heroku y crear una aplicación de Heroku:

1
$ heroku login

Se le solicitará el correo electrónico y la contraseña de su cuenta de Heroku:

1
2
3
4
Enter your Heroku credentials:
Email: ***********@gmail.com
Password: ***********
Logged in as **********@gmail.com

Una vez que hayamos iniciado sesión, creemos la aplicación:

1
$ heroku create

Relativamente rápido, estaremos atados con una aplicación:

1
2
Creating app... done,  arcane-journey-46830
https://arcane-journey-46830.herokuapp.com/ | https://git.heroku.com/arcane-journey-46830.git

El comando create agregar un control remoto de Git nombrará heroku a nuestro repositorio Git local y también agregará un nombre aleatorio - en nuestro caso es arcane-journey-46830.

Finalmente, podemos desplegar nuestro código:

1
$ git push heroku master

Heroku detectará que se trata de una aplicación Java/Maven por la presencia del archivo pom.xml en el repositorio. Después de presionar, si echa un vistazo a los registros, podrá notar:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
Enumerating objects: 26, done.
Counting objects: 100% (26/26), done.
Delta compression using up to 4 threads
Compressing objects: 100% (21/21), done.
Writing objects: 100% (26/26), 2.96 KiB | 504.00 KiB/s, done.
Total 26 (delta 5), reused 0 (delta 0)
remote: Compressing source files... done.
remote: Building source:
remote:
remote: -----> Java app detected
remote: -----> Installing JDK 1.8... done
remote: -----> Installing Maven 3.6.2... done
remote: -----> Executing Maven
...

Y finalmente, la implementación finaliza y se nos solicita una URL que conduce a nuestra aplicación:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
...
remote: -----> Compressing...
remote:        Done: 65.7M
remote: -----> Launching...
remote:        Released v3
remote:        **https://arcane-journey-46830.herokuapp.com/** deployed to Heroku
remote:
remote: Verifying deploy... done.
To https://git.heroku.com/arcane-journey-46830.git
 * [new branch]      master -> master

Probemos la aplicación nuevamente usando curl:

1
2
$ curl -X GET 'https://arcane-journey-46830.herokuapp.com/api/v1.0/time'
2020-01-04T13:51:31.559Z

O navegando en nuestro navegador a su URL:

spring_boot_app_deployed_on_heroku

Complemento de implementación de Heroku

Si queremos implementar nuestra aplicación directamente sin usar un repositorio de Git, podemos hacerlo usando el complemento heroku-cli-deploy. Comencemos por instalarlo:

1
$ heroku plugins:install heroku-cli-deploy

Al igual que en la sección anterior, le pedimos a Heroku que cree la aplicación, pero esta vez incluimos un argumento --no-remote para evitar que se nos solicite el repositorio de Git:

1
$ heroku creare heroku-demo-wikihtp --no-remote

Tenga en cuenta que esta vez hemos mencionado un nombre de aplicación: heroku-demo-wikihtp. Esto creará la aplicación con un nombre dado y no generará un nombre aleatorio como en la sección anterior.

También debemos mencionar el puerto en el que Heroku vinculará la aplicación en el archivo application.properties:

1
server.port=${PORT:8080}

Nota: Esto es necesario ya que Heroku vincula la aplicación a un puerto pasado como la variable de entorno PORT y Spring Boot expone de manera predeterminada el puerto 8080. Aquí, le pedimos a Spring que use PORT y recurra a 8080 en caso de que la variable de entorno no esté presente, es decir, estamos ejecutando localmente.

Finalmente, construimos nuestra aplicación con Maven para crear el archivo jar y desplegarlo:

1
$ mvn clean package
1
$ heroku deploy:jar target/heroku-demo.0.0.1-SNAPSHOT.jar --app heroku-demo-wikihtp

Complemento Maven

Podría haber escenarios en los que nos gustaría realizar la implementación como parte de nuestra compilación de Maven. Esto es posible utilizando el Complemento Heroku Maven. Pongamos la configuración del complemento en nuestro pom.xml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
...
<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>com.heroku.sdk</groupId>
                <artifactId>heroku-maven-plugin</artifactId>
                <version>{version}</version>
                <configuration>
                    <appName>heroku-demo-wikihtp</appName>
                    <includeTarget>false</includeTarget>
                    <includes>
                        <include>${project.build.directory}/${project.build.finalName}.jar</include>
                    </includes>
                    <jdkVersion>1.8</jdkVersion>
                    <processTypes>
                        <web>java $JAVA_OPTS -jar
                            ${project.build.directory}/${project.build.finalName}.jar</web>
                    </processTypes>
                </configuration>
            </plugin>
        </plugins>
    </build>
...

Siempre, busca la última versión del plugin aquí.

Como paso final, debemos establecer una variable de entorno: HEROKU_API_KEY. Este paso es obligatorio solo si no ha iniciado sesión en la CLI de Heroku para obtener autorización. La clave API se puede encontrar en su panel de Heroku cuenta:

heroku_api_key

Y ahora podemos usar el objetivo heroku:deploy para implementar la aplicación:

1
$ mvn clean heroku:deploy

Tablero de Heroku con GitHub

Con los enfoques programáticos/CLI fuera del camino, también hay un enfoque de GUI realmente fácil de usar. Podemos crear una aplicación en el Tablero de Heroku, vincularla con una cuenta de GitHub y desplegar desde allí.

Navega a la opción "nueva aplicación":

heroku_dashboard_new_app

A continuación, conecte su cuenta de GitHub y busque su repositorio para conectarse:

github_app_connect_to_heroku

Una vez conectado, puede implementar su aplicación eligiendo una rama para implementar o directamente eligiendo la rama maestra. Además, puede optar por habilitar implementaciones automáticas basadas en confirmaciones en una rama en particular:

github_app_deploy_to_heroku

Comprobación de registros de aplicaciones implementadas

Verificar los registros de la aplicación implementada puede ser útil para muchos propósitos. Afortunadamente, es muy fácil acceder a ellos.

Usando la CLI, es solo un comando:

1
$ heroku logs --tail

Esto permitiría ver los registros en ejecución:

heroku_logs

Alternativamente, el Tablero de Heroku nos permite acceder a ellos a través del lado derecho Más > Ver registros:

heroku_dashboard_logs

Perfil de Heroku {#archivo de Heroku}

El Procfile podría usarse para configurar o anular la configuración y los comandos predeterminados de la aplicación. Por ejemplo, al implementar la aplicación usando el complemento de implementación de Heroku, hemos agregado información de puerto en application.properties.

Esto también podría agregarse al Procfile. Añadiríamos comandos para ejecutar la aplicación como:

1
web: java $JAVA_OPTS -jar target/heroku-demo-0.0.1-SNAPSHOT.jar -Dserver.port=$PORT

Aquí, agregamos un comando para ejecutar la aplicación con Java y agregamos un argumento JVM para anular el enlace de puerto predeterminado de Spring Boot.

Eliminación de la aplicación de Heroku

En algún momento, es posible que desee eliminar su aplicación de Heroku, por el motivo que sea. Esto se hace a través de un comando simple:

1
$ heroku apps:destroy --confirm arcane-journey-46830

Podemos ejecutar el comando sin el indicador --confirm, pero en ese caso, se le pedirá que ingrese el nombre de la aplicación.

Alternativamente, podemos eliminar la aplicación de la configuración del panel de Heroku:

heroku_delete_app_dashboard

Conclusión

Con la creciente popularidad de la computación en la nube, es importante saber cómo podemos implementar y administrar nuestra aplicación en una plataforma en la nube.

Heroku es una plataforma como servicio para implementar, administrar y escalar aplicaciones. También proporciona implementaciones gratuitas con dinamómetros gratuitos. Estas implementaciones gratuitas podrían usarse para cualquier demostración o evaluación, pero definitivamente no son adecuadas para aplicaciones de producción en vivo.

En este artículo, hemos cubierto varias formas de implementar aplicaciones Spring Boot en Heroku: utilizando la CLI de Heroku, el complemento de implementación de Heroku, el complemento de Maven y, finalmente, el enfoque de GUI a través de un repositorio de GitHub.

Todas las implementaciones realizadas aquí se implementan en el banco de pruebas gratuito. Tenga en cuenta que estos dynos gratuitos se detendrán cuando no estemos usando la aplicación durante un cierto período de tiempo. Volverán a girar cuando hayamos accedido a la aplicación. Por lo tanto, podemos enfrentar algunos retrasos cuando tratamos de llegar a nuestra aplicación después de mucho tiempo.