lunes, 14 de noviembre de 2016

Oracle Developer Cloud Service Demo

Oracle Developer Cloud Service

Para empezar, vamos a explicar de qué se trata esta nube. Oracle Developer Cloud Service es un ambiente de hosting en la nube. ¿Qué es lo que se sube a esa nube? Proyectos de desarrollo de software.
En esta ocasión, vamos a tomar el rol de ingeniero de software. Una de nuestras tareas va a ser crear un ambiente en la nube de Oracle, para el desarrollo de proyectos Java. Debemos probar la creación de proyectos y administración de incidentes en la nube, así como probar las características de administración del ambiente.
En esta nube podemos tener el rol de administrador o desarrollador. Casi todas las tareas que vamos a cubrir pueden ser realizadas por ambos roles. Sin embargo, algunas de ellas sólo pueden ser ejecutadas por administradores.
Entre otras cosas, básicamente lo que ofrece esta nube es lo siguiente (de acuerdo al fabricante):
1.      Administración de issues
2.      Desarrollo ágil
3.      Repositorio de código fuente
4.      Build del software
5.      Revisión de código
6.      Colaboración vía Wiki
7.      Despliegue de servicios
Sin más, vamos a pasar al uso de la nube y de sus características. Para esto, tendremos que ingresar a través de la consola de Oracle Developer Cloud Service, con las credenciales que nos han proporcionado para el acceso.

Crear un proyecto nuevo

Para crear un nuevo proyecto basta con presionar el siguiente botón:

En la sección de detalles del proyecto, debemos dar un nombre y descripción del proyecto. A continuación, vamos a seleccionar el tipo de seguridad. Los proyectos privados son accesibles únicamente para miembros. En los proyectos compartidos, tanto el código, la wiki, los issues y builds del proyecto están disponibles para cualquier miembro del dominio de identidades de la organización.

Se pueden crear proyectos vacíos, o bien, elegir una plantilla. Si creamos un proyecto a partir de una plantilla, estaremos copiando todos los artefactos: repositorios GIT, configuración de builds y despliegue, páginas de la wiki, etcétera.
En nuestro ejemplo, lo haremos a través de una plantilla:

Por default, en las propiedades del proyecto podemos elegir un estilo de la wiki (Textile, Confluence o Markdown). Todas las wikis del proyecto usarán este estilo. Nosotros elegimos Textile.
Al seleccionar el repositorio inicial, debemos especificar su configuración. Aquí elegimos la opción de inicializar el repositorio con un archivo README.
Si se crea el proyecto a partir de una plantilla, tendremos que especificar algunas otras propiedades.
Al finalizar todo esto, presionaremos el botón Finish:

A continuación, veremos una página que muestra el progreso de la creación de nuestro proyecto. Esto tomará algunos instantes en finalizar:

Una vez que el proyecto es completamente aprovisionado, el sistema nos llevará a la página inicial. Esto nos mostrará los tabs que se muestran en la siguiente imagen. El tab de administración se mostrará únicamente si somos dueños del proyecto:

En esta pantalla podemos explorar algunas de las opciones, podemos esconder el panel de la izquierda para dar una mejor visibilidad del proyecto. También podemos ver el feed en el panel central, volver al menú inicial de Oracle Developer Cloud Service, explorar las características de los repositorios de Maven y Git, gráficas y estadísticas del proyecto, entre otras cosas.

Agregar usuarios al proyecto

Cuando iniciamos un proyecto, uno de los primeros pasos es agrega usuarios al proyecto. Para esto es necesario hacer click en el tab Team del lado derecho. Después debemos elegir New Member:

Aquí podemos agregar un usuario como miembro o como dueño del proyecto. De igual forma, si queremos agregar más de uno, debemos seleccionar la opción de usuarios múltiples. Lo anterior nos permitirá agregar más de un usuario al mismo tiempo:

Nota importante: los usuarios del proyecto deben pertenecer a la organización para poder ser asignados. De lo contrario recibiremos un error como este:

Administración del código con un repositorio Git

Oracle Developer Cloud Service ya provee un repositorio Git para la administración del código. Es posible utilizar un cliente de Git para interactuar con el repositorio. La integración de Git se puede hacer directamente con el IDE (OEPE, Oracle JDeveloper, NetBeans).
Del lado derecho de la página principal del proyecto, podemos encontrar los repositorios del proyecto:

Creación de issues

Ésta nube de Oracle tiene incluído un sistema de administración de issues basado en nube, para el equipo de desarrollo. Es posible definir issues y asignarlos a algún miembro del equipo. Por ejemplo, podemos crear issues para:
1.      Sugerir mejoras
2.      Especificar tareas
3.      Reportar defectos
4.      Definir nueva funcionalidad
5.      Asociar transacciones de código con issues
Para acceder al sistema de administración de issues, debemos elegir ésta opción en el panel del lado izquierdo:

Para crear un issue, es necesario presionar el siguiente botón del lado derecho de la pantalla:

Debemos llenar algunos datos relacionados con el issue, como se muestra a continuación. Aquí podemos catalogar el issue como defecto, tarea o característica. Para este ejemplo elegimos tarea:

Una vez que presionamos el botón de crear issue, nos aparecerá una breve confirmación en la parte superior de la pantalla. Esto nos indica que el issue ha sido creado.
El siguiente paso es asignar un propietario del issue. En este caso me lo asigné a mí mismo. También agregué un comentario que describe qué es lo que hay que hacer para esa tarea.

Una vez que presionamos el botón de agregar, el comentario estará guardado:

Finalmente presionamos guardar y el issue estará creado.
En la página principal de administración de issues, tendremos lo siguiente:

Desarrollo ágil

El tab agile nos permite organizar y calendarizar issues en sprints y supervisar el progreso.
Para esto, tenemos que dar un click en el tab de agile y después crear un nuevo tablero:

Colocamos los siguientes datos y presionamos el botón para crear el tablero:

Esto nos devolverá a un backlog del proyecto. En este backlog tenemos una única tarea creada, la del issue que generamos con anterioridad. Para poder trabajar con el backlog, debemos crear un sprint. Esto lo hacemos dando click en el botón para crear el sprint. Aquí simplemente colocamos el nombre del sprint:

Una vez que creamos el sprint, es necesario mover los issues del backlog hacia este nuevo sprint. Para esto, damos un click derecho sobre la tarea y esto nos dará algunas opciones. En el caso de nuestro ejemplo, elegimos mover la tarea hacia el sprint que acabamos de crear:

Después de realizar esto, tendremos la tarea asociada a nuestro sprint:

Para iniciar nuestro sprint, debemos presionar el botón que está del lado derecho de la pantalla. Esto nos dará opción de definir las fechas de inicio y fin del sprint. Hay que considerar que cuando usamos una metodología ágil, los sprints típicamente son de un par de semanas de duración, por eso el sistema nos indica las fechas de inicio y finalización del sprint, por default.

Al verificar en el tab de sprints activos, podemos ver que el que acabamos de crear ya se encuentra en este estado y el sistema automáticamente los organiza en columnas, como se muestra a continuación:

Revisión del código

Una de las bondades de esta nube, es que nos permite tener absoluto control de los issues a través de la integración del repositorio de Git.
Utilizando las pestañas de Merge Requests y Code, es posible gestionar el ciclo de vida de los issues, así como de realizar un monitoreo del estado de cada uno. Entre otras opciones, podemos realizar lo siguiente:
1.      Copia de un branch hacia uno nuevo, que es donde atenderemos las solicitudes de cambios.
2.      Asociación de los issues abiertos a ese nuevo branch de código.
3.      Modificación del código para resolver el issue o la solicitud de cambio.
4.      Merge de los cambios del branch de trabajo hacia el branch principal del código.
5.      Commit de los cambios.
6.      Adicional se pueden aceptar o rechazar los cambios de acuerdo a la revisión del código.
Al realizar el commit de los cambios, tenemos la opción de cambiar de estatus el issue asociado al repositorio de código. En nuestro caso, al confirmar los cambios en el repositorio principal, podemos observar que el issue que teníamos abierto, ha sido marcado como resuelto.

