Mostrando entradas con la etiqueta Scala. Mostrar todas las entradas
Mostrando entradas con la etiqueta Scala. Mostrar todas las entradas

domingo, 6 de enero de 2019

Use an Akka actor as stream source

This is my first english post, so please bear with me 😅

I've recently started toying with Akka Streams, by trying to add it to an existing Akka HTTP API that I have created to crawl and aggregate data from other APIs and websites. I thought it would be nice to finally put them in practice, and that it was a good place to start because the project involves some data transformation and processing.

sábado, 14 de julio de 2018

Finch vs Akka Http: Hola mundo en Scala


Hace varios días, buscando artículos sobre Scala en Medium, encontré un artículo sobre cómo crear una aplicación de lista de tareas utilizando Finch, que me llamó la atención. Este tenía un enlace a un artículo titutlado ¿Qué tan rápido es Finch?. En este artículo se mostraba el siguiente tweet con una gráfica comparativa de la velocidad de distintas librerías HTTP de Scala:



Siendo fanático de Scala, y estando acostumbrado a las herramientas más divulgadas para servicios web tales como Play Framework, Spray y Akka HTTP, me llamó bastante la atención que Finch mostrara por mucho un mejor desempeño que estas herramientas, a pesar de que la publicación tiene más de 2 años (publicada en febrero de 2016, vista por mí a principios de 2018). Así que me dio curiosidad de ver qué era Finch, hacer una pequeña prueba, y comparar el código con una aplicación similar con Akka HTTP.

¡Hola Finch!

Finch es una API de Scala para construir servicios HTTP sobre Finagle, la cual es un "sistema RPC extensible para la JVM, utilizado para la construcción de servidores de alta concurrencia", utilizando APIs uniformes de cliente y servidor agnósticas del protocolo (creo q podría describir a Finagle como el WCF para la JVM). En este sentido, Finch provee una delgada capa de bloques para construir APIs HTTP de forma tipada, utilizando conceptos de programación funcional. Esto convierte a Finch en una excelente herramienta para la creación de microservicios, ya que es más fácil integrarlos utilizando tipos compartidos. Cabe mencionar además que Finagle corre sobre Netty, por lo que no requiere de un servidor web separado.

Debido a que Scala es para mí más un pasatiempo, ya que no lo uso en mi trabajo, me costó un poco entender cómo se definía una API en Finch. Después de batallar un par de horas, pude crear el siguiente Hola Mundo, en un solo archivo:



Nótese que la API se compone de un solo endpoint, el cual es pasado como parámetro al servidor HTTP, para ser servido (valga la redundancia). Luego el programa queda en espera mientras el servicio se mantiene en ejecución. Las rutas se definen para cada endpoint, y los separadores utilizados en código son un par de dos puntos (::). Por otra parte, para la serialización de los datos desde y hacia JSON se usa Circe (antes llamada "JSON para gatos", vaya usted a saber por qué, jejeje).

El código completo pueden encontarlo acá: https://github.com/guillegr123/its-hellofinch

El proyecto se ejecuta utilizando SBT, con el siguiente comando:
sbt run
Luego, para probar el servicio, abrimos en el navegador la ruta: http://localhost:8080/api/v1/hello

Lo que más me gustó de Finch es que es que la creación de servicios web requiere poco código, y permite crear una API tipada desde el principio, pudiéndose definir los modelos de datos utilizados en el request y el response. Además, los endpoints son asíncronos, lo que permite una mayor concurrencia, razón de su excelente desempeño.

Pero... luego de algunas pruebas, y de investigar un poco, descubrí que Finch no hace uso de las clases estándares de Scala para programación asíncrona, sino que usa las implementaciones propias del ambiente de Twitter, por lo que obligatoriamente tendremos que hacer uso de sus librerías. Esto además, aunque no imposibilita, hace un poco más engorroso integrar librerías que hacen uso de las clases estándar de Scala. En este sentido, me parece mejor utilizar Finch para aplicaciones pequeñas, o aplicaciones de microservicios en las que hagamos uso extensivo de Finagle y las librerías de Twitter.

