PDF de programación - Creación de servicios web Biomoby

CREACIÓN DE SERVICIOS WEB

BIOMOBY



Fernando Barranco Muros

Tabla de contenidos

Servicios web BioMoby.......................................................................................................................3
Creación de un Servicio Web BioMoby Usando MOSES..............................................................5
Pre-requisitos.............................................................................................................................5
Registro del servicio...................................................................................................................7
Implementación del servicio......................................................................................................9
Despliegue del servicio............................................................................................................12

Servicios web BioMoby

Un servicio web cuenta con cuatro etapas, siendo todas necesarias para poder crear un

servicio web BioMoby:

i. Registro del servicio: Todos los servicios BioMoby tienen que estar registrados en un
repositorio, con la información necesaria para que pueda ser accedido por cualquier cliente
BioMoby sin necesidad de conocer nada del servicio. Esta información incluyen la url
donde se encuentra el servicio (llamado endpoint), descripción, entradas y salidas del
mismo, autor, categoría del servicio etc.

ii. Proporcionar la capa de comunicación con los servicios web. Esta capa debe proporcionar
una forma de comunicarse con el cliente de manera conocida. BioMoby usa el protocolo
SOAP para comunicarse.

iii. Soporte para el contenido de los mensajes en formato BioMoby (el contenido de los
mensajes xml SOAP, llamados MOBY Object). Esto incluye por ejemplo los parámetros de
entrada y salida en el formato BioMoby.

iv. La lógica del servicio. Esta etapa será distinta para cada servicio, y es realmente lo que hace
nuestro servicio. La etapa anterior proporcionara los parámetros de entrada, y deben
proporcionar soporte para el resultado del servicio.

Al contrario de los servicios web tradicionales SOAP, en BioMoby sólo hay una

operación por servicio, debiendo crear distintos servicios para cada operación que queramos.

La etapa primera, el registro del servicio, puede ser cubierta registrando los servicios
creando los mensajes xml de forma manual o usando algún script existente para enviarlas al
repositorio. Sin embargo existen varias aplicaciones (tanto web como de escritorio) que pueden
facilitarnos el registro, como Dashboard.

La segunda etapa se puede cubrir usando alguna implementación SOAP existente como

Apache Axis o JAX-WS.

Para el formato de BioMoby podríamos hacer una implementación propia del protocolo
de BioMoby (para cumplir la etapa 3) que incluiríamos como el contenido del mensaje SOAP a
enviar para la transmisión de los mensajes. Debido a la complejidad de implementar un protocolo
de mensajes XML como BioMoby, buscaremos APIs existentes para la creación de los mensajes
BioMoby, encontrando varias opciones. Por un lado se proporcionan ciertas APIs oficiales, para
varios lenguajes, Java y Perl. Además existen otras APIs creadas por terceros, como puede ser la
mAPI (“Modular API”, desarrollada por el grupo Bitlab de la Universidad de Málaga) o la API del
BSC (“Barcelona Supercomputing Center”). Además algunas de estas APIs proporcionan soporte
para el protocolo de comunicación SOAP, resolviendo la etapa 2.

Existen varios tipos, y tenemos que diferenciar la parte del cliente de la parte del
servidor. La parte del servidor permite crear servicios web BioMoby, mientras que la parte del
cliente es la que proporciona soporte para llamar los servicios ya creados y registrados en algún
repositorio. Para crear los servicios pues nos interesa que soporten el lado del servidor.

Dentro del soporte oficial de BioMoby, hay dos vertientes, usando MOSES (Moby
Services Support), o bien codificando los servicios haciendo las llamadas a la API del repositorio
BioMoby correspondiente. La API de Java se llama jMoby.

La primera opción requiere una preparación previa, pero proporciona una implementación

•

•

del servicio muy sencilla proporcionada por la generación automática del código necesario,
teniendo que preocuparse únicamente de la lógica del servicio, además de proporcionar
soporte para el llamado deploy del servicio. Solo es necesario registrar el servicio y se
generará automáticamente el código necesario para que no nos tengamos que preocupar por
la capa de Moby.
La segunda opción, llamada MobyServlet (“Semantic Web Service Provision: a Realistic
Framework for Bioinformatics Programmers” Paul M. K. Gordon *, Quang Trinh and
Christoph W. Sensen ) no requiere apenas preparación, pero es más difícil de implementar
ya que requiere algo de conocimiento interno de la API de Moby y a la hora de ejecutarse es
más lenta debido a que no tiene nada de información (la primera vez que se ejecuta un
servicio puede tardar unos 15 segundos, aunque las llamadas siguientes irán mucho más
rápido). Por contra, no será necesario registrar el servicio, ya que al usar anotaciones, el
registro se hará automáticamente. Más información:

http://biomoby.open-bio.org/CVS_CONTENT/moby-live/Java/docs/deployingServices.html

La API del BSC es parecida a la de MOSES , ya que tiene generadores de esqueletos de
los servicios (código básico que provee de la funcionalidad básica para la creación de los servicios
web), donde solo hay que preocuparse de la lógica del servicio. Tiene implementados futuras
ampliaciones, como son el asincronismo de la codificación document-literal, aunque no soporta el
asincronismo RCP , que es el oficial BioMoby. Soporte para clientes y servidores.

La mAPI proporciona soporte para poder llamar a servicios BioMoby, además de otros
como WSDL. Puesto que está pensada como una API genérica, su uso es el mismo para cualquier
tipo de servicio web a llamar. Tiene un enfoque genérico donde se usan objetos no generados, que
aunque son algo más tediosos de usar, hace que no requiera generar ni servicios ni los tipos de datos
que usa el mismo.

A continuación mostramos una tabla que compara algunas de las opciones disponibles,

ayudándonos a elegir cuál usar para nuestros propósitos:

API
MOSES
(jMoby)

TIPO LENGUAJE ASYNC
C/S

Java

MobyServlet C
Api BSC

C/S

mAPI

C

Java
Java

Java

Solo
para
clientes
No
No
oficial
SI para
clientes

SI

USABILIDAD



de

implementar

Fácil
(con
generadores, previo registro). Cuanta
con varios pre-requisitos para usarla.
Sin pre-requisitos. Lenta.
Fácil de usar. Usa generadores.
Usa JAX-WS.
Sin lado del servidor. Muy genérica,
proporcionando soporte para otros
tipos de Servicios Web.
Soporta asincronismo. Difícil de
implementar. Usa Perl.

ETAPAS

2 y 3

1, 2 y 3
2 y 3

2* y 3*

C/S

Moses (Perl
API)
Table 1: Comparación de las APIs. C: Cliente, S:Servidor, etapa1:registro, etapa2:SOAP, etapa3:formato Moby

2 y 3

Perl

*:Solo lado del cliente.

Aunque la opción de MobyServlet es la mas directa, el hecho de necesitar de
conocimientos de o bien de ANT o bien compilación y deploy manual, hace que para usuarios poco
experimentados, como posibles biólogos desarrolladores de servicios, les pueda resultar demasiado

complicado. Así pues, para crear los servicios nos decantamos por la opción de MOSES , ya que
aunque requiere unos pasos previos, estos sólo hace falta hacerlos una vez (puede hacerlo algún
experto si el desarrollador no es especialista), para posteriormente realizar servicios de manera muy
sencilla, no requiriendo conocimientos profundos de la API de BioMoby, ya que se proporciona la
interfaz gráfica Dashboard con la cual el registro, generación y puesta en producción del servicio se
hace a golpe de un click. La API del BSC también cumple dichos requisitos, e incluso ocupa menos
espacio, pero usaremos esta debido al soporte “oficial” que posee. Usaremos jMoby (Java) debido
que es un lenguaje mucho más a gusto del autor, considerando a Perl un lenguaje, que aunque
ampliamente usado por los biólogos, está en declive, aunque en este caso sacrificaremos el
asincronismo de los servicios web, estando a la espera de una próxima implementación de dicha
característica para jMoby.

Creación de un Servicio Web BioMoby Usando MOSES

El proyecto MOSES (Moby Services Support) pretende proporcionar un soporte
completo a los desarrolladores de servicios web Moby. Debido a que los mensajes Moby son
simétricos (mensajes a y desde el servicio tienen la misma estructura) también proporciona soporte
para la creación de clientes. Usaremos MOSES para servicios java.

Las cuatro partes principales de MOSES son:

• Generación de código: Genera, dado un repositorio, tanto los tipos de datos (data types)

como los esqueletos de los servicios.

• Analizador y convertidor sintáctico (parser en inglés) para los mensajes Moby en xml.
•
•

Soporte de lado del cliente.
Soporte para el lanzamiento a producción (deploy) del servicio.

Aunque se puede desarrollar usando cualquier entorno de desarrollo (o ninguno), por
comodidad irá orientado al uso de Eclipse como IDE (entorno de desarrollo). En la siguiente
página,
http://www.eu-sol.net/science/bioinformatics/tutorials/jmoby-step-by-step/writing-
biomoby-web-services/copy_of_jmoby-step-by-step-tutorial, se puede tener información más
completa sobre su desarrollo con o sin eclipse.

Además, nos centraremos en un escenario posible en el mundo real, y es que se
desarrollarán los servicios Web en una o varias máquinas, pero habrá un servidor central que ya
estará configurado y listo para usarse con un contenedor de servlets (como Apache To