El último paso es cerrar o terminar el sprint. Como era un único issue el que teníamos asociado al sprint, ahora procederemos a cerrarlo. Esto lo haremos presionando el botón de completar sprint. Nos saldrá una ventana de confirmación, donde aceptaremos la acción:

Lo que veremos a continuación es una pantalla donde nos da algunas estadísticas del estatus del sprint. Verán algo como lo siguiente:

Si observamos la página principal del proyecto, veremos que en el feed se ven reflejadas todas las actividades que hemos realizado hasta el momento:

Uso de la Wiki

Uno de los aspectos interesantes de esta nube es la integración de una Wiki lista para usarse. Podemos usar esta Wiki para crear documentación y colaborar con algunos otros miembros del equipo.
Para acceder a la Wiki, elegimos la opción en los tabs del lado izquierdo de la pantalla. Inicialmente no tenemos Wiki para este proyecto, por lo que veremos una pantalla como la siguiente:

Algo que me pareció muy interesante de esta funcionalidad, es que es un tanto inteligente. Cuando generé la primera página de la Wiki, puse dentro de la descripción del texto la palabra issue 1.

Al guardar la entrada de la Wiki, esto se convirtió automáticamente en un hipervínculo hacia el detalle del issue que generamos con anterioridad.

              
Si damos un click encima del hipervínculo, nos llevará al detalle del issue. Me parece que esta forma de generar documentación es muy simple y práctica de usar.

Ahora en la sección de Wiki, tendremos la que hemos creado recientemente:

Integración continua

Cuando creamos un proyecto en Oracle Developer Cloud Service, tenemos aprovisionadas todo lo necesario para realizar el build. Si queremos subirnos al tren de la integración continua, podemos automatizar e integrar ambientes de pruebas, recibir retroalimentación inmediata o desplegar hacia alguna nube: Oracle Java Cloud Service, Oracle Application Container; o bien, a algún ambiente local.
Para hacer uso de esta característica, debemos elegir la opción de build del lado izquierdo del panel:

Para nuestro ejemplo, elegiremos JDK 1.8:

Es posible ejecutar los pasos que nosotros ocupemos para realizar el build de nuestro proyecto. Esto es una característica muy interesante ya que podemos elegir entre lo siguiente:
1.      Ejecutar un Shell
2.      Invocar Ant
3.      Invocar Maven 2
4.      Invocar Maven 3
5.      Invocar Gradle
6.      Invocar NodeJS
7.      Copiar artefactos
En nuestro caso elegimos la opción de ejecutar un Shell:

Después de realizar el build, también hay varios pasos que podemos ejecutar. Algunos que me parecen muy interesantes son: la integración nativa para realizar el despliegue del proyecto en Oracle Cloud Service, publicar un reporte de pruebas de JUnit o la misma documentación de Java.

Salvamos nuestro job y lo ejecutamos:

Una vez que el build termina de ejecutarse, veremos un resumen parecido al siguiente:

Podemos observar que aquí se encuentra el archivo hello.out que definimos en las tareas del build del proyecto. Si damos click en este archivo, se descargará a nuestro equipo local. Podemos explorar el contenido:

Igualmente, si damos un click en la consola, podremos observar todas las tareas que fueron ejecutadas en el build. Si somos un poco observadores, nos daremos cuenta que detrás de las cámaras, se está ejecutando Hudson como nuestro servidor de integración continua. Esta integración entre la nube de Oracle y Hudson es nativa, nosotros no tuvimos que realizar ninguna configuración adicional, sino que fue aprovisionado de manera automática:

Si vamos a la página principal de jobs, se deberá ver como sigue:

Conclusiones

En conclusión, la nube de Oracle Developer Cloud Service (que a menudo viene incluida con el uso o contratación de algunas otras nubes: Oracle Application Container, por ejemplo), es una nube que nos facilita el desarrollo colaborativo, nos proporciona características de integración con Git, DevOps (Maven, Gradle), integración continua (Hudson), Wiki, y algunas otras características.
Es una muy buena opción, considerando que es gratis con el uso de alguna otra nube de Oracle. Sin duda proporciona características que podríamos y deberíamos emplear en los proyectos de desarrollo de software. Está bien pensada para el uso de metodologías ágiles y nos da una buena cantidad de características de caja para estos propósitos.

Considerando que en los proyectos de desarrollo tradicionales no tenemos orden alguno (o al menos a la mayoría de nosotros nos pasa esto en nuestro día a día), sin duda nos proporciona características valiosas que como desarrolladores nos ayuda a organizar mucho mejor el control del código, el seguimiento a los requerimientos y defectos encontrados en el código, el uso de una metodología (dejen ustedes ágil, con que usemos algún tipo de metodología tenemos suficientes beneficios), entre otras muchas que podrían ser de utilidad. 

lunes, 31 de octubre de 2016

Oracle Application Container Demo

Oracle Application Container – Demo

Introducción

Hoy haremos un ejemplo básico de uso de Oracle Application Container. Lo primero que haremos es dar una mirada a los detalles de ésta nube de Oracle.
Para esto, vamos a navegar a la siguiente URL:
Veremos las siguientes ofertas de PaaS. Por el momento nos interesa el Application Container:

Esto nos llevará al sitio de Oracle Application Container. Para solicitar una prueba, basta con elegir la opción “Try it” y seguir el procedimiento de solicitud de la instancia:

Después de un rato (algunas horas), nos llegará un correo electrónico de Oracle Cloud, que indicará que el servicio fue aprovisionado y nos dará acceso a lo siguiente:
·        Administración de los servicios
o   Dashboard
·        Detalles de la suscripción (esto puede variar, en mi caso se aprovisionó lo siguiente)
o   Oracle Application Container Cloud (este es el que vamos a usar en esta ocasión)
o   Oracle Integration Cloud Service (se van a divertir con Twitter, Facebook y LinkedIn)
o   Oracle SOA Cloud Service (para los que piensan que SOA está muerto, ¡nada más falso!)
o   Developer Service (¿desarrollo en la nube? Ustedes, DevOps, Continuous Integration, Git. ¡No sé, piénsenlo!

¿Cómo se come?

Aquí vamos a dar la descripción comercial para no entrar en polémica (ya hay bastante polémica en el mundo gracias a los dichosos microservicios).
El fabricante define esta nube como una plataforma políglota nativa en la nube. Esto incluye:
·        Desarrollo nativo en la nube
·        Distintos estilos de aplicaciones en una plataforma políglota y moderna con Java SE, PHP, Node.js y más
·        Rápida: autoservicio para el aprovisionamiento de contenedores de aplicaciones. Esto es cierto, aunque para mi gusto no fue tan rápido. El aprovisionamiento tardó algunas horas después de solicitarlo y varias conversaciones por chat con el soporte de Oracle. Uno debe ser exigente, aunque sean versiones de prueba.
·        Escalable: es posible seleccionar el tamaño de la memoria RAM de nuestra instancia y escalarla hacia arriba o abajo de manera dinámica. Esto es cierto. Hay quienes piensan que tener una instancia de unos cuántos KB es importante, yo particularmente no entiendo para qué me serviría una JVM que levante con unos cuántos KB. En fin, se puede hacer.
·        Abierta: se puede elegir entre las distintas versiones de Java SE, PHP y Node.js. Así como librerías, módulos y frameworks.
·        Ágil: cuenta con herramientas de control del ciclo de vida del desarrollo en la nube, incluye integración continua y despliegue.

Demo

Ahora pasemos directamente al uso de Oracle Application Container Cloud. La intención de esta entrada del blog es dar una introducción para la creación de un web service (Grizzly + Jersey + REST), que pueda ser almacenado y distribuido en un JAR. ¿Recuerdan eso de portabilidad en microservicios, nubes, contenedores y todo eso? Pues eso es lo que haremos aquí.

Antecedentes

Cuando un desarrollador piensa en crear un servicio REST usando Java, asumen que para crear este tipo de aplicaciones se debe usar un servidor Java EE. Sin embargo, hay alternativas mucho más ligeras para crear aplicaciones REST usando Java SE. Demostraremos que una alternativa es usar el servidor de Grizzly y el framework Jersey para REST.
Aquí cubriremos los aspectos básicos para crear una aplicación REST con Grizzly, Jersey y Maven. La aplicación incluye un modelo de datos simple para demostrar cómo se procesan las peticiones REST. Crearemos una clase para el web service con anotaciones que convertirá los métodos en URLs REST que se pueden consumir. Finalmente, empaquetaremos la aplicación REST en un JAR portable que pueda ser ejecutado en donde sea.

Grizzly Web Server

Grizzly es un servicio web Java hecho con API NIO. El caso de uso principal de Grizzly es el componente web server de GlassFish. Sin embargo, el objetivo de Grizzly es ayudar a los desarrolladores a hacer más que eso. Con Grizzly podemos construir servidores escalables y robustos usando NIO y ofrecer algunas otras bondades como un Web Framework (HTTP/S), WebSocket, Comet y más.

Jersey, REST y JAX-RS

Jersey es un framework de código libre (a todos nos gusta mucho esto) para desarrollar web services en Java, de tipo REST. Jersey soporta las APIs y servidores JAX-RS.

Escenario

El servicio web REST construido es el inicio de una aplicación REST para la administración de información de clientes. Para este ejemplo, los datos del cliente son almacenados en una lista. Crearemos un método web para devolver todos los clientes contenidos en la lista y un método para buscar al cliente por su identificador. Para mantener esto simple, todos los datos son devueltos en un formato de texto plano.

Requisitos de software

Necesitamos lo siguiente instalado en nuestro equipo:
·        Maven 3.3.1 o superior: https://maven.apache.org/
·        Java 8 u45 o superior:
·        NetBeans 8.0.2:  https://netbeans.org/

Proyecto Maven

El primer paso es crear el proyecto de Maven. Ya existe un arquetipo para este tipo de aplicación (a veces se usa de manera indiscriminada la palabra arquetipo). Para crear el proyecto debemos hacer lo siguiente:
1.      Navegar al directorio donde deseamos crear el proyecto

2.      Ejecutar el siguiente comando para crear el proyecto

3.      Es posible que no puedan encontrar el arquetipo que estamos buscando y que les aparezca un error como el siguiente:


4.      Pero no teman, los tengo cubiertos. Vayan a esta liga y descarguen el JAR:
5.      Luego copien el JAR en su repositorio local de Maven:

6.      Ejecuten de nuevo el comando y la magia estará hecha:

7.      Si damos una mirada en nuestro sistema de archivos, veremos que el proyecto está creado:

8.      La estructura del arquetipo, se ve como sigue:

9.      En este punto me di cuenta que no tengo NetBeans instalado. Al inicio dije que usaría NetBeans, pero puedo usar Eclipse también. Si ustedes tienen NetBeans: File > Open Project. Si tienen Eclipse: File > Import > Maven > Existing Maven Project.
10.   Usé Eclipse y la importación del proyecto se debe ver así (para este punto, moví la carpeta generada por Maven hacia mi workspace de Eclipse:

11.   Entonces, así se ve en Eclipse:

Una mirada al POM

Cuando creamos el proyecto de Maven, se creó nuestro archivo de configuración principal: pom.xml. En este archivo vamos a colocar todas las dependencias y versiones requeridas para construir el proyecto.
1.      La primera parte del archivo contiene metadatos del proyecto. ¿Recuerdan el ID del grupo y del artefacto que colocamos en la línea de comandos al crear el proyecto?:

2.      La segunda parte, contiene las dependencias del código requeridas por el proyecto:

3.      La tercera y última parte del archivo, contiene información acerca de los plugins requeridos por la aplicación:

Código fuente

Para este arquetipo, se han creado un par de archivos.
1.      La clase principal (main) que es la que levanta la aplicación:

2.      La clase que define los métodos del web service:

Ejecución del web service

Una vez que hemos creado el proyecto, vamos a usar Maven para ejecutar la aplicación e iniciar el web server.
1.      Abrir una terminal o línea de comandos
2.      Navegar hacia la ruta del proyecto
3.      Compilar el proyecto

4.      Ejecutar el proyecto. Esto lo hice desde Eclipse (Run) para comprobar que Maven también funciona desde el IDE:

5.      Si navegamos a la URL del WADL, podremos ver lo siguiente:

6.      Si ejecutamos un HTTP GET hacia la URL donde se encuentra nuestro recurso, obtendremos lo siguiente:

Crear el web service de Clientes

Para hacer esto un poco más interesante, vamos a agregar algunos datos de clientes a nuestro proyecto. Los archivos de clientes pueden ser modificados para que podamos buscar un cliente de manera individual; o bien, obtener la lista completa de clientes.

Agregar el código de las clases de clientes

Para esto vamos a usar dos clases. La clase cliente que es usada para representar datos del cliente y la clase lista de clientes que es la que crea una lista de clientes usando los datos de ejemplo.
1.      Crear la clase Customer. Se puede descargar del siguiente link:
2.      Crear la clase CustomerList. Se puede descargar del siguiente link:

Agregar el código del web service

El siguiente paso es agregar el web service a la aplicación: CustomerService. Se puede descargar del siguiente link:

Probar el web service de Clientes

Una vez que hemos creado las clases tanto de Clientes como del web service, vamos a probar el funcionamiento.
Lo primero que debemos hacer es detener el servidor y volverlo a iniciar. Para esto únicamente corremos la aplicación principal (main).

Obtener la lista de todos los clientes

En cuanto el servidor levanta, vamos a probar la siguiente URL para obtener una lista de todos los clientes en nuestro navegador:
Lo que obtendremos es lo siguiente:

Buscar un cliente por su identificador

Si queremos obtener un cliente en particular, únicamente debemos agregar su identificador al contexto de la URL. Así, al hacer una petición (HTTP GET) a la siguiente URL, obtendremos los datos del cliente 103:

Buscar un cliente que no existe

En caso de colocar un ID de un cliente que no existe, obtendremos la siguiente respuesta:

Crear un Uber JAR

Suena muy raro, ¿Uber JAR? Muchas veces cuando creamos una aplicación, al estar desarrollando tenemos que incluir dependencias (otros JAR), modificar el CLASSPATH, incluir muchas cosas para que nuestra aplicación pueda funcionar. Si deseamos que esta aplicación pueda ser portable y la podamos ejecutar en cualquier lugar, debemos crear un Uber JAR. Este tipo de JAR es el que incluye todas las dependencias y lo podemos transportar a donde sea.

Actualizar el pom.xml

Para que Maven pueda realizar esto, es necesario modificar nuestro pom.xml. El primer cambio es agregar el plugin de assembly.

Este plugin es utilizado para crear JARs o WARs que empaquetan aplicaciones Java en un único archivo. Lo que quiero resaltar aquí es que la clase Main se configura para ser la clase ejecutable del JAR.
Ahora que hemos creado nuestro JAR ejecutable, es necesario configurar el pom.xml para que agregue todas las dependencias al JAR. Para esto, vamos a usar el plugin de dependency.

Al agregar la meta copy-dependencies, estamos logrando que todas las dependencias queden dentro del JAR que vamos a generar.

Ejecutar la aplicación

Para construir y ejecutar la aplicación, debemos hacer lo siguiente:
1.      Compilar la aplicación

2.      Empaquetar la aplicación

3.      Verificar el directorio del JAR

4.      Ejecutar el JAR

En este punto, tengo la aplicación corriendo en mi equipo, sin necesidad de hacer más nada. Únicamente ejecuté el JAR:

¡Listo! Ahora tenemos un JAR ejecutable, empaquetado y listo para ejecutarse en cualquier lugar que corra Java. Todo esto, con Java SE + Grizzly + Jersey.

Despliegue en Oracle Application Container

Es necesario crear un archivo ZIP con el JAR de nuestra aplicación y un MANIFEST escrito en formato JSON. Posterior a esto, podremos desplegarlo en Oracle Application Container.

Creación del manifiesto

He renombrado el JAR que contiene todas las dependencias. El nombre es auto descriptivo y describe el funcionamiento del servicio. Es un servicio de catálogo de clientes:

Es necesario crear un archivo llamado manifest.json que nos dará información del despliegue que vamos a realizar. El archivo tiene la siguiente forma:

Donde:
·        Major Version: La versión de Java, en mi caso 8.
·        Command: El comando a ejecutar después de realizar el despliegue
·        Build: Número de identificación de la aplicación, proporcionado por el usuario.
·        Commit: Mensaje de despliegue de la aplicación, proporcionado por el usuario.
·        Versión: Versión de la aplicación, proporcionado por el usuario.
·        Notes: Cualquier comentario adicional, proporcionado por el usuario.
Finalmente, debemos comprimir el JAR y el manifiesto, en un archivo ZIP:

Despliegue vía la consola

Lo que debemos hacer para el despliegue es lo siguiente:
1.      Entrar a Oracle Application Container

2.      Crear una aplicación. Aquí proporcionaremos el nombre de la aplicación a desplegar, el tipo de suscripción, el archivo a desplegar, comentarios e información de la instancia (memoria, número de instancias y versión de Java). Al desplegar la aplicación, debemos esperar algunos minutos a que el archivo termine de procesarse.

3.      Monitorear la aplicación. Una vez que creamos la aplicación, se tomará unos minutos para que se aprovisione el contenedor correspondiente. Mientras tanto nos aparecerá algo como lo siguiente:

4.      Acciones sobre la aplicación. Tenemos disponibles varias acciones que podemos realizar sobre cada aplicación desplegada.

Conclusiones

La transformación digital nos ha llevado a la necesidad de utilizar medios de comunicación efectivos y ligeros. Esta habilitación de la comunicación entre aplicaciones es fundamental para dar agilidad a los negocios y responder ante los constantes cambios en las necesidades del mercado.
REST nos ofrece una manera ligera, estándar y segura como mecanismo de integración de aplicaciones, además de que es el preferido de los dispositivos móviles. Existen en el mercado distintos frameworks que nos facilitan el desarrollo e implementación de éste tipo de servicios y aplicaciones. Muchos de ellos son software libre donde la comunidad colabora diariamente.
Existen algunos otros componentes ligeros sobre los que corren nuestros servicios REST, como es el caso de Grizzly en este ejemplo. Otras opciones pueden ser Jetty o Netty. La decisión va a depender de las capacidades que estemos buscando de nuestro contenedor de aplicaciones.
Finalmente, una de las cosas más importantes es la portabilidad de las aplicaciones que estamos creando. El tema de la contenerización es fundamental en estos tiempos. Codificar una única vez y correr nuestro código en cualquier contenedor de aplicaciones. ¿Alguna vez pensaron en esto? Soluciones portables, empaquetadas. De aquí pueden desprenderse muchas líneas de negocio al pensar en cómo definimos la arquitectura de nuestras aplicaciones y cómo las desarrollamos.

Siéntanse libres de expresar sus comentarios aquí abajo.