¡Hola Akka HTTP!

Descubiertos estos detalles de Finch, y habiendo saciado mi curiosidad de probar el framework, decidí volver a mis raíces con Akka HTTP. Akka HTTP es el reemplazo de Spray, y es considerada más como una librería en lugar de un framework, ya que su principal objetivo es solo proveer herramientas para cubrir las necesidades de integración de una o varias aplicaciones vía HTTP, en lugar de lineamientos sobre los cuáles construir la aplicación. Como tal no provee manejo de componentes como CSS/Javascript, plantillas para creación de vistas y otras herramientas orientadas a aplicaciones para navegadores web.

La construcción del hola mundo utilizando Akka HTTP me costó menos que Finch, debido a que ya había hecho una prueba hace mucho tiempo (y el código fuente estaba en control de versiones). El servicio se creó en un solo archivo, al igual que el ejemplo anterior:



El código completo puede encontrarse acá: https://github.com/guillegr123/its-helloakkahttp

Al igual que con el proyecto de Finch, para ejecutar el servicio, basta ejecutar el comando:

sbt run

Y para probar el servicio, abrimos en el navegador la ruta: http://localhost:8080/api/v1/hello
 
A simple vista, el código es más grande. Esto se debe a que Akka HTTP usa los actores de Akka para el manejo de concurrencia, por lo que es necesario crear un sistema de actores, un materializador de actores, y obtener el contexto de ejecución. Además, para la serialización de los mensajes a JSON, es necesario definir un trait para el formateo del mensaje.

Aparte de eso, en esencia la definición de los endpoints es similar. Las rutas se establecen para cada enpoint, pero usando la barra diagonal (o pleca) como separador, lo que resulta un poco más natural que los dos puntos de Finch, pero que sirven al mismo propósito. Los enpoints son asíncronos, pero a diferencia de Finch, usa la implementación de Futures estándar de Scala.

De forma similar a Finch, la instancia de rutas de la API es pasada como parámetro a su propio servidor web, el cual es iniciado. Sin embargo, en este caso no utiliza una librería externa como Netty, sino que se ejecuta sobre los actores y los flujos de Akka, y activa un puerto para hacer uso directo del protocolo HTTP.

Por otra parte, a diferencia de Finch, al finalizar el servicio web, es necesario desconectar el servidor web explícitamente del puerto, y finalizar el sistema de actores.

Conclusiones

Luego de estas pequeñas pruebas, considero que ambas librerías son excelentes, pero poseen enfoques diferentes, así como implementaciones, por lo que pueden usarse de distintas formas. Akka HTTP parece ser la mejor opción cuando tenemos una aplicación creada utilizando las librerías estándar de Scala, o bien actores de Akka, y solo necesitamos integrar sus componentes u otras aplicaciones vía HTTP. Y Finch parece ser una buena elección cuando necesitamos crear interfaces web tipadas, o sistemas de microservicios que deseamos integrar de forma fácil, ya que también facilita la creación de clientes.

En cuanto al desempeño, según el workbench mostrado por Vladimir Kostyukov, Finch es mucho más rápido que Akka HTTP. Sin embargo, la comparativa fue realizada hace dos años, cuando Akka HTTP aún estaba en pañales, por lo que quedamos a la espera de una comparación más reciente. En lo personal espero más Akka HTTP por ser considerado el reemplazo de Spray.

jueves, 24 de agosto de 2017

Instalar SBT en Linux


Saludos. En esta entrada explicaré como instalar la Scala Build Tool en Linux. Los pasos los describo a continuación:
  1. Descargar la última versión de SBT desde la página de descargas oficial: http://www.scala-sbt.org/download.html
  2. Descomprimir el paquete descargado. Para efectos de este mini-tutorial, se descargó la versión 1.0.0 en paquete TGZ, y por cuestiones de orden, se descomprimirá en el folder /opt, por lo que en este caso los comandos a ejecutar son:

    $ su        # Iniciar sesión en modo súper usuario
