Implementación de aplicaciones Spring Boot en Heroku

I

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 uno de ellos.

Heroku proporciona una plataforma como servicio para implementar aplicaciones de varias pilas de tecnología como Node, Java, Python, etc. Se encarga de todos los aspectos complicados de implementación, infraestructura, escalado, actualización, seguridad, etc. y nos permite enfocarnos 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.

Crear una aplicación Spring Boot

Inicialización de la aplicación Spring Boot

Como siempre, la forma más fácil de comenzar con un proyecto esqueleto de Spring Boot es usar el Spring Initializer:

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

Alternativamente, podemos crear la aplicación usando el Spring Boot CLI:

$ spring init --dependencies=web heroku-demo

Crear un punto final REST

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

@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 el @RestController anotación, es una anotación de conveniencia hecha como una combinación de la @Controller y @ResponseBody anotaciones.

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

$ mvn spring-boot:run

O, usando su IDE, simplemente ejecute la aplicación y navegue hasta el localhost:8080/api/v1.0/time Dirección URL:

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

$ 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.

Usando la CLI de Heroku con Git

Heroku ofrece su propia CLI, que podemos usar para implementar una aplicación. Para hacer esto, necesitamos instalar Heroku CLI y Git.

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

$ git init

Una vez creado el repositorio, agreguemos y confirmemos los archivos:

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

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

$ heroku login

Le solicitará un correo electrónico y una contraseña para su cuenta de Heroku:

Enter your Heroku credentials:
Email: ***********@gmail.com
Password: ***********
Logged in as **********@gmail.com

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

$ heroku create

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

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

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

Finalmente, podemos implementar nuestro código:

$ git push heroku master

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

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:

...
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:

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

O navegando nuestro navegador a su URL:

Complemento de implementación de Heroku

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

$ 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 una --no-remote argumento para evitar que se le solicite el repositorio de Git:

$ heroku creare heroku-demo-Pharos.sh --no-remote

Tenga en cuenta que esta vez hemos mencionado el nombre de una aplicación: heroku-demo-Pharos.sh. 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 application.properties archivo:

server.port=${PORT:8080}

Nota: Esto es necesario ya que Heroku vincula la aplicación a un puerto pasado como PORT variable de entorno y Spring Boot por defecto expone el 8080 Puerto. Aquí, le pedimos a Spring que use PORT y volver 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 jar archivarlo e implementarlo:

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

Complemento Maven

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

...
<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-Pharos.sh</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, busque la última versión del plugin aquí.

Como paso final, necesitamos establecer una variable de entorno: HEROKU_API_KEY. Este paso es necesario 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:

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

$ mvn clean heroku:deploy

Panel de Heroku con GitHub

Con los enfoques programáticos / CLI fuera del camino, también hay un enfoque GUI realmente fácil de usar. Podemos crear una aplicación en el Panel de Heroku, vincúlelo con una cuenta de GitHub e impleméntelo desde allí.

Navega a la opción “nueva aplicación”:

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

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

Verificación de registros de aplicaciones implementadas

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

Usando la CLI, es solo un comando:

$ heroku logs --tail

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

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

Heroku Procfile

El Procfile se puede utilizar para configurar o anular la configuración y los comandos predeterminados de la aplicación. Por ejemplo, mientras implementamos la aplicación usando el plugin de implementación de Heroku, hemos agregado información de puerto en el application.properties.

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

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.

Eliminar la aplicación de Heroku

En algún momento, es posible que desee eliminar su aplicación de Heroku, por cualquier motivo. Esto se hace mediante un comando simple:

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

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

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

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 se pueden utilizar 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 plugin de implementación de Heroku, el plugin 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 dinamómetros gratuitos se detendrán cuando no estemos usando la aplicación durante un período de tiempo determinado. Volverán a girar cuando hayamos pulsado la aplicación. Por lo tanto, es posible que enfrentemos algunos retrasos cuando intentemos llegar a nuestra aplicación después de mucho tiempo.

 

About the author

Ramiro de la Vega

Bienvenido a Pharos.sh

Soy Ramiro de la Vega, Estadounidense con raíces Españolas. Empecé a programar hace casi 20 años cuando era muy jovencito.

Espero que en mi web encuentres la inspiración y ayuda que necesitas para adentrarte en el fantástico mundo de la programación y conseguir tus objetivos por difíciles que sean.

Add comment

Sobre mi

Últimos Post

Etiquetas

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con tus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, aceptas el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Más información
Privacidad