Mostrando las entradas con la etiqueta Oracle Developer Cloud Service. Mostrar todas las entradas
Mostrando las entradas con la etiqueta Oracle Developer Cloud Service. Mostrar todas las entradas

martes, 5 de mayo de 2020

Automatización de Deployment de Oracle API Platform Cloud Service

Desde hace algunas semanas he participado en un proyecto de migración hacia Oracle Cloud. El proyecto tiene como objetivo migrar una buena cantidad de servicios a la nube de Oracle. Estos servicios se encuentran actualmente desplegados en Oracle SOA Suite.

Uno de los objetivos de la organización es darle a los servicios el enfoque de APIs, de tal manera que puedan ser usados por varios canales dentro y fuera de la organización. También que la misma organización pueda ejecutar acciones de monitoreo de uso y rendimiento, monetización, seguridad, y algunas otras relacionadas con el proceso de API Management.

La arquitectura utilizada para la implementación es una mezcla de varias nubes de Oracle:
  • Oracle API Platform Cloud Service
  • Oracle Integration Cloud Service
  • Oracle Infrastructure Cloud
  • Oracle Developer Cloud Service
Voy a enfocar esta entrada del blog a la automatización de los artefactos creados en Oracle API Platform Cloud Service debido a que la arquitectura contempla un plan de recuperación ante desastres, comúnmente llamado DRP.

Oracle API Platform Cloud Service

Esta es la plataforma de API Management que ofrece Oracle. Proporciona funcionalidades típicas de una plataforma de este estilo. A continuación, se listan algunas de sus capacidades:
  • Configuración de proveedores de OAuth 2.0
  • Administración de usuarios y grupos
  • Administración de roles
  • Gateways lógicos y físicos
  • Gestión de APIs
  • Gestión de planes
  • Gestión de cuentas de servicio
  • Analíticos
  • Portales de desarrolladores
  • Administración de aplicaciones
Una de las desventajas de este servicio de Oracle es que no cuenta con opciones para realizar la migración de las APIs y Gateways desplegados, hacia una instancia nueva o distinta. Por ejemplo, en el caso de un desastre, tendríamos que encender la instancia contemplada en el DRP. Sin embargo, no existen capacidades para migrar los artefactos de una instancia a otra de manera natural.

Para mayor detalle del servicio de API Management de Oracle, pueden consultar la documentación en la siguiente liga:


REST API

Afortunadamente, el servicio (como casi todos los servicios de nube) cuenta con APIs de tipo REST que nos ayudarán a automatizar el proceso. Esto evitará la necesidad de construir y sincronizar todo de nuevo en la instancia del DRP.

El alcance de las APIs provistas por Oracle incluyen la interacción con distintos elementos de la plataforma. Algunos de ellos son los siguientes:
  • APIs
  • Aplicaciones
  • Deployments
  • Gateways
  • Planes
  • Políticas
  • Cuentas de servicio
  • Suscripciones
La seguridad implementada para el uso de las APIs es OAuth 2.0. Esto quiere decir que previo al uso de las APIs, es necesario obtener un token de acceso a través de Oracle Identity Cloud Service. Una vez que el usuario es autenticado y autorizado, se utiliza el token para invocar cualquiera de las APIs.

La documentación completa de la funcionalidad de las APIs, su alcance y ejemplos de uso se encuentra en la siguiente liga:


Developer Cloud Service

Para este proyecto inclumos el uso de Developer Cloud Service como un entorno en el que vamos a ejecutar la automatización del despliegue de las APIs generadas. Developer Cloud Service es la plataforma de desarrollo de Oracle en la nube (PaaS). Cuenta con capacidades para desarrollo, colaboración, construcción y despliegue de aplicaciones en Oracle Cloud.

La documentación completa de Oracle Developer Cloud Service la pueden encontrar aquí:


Proceso de Automatización

Los pasos que seguimos para la automatización del despliegue en Oracle Developer Cloud Service fueron los que se detallan a continuación.

Descriptor

Lo primero que utilizamos es un descriptor de las APIs. Este básicamente es un archivo de tipo JSON que nos indica información importante de las APIs que queremos promover de una instancia a otra.

Básicamente, la información que debe incluir el descriptor es la siguiente:

  • Nombre de la API
  • Endpoint del servicio del backend
A continuación, se muestra un ejemplo simple del descriptor:

{
    "apis": [
        {
            "name": "Orders API",
            "targetURL": "https://oracleintegrationcloudinstance/ic/ws/integration/v1/flows/soap/"
        },
        {
            "name": "Customers API",
            "targetURL": "https://oracleintegrationcloudinstance/ic/ws/integration/v1/flows/soap/"
        }
    ]
}

Dentro del arreglo de APIs, vamos a colocar todas las APIs que necesitamos mover de una instancia (fuente) a otra (destino).

Una vez creado el descriptor, se debe subir al repositorio de Git para conectar el job que realizará el despliegue automático. Así, cada vez que se decida mover APIs de una instancia a otra, se deberá modificar el descriptor y hacer commit de los cambios al repositorio.

Es hora de crear el job.

Parámetrización del job