# mkdir sbt      # Crear directorio sbt, para colocar acá todas las versiones de SBT
# cd sbt         # Navegar al directorio sbt
# tar -xvzf /home/usuario/Downloads/sbt-1.0.0.tgz    # Descomprimir el paquete
  3. Hacer que el script sbt sea ejecutable:

    # chmod u+x sbt-1.0.0/bin/sbt
  4. Crear la variable de ambiente SBT_HOME, y agregar la ruta que contiene el script sbt a la variable de ambiente PATH. Para ello, se agrega al final del archivo ~/.bash_profile las siguientes líneas (para establecer las variables para terminales bash para el usuario actual):

    export SBT_HOME="/opt/sbt/sbt-1.0.0"
export PATH="${PATH}:${SBT_HOME}/bin"
  5. Cerrar sesión e iniciar sesión nuevamente, para cargar las nuevas variables de entorno. Luego de ello, podemos abrir la terminal, y ejecutar el comando sbt, el cual ya estará disponible.

lunes, 20 de junio de 2016

Instalar Lightbend Activator en Windows

Estaba intentando preparar las herramientas para probar hacer una aplicación usando Scala y Play Framework en mi computadora, solo que en esta ocasión en Windows 10. Sin embargo, intentando "instalar" el Lightbend Activator, me topé con algunos problemas inesperados particulares para Windows, y que tristemente parecen existir desde hace ya algunos años. A continuación comparto los pasos que pude seguir para preparar el Activator en Windows, en caso de quee alguien más tenga problemas, y también para recordarle al yo del futuro como hacer esto, en caso de que tenga que hacerlo en otra máquina.
 

1. Descargar e instalar el Java JDK 1.8

Para poder usar el Lightbend Activator necesitamos instalar el Java JDK 1.8 (al fin y al cabo Scala compila a bytecode de Java, y corre sobre la JVM). Podemos descargar el instalador de la última actualización de la versión 1.8 para Windows desde la página de Oracle, para la arquitectura de nuestra computadora (i586 - 32 bits - o x64 - 64 bits).

Una vez descargado el instalador, procedemos a ejecutarlo, para realizar la instalación, siguiendo los pasos indicados (a.k.a. presionar Next hasta finalizar).
 

2. Crear la variable de entorno JAVA_HOME

Es necesario crear la variable de entorno de Windows llamada JAVA_HOME, para que haga referencia al directorio donde se instaló el JDK. El script del Lightbend Activator hará uso de esta variable para encontrar el JDK, que necesita para ejecutarse. Acá hay un tutorial que muestra cómo hacer este paso.
 

3. Descargar el Lightbend (Typesafe) Activator

Para descargar el Lightbend (antes Typesafe) activator, hay que visitar el sitio web de Lightbend. En la parte de abajo hay un listado de enlaces, entre los cuales está uno que dice Download Activator (créanme que me costó encontrar el enlace).

 
Luego, en la página de descarga, basta con presionar el botón Download, que descargará la versión completa (entre 600 y 700 Mb) y más reciente disponible (v1.3.10 al momento de escribir esta entrada). Lo que se descarga es un archivo ZIP, por lo que podemos guardarlo en cualquier parte.


 4. Descomprimir el Lightbend Activator

Una vez descargado el Activator, es necesario descomprimirlo. Si solo lo vas a utilizar con tu usuario, puedes descomprimirlo en cualquier carpeta dentro de tu directorio de usuario. Si quieres que otros usuarios pueda utilizarlo, te recomendaría hacerlo en una ruta más pública, como por ejemplo C:\Development\Lightbend o algo así. Un punto importante es que la ruta donde coloquemos el Activator no debe tener espacios.

5. Agregar la ruta de los binarios del Activator a la variable PATH

