Download PRIMEROS PASOS CON SOFIA2

Sofia2
Primeros Pasos con
Sofia2 IoT Platform
Mayo de 2017
Índice
1
Paso a Paso con Sofia2 ....................................................................................................................... 3
1.1
Modela los datos: ................................................................................................................ 4
1.2
Conecta tu dispositivo ....................................................................................................... 10
1.2.1
Alta del dispositivo en la plataforma: ............................................................................... 10
1.2.2
Conexión física del dispositivo a través de cualquiera de los gateways IoT: .................... 13
1.3
Verifica el funcionamiento ................................................................................................ 20
1.4
Crear aplicaciones ............................................................................................................. 23
1.4.1
Crea tu dashboard visualmente ........................................................................................ 23
1.4.2
Crear reglas de forma guiada ............................................................................................ 31
1.4.3
Exponer información con un API REST .............................................................................. 42
Sofia2 – Guía Primeros Pasos
2
1 Paso a Paso con Sofia2
El siguiente flujo muestra los principales pasos a seguir para trabajar con el flujo IoT en Sofia2
A continuación se vamos a describir cada paso sobre la plataforma Sofia2, mediante un sencillo
ejemplo con un termostato de temperatura y humedad.
Nota: Hay que tener en cuenta que lo que vamos a describir es un flujo IoT sencillo sobre Sofia2. En
función del tipo de proyecto, algunos pasos pueden omitirse. Además, esta guía cubre un
subconjunto de la funcionalidad de Sofia2, y no se describen todas las herramientas proporcionadas
por la plataforma, por lo que solo tiene que ser tenida en cuenta como una primera toma de
contacto con Sofia2, para descubrir y afianzar conceptos, de manera que posteriormente sea más
fácil profundizar en la totalidad de capacidades de Sofia2.
Sofia2 – Guía Primeros Pasos
3
1.1
Modela los datos:
La plataforma Sofia2 funciona en torno a los datos enviados por los dispositivos o aplicaciones
conectados. Cualquier evento, medida, comando... se gestiona en la plataforma como un dato, que
es almacenado, puede ser consultado y además puede desencadenar ciertas acciones
(notificaciones, ejecución de reglas/flujos…).
Por lo que cada tipo de datos utilizados por un dispositivo o aplicación, se debe modelar y dar de
alta en la plataforma la correspondiente entidad, denomina Ontología. Una Ontología tiene los
siguientes propósitos:
 Definir semánticamente el tipo de datos, con sus atributos y restricciones.
 Definir el soporte físico (Colecciones, Tablas...) para el almacenamiento de datos tanto en
base de datos de tiempo real como en histórico.
 Definir las reglas de seguridad en el acceso a la información contenida en la ontología.
En la consola de administración de Sofia2 existen diferentes alternativas para crear una ontología.
En este caso utilizaremos la opción de Crear ontología paso a paso. Para ello, entramos en la
consola de administración y seleccionamos Ontologías > Crear Ontología
Sofia2 – Guía Primeros Pasos
4
Y a continuación Creación Paso a Paso:
Modelaremos una ontología para simular un termostato. Por lo que le daremos un nombre y la
marcaremos como Activa:
A continuación elegiremos la plantilla a partir de la que modelaremos la ontología. Una plantilla
permite crear una ontología con unos atributos por defecto. En función del proyecto es una opción
muy interesante, ya que la plantilla contiene una definición base de las ontologías a crear.
En nuestro caso elegiremos una plantilla vacía, para dar de alta nosotros mismos los campos de la
ontología:
A continuación damos de alta dos propiedades: temp y hum para representar las medidas de
temperatura y humedad enviadas por el termostato. Y además marcamos el campo
additionalProperties como false, para indicar la restricción de que no se admitirán otras
propiedades para este tipo de datos:
Sofia2 – Guía Primeros Pasos
6
Pulsamos Generar Esquema para generar el JSONSchema que define el tipo de datos de la
ontología:
Sofia2 – Guía Primeros Pasos
7
Y finalmente podemos Generar una Instancia con un dato de ejemplo para el tipo de datos
definido por esta ontología, y darla de alta en la plataforma pulsando Crear:
Sofia2 – Guía Primeros Pasos
8
Resumen:
Al finalizar este paso, habremos dado de alta en Sofia2 una ontología, caracterizada por:
 Definir el tipo de datos LecturaTermostato, Que tendrá dos atributos requeridos: temp y