Para hacer dinámico el job que automatiza el despliegue, es necesario colocar algunos parámetros que podamos cambiar a la hora de ejecutarlo. De esta forma, si las instancias cambian, la ejecución del job será dinámica y se adaptará a nuestras necesidades. Los parámetros que colocamos son los siguientes:
  • Descriptor: nombre del archivo descriptor que se subirá al repositorio. El contenido deberá tener la información de las APIs que se necesitan mover de un ambiente a otro.
  • GetTokenURL. URL de la API que utilizaremos para obtener el token de acceso. Normalmente esta es la URL de Oracle Identity Cloud Service.
  • ClientCredsSource. Client ID y client secret de la aplicación origen que utilizaremos para consumir las APIs.
  • ClientCredsTarget. Client ID y client secret de la aplicación destino que utilizaremos para consumir las APIs.
  • UsernameSource. Usuario para obtener el token de acceso en la instancia origen.
  • PasswordSource. Password para obtener el token de acceso en la instancia origen.
  • ScopeSource. Scope para obtener el token de acceso en la instancia origen.
  • URLEnvSource. URL de la API de la instancia origen de Oracle API Platform.
  • UsernameTarget. Usuario para obtener el token de acceso en la instancia destino.
  • PasswordTarget. Password para obtener el token de acceso en la instancia destino.
  • ScopeTarget. Scope para obtener el token de acceso en la instancia destino.
  • URLEnvTarget. URL de la API de la instancia destinode Oracle API Platform.
  • GatewayID. Identificador del Gateway donde vamos a desplegar las APIs.
Los parámetros anteriores nos ayudan a ejecutar el job con valores dinámicos. Así, si la instancia fuente o destino cambia, lo único que es necesario es cambiar los valores de esos parámetros.

Scripting

La estrategia para realizar la automatización fue ejecutar un bash script. La mayoría de las APIs de Oracle están ejemplificadas con el uso de cURL. Por esta razón decidimos escribir un bash script y ahí encapsular las llamadas a las APIs con el uso de cURL.

Sin embargo, es posible codificar la automatización en cualquier otro lenguaje. Aquí lo importante es que sepamos cómo consumir REST APIs con ese lenguaje. Incluso es posible crear un plugin de Maven o Gradle para este propósito.

Validaciones

Antes de ejecutar la automatización, debemos hacer algunas validaciones. En mi caso las validaciones que hice al contenido del descriptor fueron las siguientes:
  • El archivo JSON tiene una estructura válida y cumple con la definición de la estructura del descriptor.
  • El archivo incluye la información de al menos una API a desplegar.
Procedimiento de despliegue

Los pasos para realizar el despliegue, después de librar todas las validaciones del archivo, son los siguientes:
  • Obtener un token de acceso del ambiente origen: POST /oauth2/v1/token
  • Obtener las APIs del ambiente origen: GET /apiplatform/management/v1/apis
  • Validar que todas las APIs del descriptor, se encuentran desplegadas y activas en el ambiente origen. Esto es necesario, pues del ambiente origen se va a tomar toda la definición de cada API. Si no están desplegadas o activas, no podemos tomar la definición de ese ambiente: GET /apiplatform/management/v1/apis/{id}/deployments
  • Obtener un token de acceso del ambiente destino: POST /oauth2/v1/token
  • Obtener las APIs del ambiente destino: GET /apiplatform/management/v1/apis
  • Si la API origen existe en el destino: actualizar la definición con el detalle del origen y con el endpoint del descriptor (targetURL): PUT /apiplatform/management/v1/apis/{id}
  • Si la API origen no existe en el destino: crear la API en el ambiente destino con el detalle del origen y con el endpoint del descriptor (targetURL): POST /apiplatform/management/v1/apis
  • Desplegar la API en el ambiente destino: POST /apiplatform/management/v1/apis/{id}/deployments
Posibles errores

En caso de que exista un error en alguno de los pasos anteriores, el proceso se detiene y se reporta la causa del error. Algunas causas de error pueden ser las siguientes:
  • Información de credenciales incorrecta: usuarios, passwords, client credentials
  • Las APIs listadas en el descriptor no se encuentran desplegadas y/o activas en el entorno origen
  • Hay alguna dependencia en el entorno origen que no está configurada en el entorno destino. Por ejemplo los service account.
Conclusiones

Crear un mecanismo de automatización de despliegue de las APIs desplegadas en Oracle API Platform Cloud Service es una buena idea, pues a menudo se pueden presentar escenarios donde es necesario mover los artefactos de una instancia a otra. Esto puede suceder por distintas razones: se actualizan los servicios de nube, en un escenario de DRP, en caso de tener distintas instancias para distintos ambientes (Dev, Staging, Prod).

La reacción oportuna a alguno de estos escenarios, se verá beneficiada por la automatizacion y evitará el esfuerzo de crear nuevamente cada uno de los artefactos (APIs, Gateways, Planes, entre otros).

El uso de Developer Cloud Service es una buena alternativa para concentrar estas estrategias, pues es una plataforma que podemos utilizar de manera transparente para integrar con distintas nubes de Oracle, ya sea a través del uso de las APIs o a través de la propia CLI de Oracle. Aquí mismo podemos documentar y dar seguimiento al proceso y tareas de automatización. Personalmente he utilizado esta nube para automatización de despliegues de:
  • Microservicios (Helidon, Quarkus) hacia Oracle Kubernetes Cluster.
  • Oracle SOA Suite (Service Bus y SOA Composites) hacia entornos OnPremise y Cloud.
  • APIs en Oracle API Platform Cloud Service
  • Integraciones en Oracle Integration Cloud Service
  • Funciones en Oracle Functions (FaaS)

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.