Para poder utilizar el Activator desde la línea de comandos, sin necesidad de conocer el directorio de instalación de este, es necesario agregar la ruta de la carpeta de binarios (carpeta bin dentro del directorio del activator - por ejemplo activator-dist-1.3.10\bin) a la variable de entorno PATH. Nuevamente, si solo vamos a utilizar la aplicación con nuestro usuario, modificaremos la variable propia de nuestro usuario; y si la van a utilizar todos los usuarios, agregamos la ruta a la variable PATH de sistema. Este y este otro son algunos tutoriales que muestran como agregar valores a la variable PATH de Windows.

6. Corregir el archivo de activator.bat

Sí, triste pero cierto, hay que corregir un archivo. El archivo activator.bat se ubica en la carpeta de binarios (bin). Hay que abrir el archivo con cualquier editor de texto, buscar la línea que dice:

set SBT_HOME=%BIN_DIRECTORY

Y agregar el símbolo de porcentaje faltante al final de esta, para que quede así:

set SBT_HOME=%BIN_DIRECTORY%

Luego guardamos el archivo y continuamos con nuestra vida. O podríamos modificarlo para que se pueda colocar el Activator en rutas con espacios (recordar el punto No. 4... pero tal vez en otra ocasión).

7. Agregar el archivo sbtconfig.txt

¡No tan rápido! Si intentamos ejecutar el Activator desde la línea de comandos, nos mostrará el siguiente mensaje:

The system cannot find the file C:\ruta\al\lightbend\activator-dist-1.3.10\bin\..\conf\sbtconfig.txt.

Para corregir esto debemos agregar el archivo en la ruta especificada. El archivo lo podemos descargar desde el repositorio del SBT Launcher en GitHub, y lo guardamos en la ruta activator-dist-1.3.10\conf\

8. Ejecutar el Activator

¡Finalmente! Abrimos la línea de comandos, y ejecutamos el siguiente comando (valga la redundancia):

activator ui

Esto abrirá una ventana en el navegador que tengamos por defecto, en donde se mostrará la interfaz de usuario del Activator, con los listados de tutoriales y proyectos base para poder empezar a trabajar con las herramientas de la plataforma reactiva de Lightbend (las que sean gratis, al menos).

lunes, 13 de abril de 2015

Preparar Eclipse Luna para Scala y Play Framework 2


Para desarrollar una aplicación en estos días, es recomendable usar un IDE que facilite el trabajo y brinde las herramientas necesarias para realizarlo. Si vas a desarrollar una aplicación con Play Framework 2.x y Scala, mi recomendación personal es usar Scala IDE. El IDE completo consiste en una versión de Eclipse, pre-configurada de manera especial con el plugin de Scala y Play Framework, entre otros componentes, para el desarrollo de aplicaciones con el lenguaje Scala, y en particular con Play Framework 2. Es posible descargar el IDE completo, pero si ya cuentas con Eclipse, entonces puedes instalar los plugins, siguiendo los pasos que se describen a continuación:

Visita la pagina de descargas estables de Scala IDE, y obtén la URL de los sitios de actualización disponibles para tu version de Eclipse. Para el caso de este post, se utilizara la versión 4.0 de Scala IDE (que es la última disponible al momento de escribirlo), sobre Eclipse Luna, por lo que la URL de actualizacion es: http://download.scala-ide.org/sdk/lithium/e44/scala211/stable/site




Añade el plugin de Scala IDE a Eclipse. Para ello se selecciona la opción Help > Install New Software en el menú de Eclipse.


En la ventana que aparecerá en pantalla, deberá colocarse la URL para descargar la actualización en la parte superior (campo Work with), y presionar el botón Add.


Aparecerá una ventana en la que habrá que asignar un nombre a la fuente (puede ser cualquier nombre). En el caso de este ejemplo, se le llamó Scala IDE (Scala 2.11.6), para indicar que de esta web se descargan los plugins relacionados a Scala IDE, especializados para la vesión 2.11.6 de Scala.