hum. De forma que la plataforma solo admitirá Instancias que contengan esas dos
informaciones. Esto es datos en formato JSON del tipo: {“LecturaTermostato:”:{“temp”:
28.6, “hum”: 5}}
 Definición en Base de datos de tiempo real del soporte de almacenamiento para la
ontología. En una instalación de referencia (Con MongoDB como BDTR) esto se materializa
en una colección llamada LecturaTermostato¸ que será donde se almacenen en tiempo
real los datos.
 Definición en Base de datos histórica del soporte de almacenamiento de datos históricos
para la ontología. En una instalación de referencia (Con Hive sobre Hadoop como BDH)
esto se materializa en una tabla Hive llamada LecturaTermostato¸ que será donde se
almacenen los datos cuando su ventana de tiempo real finalice.
 Definición de permisos sobre la ontología. En este caso solo tiene permiso el propietario,
ya que fue declarada como privada. No obstante, desde el menú de ontologías, el
propietario puede dar permisos (Lectura, Escritura o Total) a usuarios concretos, o a grupos
de usuarios con los que tenga proyectos comunes
(https://about.sofia2.com/2016/09/07/concepto-de-grupo/).
Gráficamente hemos intervenido en los siguientes componentes de la plataforma:
Sofia2 – Guía Primeros Pasos
9
1.2
Conecta tu dispositivo
La conexión de dispositivos es el modo de conectar la plataforma al mundo físico. Hay que tener
en cuenta que por “dispositivo” se entiende cualquier aplicación o sistema, que
independientemente de su tamaño (Desde un simple sensor, hasta un sistema empresarial) es
capaz de enviar/consumir información con la plataforma a través del Gateway IoT de Sofia2.
Como nota, cabe destacar que este no es único modo para cargar datos en Sofia2 ni de conectar
otros sistemas. En función del tipo de necesidad existen otras alternativas: Api Manager, Ficheros
Excel, Tablas Hive, Fuentes Open Data, Escuchas activas a Apis de Internet, e incluso plugins de
interconexión a medida.
La conexión de un dispositivo a la plataforma consta de dos pasos:
 Alta del dispositivo en la plataforma
 Conexión física del dispositivo a través de cualquiera de los gateways IoT (MQTT, REST, Ajax,
Websocket)
1.2.1
Alta del dispositivo en la plataforma:
Consiste en el registro en Sofia2 de una nueva aplicación, que utilizará la plataforma como
backend. Permite que cuando la aplicación haga una solicitud para enviar/consultar datos con la
Sofia2 – Guía Primeros Pasos
10
plataforma, está la identifique, verifique sus credenciales así como si tiene permiso de acceso a la
información solicitada.
En Sofia2, una aplicación se conoce como ThinKP, de manera que para dar de alta el dispositivo es
necesario registrar un nuevo ThinKP. Para ello, en el menú de la consola de administración
THINKPS SOFIA2 > Mis ThinKPs
Y seleccionar Nuevo ThinKP:
Dar un nombre y descripción al ThinKP así como seleccionar las ontologías que va a utilizar y pulsar
Crear. Finalizado este proceso ya tendremos la aplicación dada de alta en Sofia2.
En nuestro caso daremos de alta un ThinKP llamado AppTermostato, que representará a los
termostatos físicos que conectaremos a la plataforma.
Sofia2 – Guía Primeros Pasos
11
Y por defecto se habrá creado un token de autenticación que podemos consultar en la pestaña
Mis Tokens
Este token de autenticación se utilizará por los dispositivos y aplicaciones para autenticarse en
la plataforma Sofia2 y de este modo establecer una conexión con la misma para enviar/consultar
información.
Un ThinKP puede tener tantos tokens activos como sea necesario. La gestión de Tokens se hace
desde la consola de administración en la pestaña Mis Tokens pudiendo generar nuevos tokens e
invalidar otros ya existentes.
En esta sección cabe destacar también la pestaña Mis Instancias en este caso vacía ya que
todavía no hemos conectado ninguna aplicación física a la plataforma:
Sofia2 – Guía Primeros Pasos
12
Una Instancia de un ThinKP representa a una aplicación en ejecución, de manera que un ThinKP
lógico (en nuestro caso AppTermostato) puede tener varias Instancias en ejecución (Por ejemplo
TermostatoDormitorio, TermostatoSalón, TermostatoCocina…) de manera que no es necesario
registrar todas las instancias de forma individual en la plataforma, sino que cada instancia, al
iniciar conexión indicará de que instancia en concreto se trata.
1.2.2
Conexión física del dispositivo a través de cualquiera de los gateways IoT:
En este punto ya podemos conectar aplicaciones reales a Sofia2. Recordemos:
 Hemos creado la entidad de datos (ontología) que almacenará la información que
enviaremos.
 Hemos registrado un ThinKP que representa nuestra aplicación y que dispone del token de
autenticación necesario para conectarse a la plataforma.
Antes de pasar a desarrollar, introduciremos el Protocolo SSAP. Se trata del protocolo de
mensajería utilizado para conectar los dispositivos con el IoT Broker de Sofia2. En concreto es el
protocolo que comunica las fuentes IoT con el Broker de Sofia2:
Sofia2 – Guía Primeros Pasos
13
SSAP un protocolo lógico, basado en formato JSON, que define un conjunto de mensajes para
que las aplicaciones puedan comunicarse con el IoT Broker de Sofia2. Es independiente del
protocolo de transporte físico (MQTT, Ajax/Push, Websocket, REST…), es decir, los mensajes
SSAP se encapsulan por el protocolo físico elegido.
Permite:
 Abrir/Cerrar sesión con el SIB.
 Insertar nueva información (tanto de ontologías como de estado de la aplicación)
 Consultar/Actualizar Información.
 Suscribirse/Desuscribirse a eventos.
Para más información sobre el protocolo SAAP, consultar el blog de Sofia2
 https://about.sofia2.com/2014/04/14/conociendo-el-protocolo-de-interoperabilidad-desofia2-ssap/
 https://about.sofia2.com/2014/10/09/mensaje-ssap-bulk/
 https://about.sofia2.com/2017/02/21/mejoras-en-protocolo-ssap/
 https://about.sofia2.com/2014/04/27/conociendo-las-apis-de-sofia-2-api-restful/
Lo siguiente es pasar a desarrollar la aplicación que se ejecutará en el dispositivo y que a través
del protocolo SSAP, enviará/consultará información al IoT Broker de Sofia2.
Para desarrollar una aplicación abstrayéndose de las complejidades de los protocolos físicos de
conexión, así como simplificar el tratamiento de mensajes SSAP, Sofia2 pone a disposición de los
desarrolladores un ejemplo de KP Java que se puede descargar a través de la consola de
administración, para ello seleccionamos Vistra Tradicional en la pantalla principal:
Sofia2 – Guía Primeros Pasos
14
Se cargará una vista distinta de la página principal de la consola de administración, dónde tendremos
que seleccionar la opción Descargar ejemplo Kp Java:
Automáticamente empezará la descarga de un zip que tendremos que descomprimir y cargar en el
Eclipse.
Sofia2 – Guía Primeros Pasos
15
En nuestro caso vamos producir datos, para ello tenemos que configurar la clase
ProductorTemperatura asignando el token y la instancia KP correspondiente:
Además hay que configurar la instancia que queremos insertar:
A continuación se muestra el código de la Aplicación:
Sofia2 – Guía Primeros Pasos
16
Como vemos en el código, la aplicación sigue el siguiente flujo:
 Envío de mensaje SSAP JOIN, para autenticar con la plataforma y recibir una
sessionKey si la autenticación del ThinKP es correcta.
 Generación y envío de un mensaje SSAP INSERT para enviar datos a una ontología.
 Comprobación de que se ha insertado correctamente en la ontología.
Para todos aquellos que no se sientan del todo cómodos programando en Java, Sofia2 dispone de
una funcionalidad implementada en la consola de administración que nos permite simular datos
para insertarlos en una ontología. Accediendo a ONTOLOGIAS > Simulador Tiempo Real Instancias
de Ontología:
Sofia2 – Guía Primeros Pasos
17
Si seleccionamos Crear Simulador nos mostrará la siguiente pantalla:
Sofia2 – Guía Primeros Pasos
18
Para nuestro caso hemos creado un simulador numericosCurso que simula datos numéricos del 5
al 20 con una precisión de 2 decimales y que insertará datos cada 5 segundos. Una vez Añadido el
generador al listado seleccionamos la ontología en la cual queremos insertar y asignamos a cada
campo de la ontología el generador correspondiente. En nuestro caso utilizaremos el mismo
generador para rellenar los campos de temperatura y humedad:
Por último seleccionamos Crear Simulador para crearlo o directamente Empezar para empezar a
insertar datos simulados en la ontología.
Resumen:
Al finalizar este paso, habremos registrado y conectado a Sofia2 una aplicación (ThinKP), que
podría ejecutarse en un dispositivo para enviar datos:
 Alta en Sofia2 del ThinKP AppTermostato, y consulta del token generado
automáticamente.
 Desarrollo de la aplicación ProductorTemperatura con el ejemplo Java
 Ejecución de la App para abrir sesión en Sofia2, enviar datos a la ontología
LecturaTermostato.
Además, como alternativa, habremos creado un simulador de datos, que generará datos
aleatorios para insertar en la ontología LecturaTermostato.
Gráficamente hemos intervenido en los siguientes componentes de la plataforma:
Sofia2 – Guía Primeros Pasos
19
1.3
Verifica el funcionamiento
La consola de administración de Sofia2, ofrece diferentes alternativas para comprobar cómo está
funcionando nuestro dispositivo.
Podemos consultar las instancias registradas en Mis ThinKPs > AppTermostato y abriendo la
pestaña Mis Instancias. Comprobamos que ahora si aparece la instancia que hemos conectado
en la ejecución del Test:
Sofia2 – Guía Primeros Pasos
20
También podemos consultar la información enviada por el dispositivo a las distintas ontologías
desde la sección Herramientas > Consola BDTR y BDH
Donde se pueden ejecutar consultas sobre las distintas ontologías, tanto en formato SQL como
en formato Nativo de la Base de datos subyacente. En nuestro caso, consultaremos en la BDTR
la ontología LecturaTermostato, para comprobar que el último dato almacenado es el que
hemos introducido desde nuestra App (Test Java del paso anterior):
Sofia2 – Guía Primeros Pasos
21
Resumen:
Al finalizar este paso, habremos consultado que nuestro dispositivo está correctamente conectado
a Sofia2 y enviando información, así como que podemos lanzar consultas a las Bases de datos para
verificar que los datos enviados son correctos.
Sofia2 – Guía Primeros Pasos
22
1.4
Crear aplicaciones
Una vez que existen datos en la plataforma y a medida que los dispositivos u otras aplicaciones
se conectan con Sofia2 es posible crear aplicaciones que interoperen entre sí y exploten la
información existente.
1.4.1
Crea tu dashboard visualmente
Los dashboards nos permiten visualizar gráficamente la información almacenada por los
dispositivos u otras aplicaciones en Sofia2.
Para desarrollar un dashboard primero tenemos que crear los gadgets que lo van a formar, ya
que un dashboard es un conjunto de gadgets unificados en una misma pantalla.
En la consola de administración de Sofia2 existen diferentes alternativas para crear un gadget.
En este caso utilizaremos el Wizard, que nos permite crear un gadget de forma guiada. Para ello,
entramos en la consola de administración y seleccionamos Visualización > Mis Gadgets
Sofia2 – Guía Primeros Pasos
23
Y seleccionamos Crear Gadget:
Lo primero es darle nombre al gadget, es conveniente que el nombre del gadget guarde relación
con el tipo de información que se quiere mostrar, en nuestro caso vamos a representar la
temperatura.
El siguiente paso es seleccionar la ontología de la cual vamos a extraer el campo que queremos
representar:
Sofia2 – Guía Primeros Pasos
24
Seleccionamos el tipo de gadget (tipo de componente HTML) y el campo de la ontología que
queremos representar en el gadget. En este caso, crearemos un gadget que mostrará el atributo
temperatura en un componente de tipo Gauge:
A continuación se elige el tipo de conexión. Los gadget componentes son dinámicos, una vez se
asocian a un atributo de una ontología, cada vez que un dispositivo u otro sistema inserta una
nueva instancia de la ontología, el componente se actualiza con el nuevo valor del atributo en
dicha instancia. Para ello existen dos modos de conexión para acceder al valor del atributo:
 Streaming: Es un modo de suscripción en el que se obtener los datos en tiempo real en
el momento que cambian.
 Query: Es un modo de consulta periódica en el que se lanza periódicamente una query
y se actualiza el valor de componente con el resultado.
En este caso vamos a seleccionar la opción Query:
Sofia2 – Guía Primeros Pasos
25
A continuación seleccionamos la base de datos sobre la cual se va a ejecutar la query. En este
caso utilizaremos la Base de Datos de Tiempo Real, además configuramos el periodo de
ejecución de la consulta.
Por último introducimos la query correspondiente. Al tratarse del modo de conexión “query”
deberemos volver a seleccionar el campo de la ontología que se va a representar, así como el
tipo de gadget (Gauge)
Sofia2 – Guía Primeros Pasos
26
Una vez configurado el gadget, se mostrará en la parte inferior de la página un ejemplo de cómo
quedaría nuestro gauge, para comprobar que es lo que estábamos buscando, y si es así, lo
guardamos:
Sofia2 – Guía Primeros Pasos
27
Repetir los pasos para crear el gadget para representar la humedad, en este caso vamos a
seleccionar un gadget tipo área:
Una vez hemos creado nuestros gadgets, pasamos a crear el dashboard, para ello seleccionamos
la opción de menú Visualización > Mis Dashboards de la consola de administración y pulsamos
Crear Dashboard.
La herramienta de creación de dashboards de la plataforma Sofia2 permite seleccionar estilos
predefinidos (Default Theme, Blue Green Theme…) o puedes personalizar tu dashboard (Custom
Style). Vamos a seleccionar el estilo Dask Blue Theme y le asignamos el nombre
LecturaTermostato:
Sofia2 – Guía Primeros Pasos
28
A continuación creamos una nueva página del dashboard pulsando en Nueva Página. Nos
aparecerá el dashboard en blanco por lo que ahora añadiremos los gadgets creados
anteriormente. Pulsamos el símbolo + que aparece en la esquina superior izquierda. Se mostrará
un listado con los gadgets creados hasta el momento, seleccionaremos los que queremos
representar:
Una vez añadidos los gadgets, podemos situarlos donde prefiramos dentro de la página, cuando
el dashboard presente el formato deseado sólo tenemos que pulsar en Guardar y ya tendremos
guardado nuestro dashboard.
Sofia2 – Guía Primeros Pasos
29
Desde la consola de administración si accedemos a Visualización > Mis Dashboards veremos
nuestro dashboard, si pinchamos en el primer botón de la columna Opciones, obtendremos una
URL en la cual se podrá ver el dashboard.
Resumen:
Al finalizar este paso, habremos construido un dashboard que mostrará gráficamente mediante
dos gadgets los datos enviados por nuestro dispositivo:
 Alta de Gadgets asociándolos a los datos recuperados de una query que se ejecuta
periódicamente
 Desarrollo de dashboard que integra los Gadgets
Gráficamente hemos intervenido en los siguientes componentes de la plataforma:
Sofia2 – Guía Primeros Pasos
30
1.4.2
Crear reglas de forma guiada
La plataforma Sofia2 permite crear reglas que se ejecuten en respuesta a la recepción de datos
o periódicamente según una expresión Cron. Existen diferentes alternativas para crear una
regla, en este caso vamos a utilizar el Wizard de Creación de Reglas. Podemos acceder a esta
funcionalidad desde la consola de administración en Reglas >Wizard Creación de Reglas.
Sofia2 – Guía Primeros Pasos
31

Accederemos a un wizard dónde en primer lugar debemos seleccionar el tipo de regla que
queremos generar, seleccionaremos Generar regla script Ontología. Se trata de una regla que
se ejecuta cada vez que en la plataforma se recibe una instancia de una determinada
ontología.

Pulsamos Siguiente e introducimos el nombre que identificará la regla, un timeout para finalizar
su ejecución en caso de que se alargue indefinidamente y seleccionamos la ontología, en
respuesta a cuyas entradas queremos que se ejecute la regla:
Sofia2 – Guía Primeros Pasos
32
Por último programamos nuestra regla, en este caso se va a evaluar el dato temperatura de la
ontología y en el caso de que la temperatura supere un determinado umbral se enviará un correo
de alerta, para ello en la pestaña If programaremos la condición para que se dispare la regla o
no:
Mientras que en la pestaña Then programaremos la acción a realizar una vez se haya verificado
la condición, que en este caso es mandar un email:
Sofia2 – Guía Primeros Pasos
33
Una vez guardada y activada la regla cada vez que llegue un evento a la ontología se comprobará
el parámetro temperatura y se lanzará o no la regla.
En Sofia2 tenemos otras herramientas más visuales para la creación de este tipo de reglas, cómo
es Node-RED. Node-RED es un motor de flujos con enfoque IoT que permite definir gráficamente
flujos de servicios, a través de protocolos estándares como REST, MQTT, Websocket… además
de ofrecer integración con APIs de terceros, tales como Twitter, Facebook, Yahoo!...
En primer lugar, para poder acceder a la herramienta Node-RED integrada en Sofia2 es necesario
crearse un dominio, sólo se puede crear un dominio a la hora de crear un proyecto y únicamente
podrá haber un dominio por proyecto, es en este dominio donde se arrancará una instancia de
Node-RED en la cual podremos empezar a crear nuestros flujos. Si accedemos a PROYECTOS >
Mis Proyectos:
Y seleccionamos Crear Proyecto accedemos a la siguiente pantalla:
Sofia2 – Guía Primeros Pasos
34
En primer lugar hay que nombrar al proyecto, veremos que el campo identificador se rellena
automáticamente. Una vez nombrado el proyecto nos vamos a MOTOR DE FLUJOS dónde
marcaremos que queremos que se cree un dominio asociado a este proyecto.
Una vez creado el proyecto junto con su dominio, nos vamos a REGLAS > Mis Flujos
Sofia2 – Guía Primeros Pasos
35
Dónde veremos que aparece una lista con nuestros dominios disponibles:
Como se puede observar el dominio se encuentra parado, procedemos a arrancarlo
seleccionando el play que se encuentra en la columna Opciones. Al estar trabajando con rol
Colaborador nos saldrá un mensaje de aviso de que nuestro dominio se va a arrancar en modo
demo, esto quiere decir que pasado un tiempo determinado el dominio se parará sólo dando la
posibilidad al usuario de poder volver a arrancarlo.
Sofia2 – Guía Primeros Pasos
36
Una vez arrancado el dominio, es decir una vez levantada la instancia Node-RED, podremos
acceder al editor visual, para ello seleccionamos el dominio en el cual queremos trabajar:
Y seleccionamos en Ver Flujos:
Sofia2 – Guía Primeros Pasos
37
Vamos a construir un flujo que haga exactamente lo mismo que la regla script creada
anteriormente. En el Node-RED que está integrado con la plataforma tenemos unos nodos
propios para interactuar con la misma, uno de estos nodos en el ssap-process-request, este nodo
nos permite escuchar eventos de una determinada ontología asociada a un ThinKP y nos
proporciona como dato de salida la instancia que se acaba de insertar. Arrastramos el nodo al
editor, haciendo doble click sobre el nodo se desplegará un listado de parámetros necesarios
para configurar el nodo:
-
Message adress: la dirección del flujo, en este caso es de tipo INPUT
-
Type Message: eventos que queremos escuchar, en este caso INSERT
-
Ontology: ontología sobre la cual queremos escuchar.
-
ThinKP: ThinKP al cual está asociado la ontología anteriormente seleccionada.
-
KP instance: Instancia del ThinKP.
Lo siguiente es extraer el dato temperatura que se acaba de insertar, para ello arrastramos al
editor un nodo function, este nodo nos permite tratar los datos programando en javascript, en
nuestro caso extraeremos el dato temperatura de la instancia recibida y lo pasaremos al siguiente
nodo dentro del payload del mensaje:
Sofia2 – Guía Primeros Pasos
38
Ahora tenemos que evaluar si el dato temperatura supera el umbral definido, para ello
utilizaremos el nodo switch:
Por último, en el caso de que se supere dicho umbral se mandará un correo electrónico a través
del nodo e-mail:
Sofia2 – Guía Primeros Pasos
39
Una vez montado el flujo lo desplegamos seleccionando la opción Deploy situada en la parte
superior derecha del editor. Visualmente el flujo quedaría de la siguiente manera:
Dicho flujo se desencadenará cada vez que se realice una inserción en la ontología
LecturaTermostato desde el ThinKP correspondiente.
Resumen:
En este apartado se ha creado una regla en la plataforma de dos formas distintas, desde el motor
de Scripting y desde el Motor de Flujos, que se ejecutará cuando se reciba desde el dispositivo
información hacia una ontología. Esto permite evaluar la información en el momento que se
procesa en Sofia2 y disparar acciones programadas en plataforma en respuesta a dichos eventos
de entrada.
Visualmente en este apartado hemos interactuado con los siguientes módulos de la plataforma:
Sofia2 – Guía Primeros Pasos
40
Sofia2 – Guía Primeros Pasos
41
1.4.3
Exponer información con un API REST
Sofia2 permite publicar nuestras ontologías como APIs REST. Esto es especialmente interesante
en la integración con otros sistemas, ya que toda la información, tanto de tiempo real, como
histórica, queda disponible para ser consultada y actualizada como si de un recurso HTTP se
tratase, manteniendo los mismos principios de autenticación y autorización del resto de la
plataforma.
Para exponer una ontología como un API REST, accedemos a la opción de menú API Manager >
APIs de la consola de administración y seleccionamos Crear API:
Sofia2 – Guía Primeros Pasos
42
Le asignamos el Nombre a nuestra API y la marcamos como Pública. Desmarcamos la opción
“API Externa”, ya que es una opción para invocar a APIs de terceros, y seleccionamos la ontología
que queremos publicar. Vamos a establecer una cache de 5 minutos para los resultados de las
consultas y un límite de 5 consultas al API por minuto.
Podemos observar como ya se muestra el EndPoint HTTP de acceso a la API que expone nuestra
ontología:
Por último nos aparecen las operaciones que queremos que API REST exponga (e incluso crear
operaciones a medida con la opción CUSTOM):
Sofia2 – Guía Primeros Pasos
43
Crearemos dos operaciones CUSTOM, uno por cada tipo de dato que almacenamos, Humedad y
Temperatura.
Sofia2 – Guía Primeros Pasos
44
El resultado final será algo parecido a lo siguiente:
Una vez creada la API la pasamos Publicada pulsando en el botón Publicar del listado de API.
Sofia2 – Guía Primeros Pasos
45
Cada usuario dispone de un API Key que lo identifica en la plataforma a efectos de autenticación y
autorización sobre APIs. Es posible consultar y regenerar el API Key desde la pestaña Mis API Key
Para utilizar un API es necesario suscribirse a él, salvo el propietario, que queda suscrito por
defecto. En la pestaña Mis Suscripciones podemos consultar todas las APIs a las que tenemos
acceso, así como consultar su documentación e invocarlas utilizando un cliente REST integrado
en la consola de administración
Pulsando Test & Doc accedemos a la documentación y cliente REST del API
Sofia2 – Guía Primeros Pasos
46
Al pulsar sobre cada opción nos aparece la meta información del servicio.
Para utilizar el cliente REST del API debemos introducir el Token de usuario del API Key en la
cabecera X-SOFIA2-APIKey
Sofia2 – Guía Primeros Pasos
47
Y ejecutando Submit, obtendremos el resultado de la consulta que habíamos definido en la
operación Custom anteriormente.
En la pestaña Request Info podemos ver el URL de invocación de la operación, que será el
End Point que se creó cuando generamos el API más la operación.
Sofia2 – Guía Primeros Pasos
48
Resumen:
Al finalizar este paso, habremos publicado un API REST con dos operaciones Custom, para
acceder vía métodos HTTP, a los datos almacenados por nuestro dispositivo.
 Alta del API REST con dos métodos Custom sobre nuestra ontología.
 Consulta de la documentación del API REST
 Invocación a un método del API REST mediante cliente integrado en la plataforma.
Visualmente en este apartado hemos interactuado con los siguientes módulos de la plataforma:
Sofia2 – Guía Primeros Pasos
49