En la tabla del medio aparecerá el listado de plugins que pueden descargarse desde la web proporcionada. De ellos, se deberá seleccionar la opción completa Scala IDE, y la opción Scala IDE plugins (incubation) > Play2 support in Scala IDE. El primero de ellos sirve para trabajar con Scala en general, usando Eclipse. El segundo de ellos es especializado para Play Framework 2, pues incluye soporte particular para este, incluyendo auto-completar código fuente, manejo de plantillas de Scala, embellecimiento de código fuente y auto-completación, para el archivo de rutas.



Luego de elegidos los plugins, se presiona el botón Next. Se presentará una pantalla en la que Eclipse presenta el listado de todos los componentes a instalar. Puede notarse que además de los seleccionados, se incluye el SDK de Scala (Scala 2.11.6, en este caso), y el Scala Build Tool (SBT). Una vez verificado el listado, se presiona el botón Next.


Como último paso previo a realizar la instalación, se solicita que leas la licencia de los componentes a instalar. Si estás conforme con todas ellas, basta con seleccionar el botón de radio que dice I accept the terms of the license agreements, y presionar el botón Finish, para que Eclipse comience la descarga e instalación de los plugins.


Habrá que esperar algunos minutos para que se complete el proceso. Cuando se haya finalizado la instalación, aparecerá una ventana de diálogo indicando que es necesario reiniciar Eclipse, para que los cambios tengan efecto, y que si lo deseas reiniciar en este momento. Si no tienes trabajo pendiente de guardar, puedes presionar el botón Yes, para que el programa se reinicie. Si aún no deseas cerrar Eclipse, puedes hacerlo más tarde, pero los plugins no serán activados hasta que vuelvas a iniciar Eclipse.


Al iniciar Eclipse, posiblemente se muestre una advertencia, indicando que algunas de las configuraciones no son adecuadas para Scala IDE. Para ejecutar un diagnóstico de estas configuraciones, presiona el botón Yes.


En este caso se mostrará una ventana indicando algunas configuraciones particulares para Scala IDE. Si no tienes una configuración especializada de Eclipse, te sugiero usar las configuraciones recomendadas por defecto (Use recommended default settings). También presta atención a la sección de Heap settings, que se refiere a las configuraciones de memoria de Pila de la Java Virtual Machine: para Scala se recomienda un valor máximo de al menos 1024Mb. En este caso el valor que se tiene es de 455Mb. Para ajustar este valor, habrá que hacerlo editando el archivo eclipse.ini, lo cual haremos en el siguiente paso. Por el momento, solo presionamos el botón Ok, para establecer las configuraciones por defecto, y una vez iniciado Eclipse, lo cerramos.


Para modificar el tamaño de la memoria de la JVM usada en Eclipse, hay que abrir el archivo eclipse.ini, con un editor de texto, y posiblemente en modo administrador (dependiendo de donde se haya instalado Eclipse, y el sistema operativo). Este archivo está ubicado en el directorio donde se instaló Eclipse (ver la ruta que apareció en la ventana de configuraciones). En este archivo hay que buscar la línea que inicia con -Xmx, y modificar el valor que le sigue por el requerido. La línea quedaría así: -Xmx1024m


Guardamos los cambios, y volvemos a abrir Eclipse. Ahora notarán que el programa abre sin mostrar ninguna advertencia. Finalmente, antes de trabajar con Play Framework, se recomienda ajustar el IDE para refrescar cambios externos, para detectar los cambios realizados por los comandos de la consola de Play (o bien del Activador de Typesafe, o el SBT, según la herramienta que se esté usando). Para ello, se selecciona el menú Window > Preferences.


Se abrirá una nueva ventana. En el árbol de opciones de la izquierda, se selecciona el ítem General > Workspace. En el lado derecho seleccionamos la opción Refresh using native hooks or pooling, y presionamos el botón Ok.


Y esto es todo, el IDE ya está listo para trabajar con proyectos de Scala, y en particular de Play Framework 2.
Con la tecnología de Blogger.