Guia paso a paso de despliegue con Fiware


FIWARE

 La plataforma FIWARE surgió en el año 2014 aproximadamente a partir de las propuestas del Horizonte 2020 de la Unión Europea. Se trata de un intento de estandarizar una nube que permita conectar el IoT estando ya finalizado, aunque su desarrollo continúa siendo dirigido por la propia comunidad de FIWARE. Si estudiamos el interés en esta plataforma, encontramos que su inicio fue explosivo, debido a la gran aglomeración de empresas y noticias que generaron contenido y búsquedas en su planteamiento, desarrollo y lanzamiento, que después se vio reducido. Sin embargo, podemos empezar a observar un leve repunte en el interés por esta plataforma, ya que algunas empresas como Telefónica buscan convertirlo en el estándar de facto mediante su uso, que comenzó a impulsarse en 2015

Para lograr esta conectividad de elementos y a su vez permitir la adición de otras funcionalidades, el elemento principal de la nube de FIWARE es el llamado ORION Context Broker, un intermediario que permite la conectividad a todo tipo de elementos, bien mediante su API NGSI que emplea REST, o bien mediante agentes. Estos agentes no son más que módulos intermediarios que pueden traducir otros formatos o protocolos de comunicación a NGSI, de manera que se posibilita de esta forma la conectividad con otros dispositivos que no puedan establecer comunicaciones mediante REST.

Por otro lado, aplicaciones externas de desarrolladores pueden comunicarse con Orion a través de la API REST mencionada.

Todos los componentes de FIWARE son, según su propia nomenclatura, denominados Generic Enablers (GEs), dado que proveen nuevas características al sistema que otros componentes no pueden ofrecer: persistencia de los datos, comunicación, autenticación segura, etc. 2.2.1 Cosmos Uno de los GE disponibles en FIWARE es Cosmos destinado a permitir el análisis Big Data una vez que los datos han sido almacenados de manera persistente.

Cosmos permite el análisis de los datos mediante aplicaciones del tipo map&reduce, o mediante Apache Hive. 2.3 Docker Docker es un sistema de contenedores de software, que empaqueta el software en estos contenedores, de manera que contienen todo lo necesario para funcionar. Esto facilita el despliegue y mantenimiento de las aplicaciones, ya que para que la propia aplicación funcione evitamos requerir unas dependencias previas a la máquina host, provee de una capa a la vez de seguridad y de abstracción al aislar los contenedores del resto de dicha máquina, y evita la sobrecarga de necesitar ejecutar un sistema operativo completo sobre el host.

 FIWARE sobre Docker

 De los múltiples componentes que existen en la arquitectura de FIWARE, la siguiente imagen refleja cuales son aquellos que existen como contenedores en Docker, con un color oscuro los propios de FIWARE, y en un color más claro aquellos relacionados y que también existen y por tanto es viable emplearlos en un despliegue.

Como podemos comprobar, Orion está disponible, y a su vez sería necesario emplear un contenedor de MongoDB para poder desplegar Orion y tenerlo en funcionamiento.

En este proyecto emplearemos FIWARE como intermediario para conectar nuestro escenario IoT. La razón de uso de esta plataforma se encuentra en dos motivos principales:

  • Permitir conectar un escenario IoT completo, sean cuales sean los componentes que lo conforman. Si bien nuestro escenario puede ser suficientemente pequeño como para no requerir el uso de esta plataforma, es útil de cara a la conceptualización del trabajo, su uso en un escenario de mayor tamaño y para el propio aprendizaje.
  •  La no existencia de plataformas similares que no sean privadas, por tanto, la única alternativa abierta a su uso para todo el mundo.
  • En tercer lugar, emplearemos Docker como sistema de contenedores para desplegar los componentes de FIWARE que necesitemos emplear. De esta manera, conseguiremos:
    •  Ahorrar tiempo y dificultades en el despliegue y configuración de los GE de FIWARE.
    •  Facilitar la actualización o reemplazo de componentes desplegados en contenedores.

Finalmente, hemos podido observar como el análisis de datos está a la orden del día, aplicándose estas técnicas 12 Análisis de datos de un escenario FIWARE basado en Docker 12 a ámbitos cada vez más diversos

  Instalación

En primer lugar, instalaremos Docker

https://hub.docker.com/r/fiware/orion

Docker Compose le permite vincular un contenedor Orion Context Broker a un contenedor MongoDB en unos minutos. Este método requiere que instale Docker Compose.

Considere este método si desea probar Orion Context Broker y no quiere preocuparse por las bases de datos o no le importa perder datos.

Seguimos estos pasos:

  • Creamos un directorio en su sistema en el que trabajar (por ejemplo, c: / fiware).
  • Creamos un nuevo archivo llamado docker-compose.yml dentro del directorio con el siguiente contenido:
mongo:
   image: mongo:3.6
   command: --nojournal
 orion:
   image: fiware/orion
   links:
     - mongo
   ports:
     - "1026:1026"
   command: -dbhost mongo
  • Usando la línea de comandos y dentro del directorio que creamos, escribiremos:

C:\fiware>docker-compose up

NOTA IMPORTANTE: Dado que   puede dar problemas en la ejecución  de la imagen de docker especialmente al lanzar la imagen de fiware_orion_1 , es mejor desde el directorio de despliegue lanzar el siguiente comando:

$ docker-compose up –force-recreate orion

Con respecto a –nojournal, no se recomienda para producción, pero acelera el inicio del contenedor mongo y evita algunos problemas de condiciones de carrera si el contenedor Orion es más rápido y no encuentra la base de datos lista y lista.

Lo que he hecho con este método es descargar imágenes para Orion Context Broker y MongoDB desde el repositorio público de imágenes llamado Docker Hub: es entonces cuando ha creado dos contenedores basados en ambas imágenes.

  • Después de unos segundos, debería tener su Context Broker ejecutándose y escuchando en el puerto 1026 lo cual podemos comprobar si nos vamos a la url: http// localhost: 1026/version

También desde el interfaz gráfico de dockers debe aparecer corriendo el contenedor de fiware ejecutándose:

Si desea detener el escenario, debe presionar Control + C en el terminal donde se está ejecutando docker-compose, pero se perderían todos los datos que se estaban utilizando en Orion con este método.

Pruebas iniciales

Creemos ahora una entidad tipo práctica del tipo Medida al que el vamos asociar la temperatura y humedad de una habitación.

Debemos extremar las cabeceras (headers) cuando enviamos datos a Orión Content Bróker, pues el Key Host que viene por defecto en Postman no nos sirve, para lo cual deberemos crear otra key asociándola a “application/json”. Asimismo, de igual manera lo haremos con el atributo “Content-Type”.

Y este el código para crearlo en formato Json:

{

        “id”: “Practica”,

        “type”: “Medida”,

        “Temperatura”: {

            “type”: “Integer”,

            “value”: 25,

            “metadata”: {}

        },

        “Humedad”: {

            “type”: “Float”,

            “value”: 50,

            “metadata”: {

                “accuracy”: {

                    “type”: “Float”,

                    “value”: 9

                }

            }

        }

    }

Si queremos cambiar un valor se hará a través de la url http:// localhost:1026/v2/entities/Practica/attrs/    y cambiaremos el cuerpo y la cabecera

Es decir, en el código Json simplemente hemos eliminado el id y el tipo de la entidad y mantenido el resto:

    {       

        “Temperatura”: {

            “type”: “Integer”,

            “value”: 35,

            “metadata”: {}

        },

        “Humedad”: {

            “type”: “Float”,

            “value”: 51,

            “metadata”: {

                “accuracy”: {

                    “type”: “Float”,

                    “value”: 9

                }

            }

        }

    }

También podemos recuperar el valor directamente desde sin usr postman llamando directamente a http://localhost:1026/v2/entities/

Asimismo, podemos cambiar no solo el valor de un atributo, sino también el tipo de dato usando PUT:

Es precisamente este el formato que podríamos usar para enviar las muestras al Content-bróker de Fiware  desde el endpoint http://192.168.1.66:1026/v2/entities/

{       

        “Temperatura”: {

            “type”: “Float”,

            “value”: 26,

            “metadata”: {}

        },

        “Humedad”: {

            “type”: “Float”,

            “value”: 54,

            “metadata”: {

                “accuracy”: {

                    “type”: “Float”,

                    “value”: 9

                }

            }

        }

    }

RESUMEN DE PRUEBAS FINALES

Para probar el funcionamiento del sistema:

-Iniciamos Orion Content Broker

-Iniciamos el agente Postman

-Desde Postman  configuramos la url a http://192.168.1.66:1026/v2/entities/Practica/attrs/  , usaremos el método PUT y añadiremos  a headers las keys Accept y Content-type al valor application/json

Como posibles valores de prueba podemos usar los siguientes:

{       

        “Temperatura”: {

            “type”: “Integer”,

            “value”: 35,

            “metadata”: {}

        },

        “Humedad”: {

            “type”: “Float”,

            “value”: 51,

            “metadata”: {

                “accuracy”: {

                    “type”: “Float”,

                    “value”: 9

                }

            }

        }

    }

Podemos cambiar solo la temperatura:

{       

        “Temperatura”: {

            “type”: “Integer”,

            “value”: 99,

            “metadata”: {}

        }

    }

O también cambiar el valor de la humedad:

{   “Humedad”: {

            “type”: “Float”,

            “value”: 51,

            “metadata”: {

                “accuracy”: {

                    “type”: “Float”,

                    “value”: 9

                }

            }

        }

    }

-Desde un navegador Chrome con las extensiones json y refresh nos iremos a http://192.168.1.66:1026/v2/entities/   podemos comprobar que se ha actualizado

Solución final

Dado que   puede dar problemas en la ejecución de la imagen de docker especialmente al lanzar la imagen de fiware_orion_1 , es mejor desde el directorio de despliegue lanzar el siguiente comando:

$ docker-compose up –force-recreate orion

Una vez iniciados los dos servicios comprobaremos mediante el interfaz de docker que ya podemos empezar a trabajar

Lo siguiente es crear las entidades finales usando el siguiente código en Json:

{"id": "Practica",

        "type": "Medida",

        "Temperatura": {

            "type": "Float",

            "value": 25,

            "metadata": {}

        },

        "Wifi": {

            "type": "Float",

            "value": 50,

            "metadata": {}

        },

        "Temperaturaint": {

            "type": "Float",

            "value": 28,

            "metadata": {}

        },

        "Humedad": {

            "type": "Float",

            "value": 50,

            "metadata": {

                "accuracy": {

                    "type": "Float",

                    "value": 9

                }

            }

        }

    }

Como end-point desde  postman establecemos a http://localhost:1026/v2/entities/        

Para el body no debemos olvidar insertar el código RAW en formato JSON.

Es importante configurar el token Accept como aplication/json:

Una vez creado podemos comprobar el resultado si nos vamos a http://localhost:1026/v2/entities/

En caso de problemas de conectividad deberemos cerrar el cortafuegos o configurarlo para que acepte tráfico desde fuera de la red externa.

También desde Postman podemos recuperar las últimas medidas enviadas a Orion Content Bróker.

Y una vez definidas la entidades con el método PUT vamos a ir actualizando los datos  usando la url http://192.168.1.66:1026/v2/entities/Practica/attrs/

¡No debemos olvidarnos de los headers!!

Como hemos comentado, una vez tengamos el contenido del body actualizado le daremos al botón “Put”;

Podemos comprobar mediante la consola de Orión Content Bróker las entidades, así como diferentes datos almacenados en la BBD:

sh-4.2$ ls

anaconda-post.log  bin  dev  etc  home  lib  lib64  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

sh-4.2$ curl localhost:1026/v2/entities -s -S -H ‘Accept: application/json’ | python -mjson.tool

[

    {

        “Humedad”: {

            “metadata”: {

                “accuracy”: {

                    “type”: “Float”,

                    “value”: 9

                }

            },

            “type”: “Float”,

            “value”: 46

        },

        “Temperatura”: {

            “metadata”: {},

            “type”: “Float”,

            “value”: 26

        },

        “Temperaturaint”: {

            “metadata”: {},

            “type”: “Float”,

            “value”: 53.33

        },

        “Wifi”: {

            “metadata”: {},

            “type”: “Float”,

            “value”: -67

        },

        “id”: “Practica”,

        “type”: “Medida”

    }

]

sh-4.2$ curl localhost:1026/v2/types -s -S -H ‘Accept: application/json’ | python -mjson.tool

[

    {

        “attrs”: {

            “Humedad”: {

                “types”: [

                    “Float”

                ]

            },

            “Temperatura”: {

                “types”: [

                    “Float”

                ]

            },

            “Temperaturaint”: {

                “types”: [

                    “Float”

                ]

            },

            “Wifi”: {

                “types”: [

                    “Float”

                ]

            }

        },

        “count”: 1,

        “type”: “Medida”

    }

]

sh-4.2$ curl localhost:1026/v2/types?options=values -s -S -H ‘Accept: application/json’ | python -mjson.tool

[

    “Medida”

]

sh-4.2$ curl localhost:1026/v2/types/Room -s -S -H ‘Accept: application/json’ | python -mjson.tool

{

    “description”: “Entity type not found”,

    “error”: “NotFound”

}

sh-4.2$

   Sensor DHTXX

Para que esta práctica tenga sentido vamos a implementar un caso práctico de un sensor real basado en DHTX conectado a un ESP32 que será el que envié las medidas a ORION Content Broker que consistirán en las siguientes:

  • Temperatura exterior
  • Humedad exterior
  • Temperatura interior
  • Nivel señal wifi
  • Sensor Hall(opcional)

DHT11 y DHT22 son dos modelos de una misma familia de sensores, que permiten realizar la medición simultánea de temperatura y humedad usando además un único hilo para comunicar los datos vía serie, para lo cual ambos disponen de un procesador interno que realiza el proceso de medición, proporcionando la medición mediante una señal digital, por lo que resulta muy sencillo obtener la medición desde un microprocesador como Arduino, ESP8266 o el node MCU que usaremos.

Ambos son similares pero el DHT11 presenta una carcasa azul (es el que usaremos en la práctica), mientras que el sensor DHT22 es blanco, compartiendo además los mismos pines disponiendo de 4 patillas, de las cuales usaremos sólo 3: Vcc, Output y GND.  Como peculiaridad, la salida la conectaremos a una entrada digital, pero necesitaremos poner una resistencia de 10K entre Vic y el Pin Output, pero existen unos módulos que integran esta junto con los pines VCC, OUT y GND.

El DHT11 puede medir temperaturas entre 0 a 50, con una precisión de 2ºC, humedad entre 20 a 80%, con precisión del 5% y con una a frecuencia de muestreo de 1 muestras por segundo (1 Hz)

En clara superioridad con el dHT11, el modelo DHT22 tiene unas características mucho más profesionales.

  • Medición de temperatura entre -40 a 125, con una precisión de 0.5ºC
  • Medición de humedad entre 0 a 100%, con precisión del 2-5%.
  • Frecuencia de muestreo de 2 muestras por segundo (2 Hz)

Destacar que este tipo de sensores de temperatura (y, aún más, los sensores de humedad), son sensores con elevada inercia y tiempos de respuesta elevados. Es decir, al “lentos” para reflejar los cambios en la medición.

Conectar el DHT11   o el DHT22 a un Arduino o al Node MCU es sencillo, simplemente alimentamos desde Arduino al sensor a través de los pines GND y Vcc del mismo. Por otro lado, conectamos la salida Output a una entrada digital de Arduino. Necesitaremos poner una resistencia de 10K entre Vcc y el Pin Output.

El esquema eléctrico queda como la siguiente imagen:

Los sensores DHT11 y DHT22 usan su propio sistema de comunicación bidireccional mediante un único hilo, empleando señales temporizadas por lo que en general, lo normal es que empleemos una librería existente para simplificar el proceso.

Conexión de DHT22 a Node MCU-32S

 Como vemos el circuito para conectar al Node MCU   el sensor de temperatura y humedad DHT11 no puede ser más sencillo, pues simplemente alimentaremos con 3.3v DC tanto el DHT11 como el Node MCU   en sus pines correspondiente     sin olvidar que la salida de datos del DH11pin datos) tenemos que conectarla al pin 5 del GPIO.

Respecto a la placa de desarrollo usada es la NodeMCU-32S basada en ESP32, placa que cuenta con conectividad WiFi + Bluetooth, CP2102 a bordo y llaves. Además, todos los pines de E / S del módulo ESP-WROOM-32 son accesibles a través de los encabezados de extensión. Gracias a los ricos recursos de código abierto, admite el desarrollo de varias formas, como los comandos Lua / AT / MicroPython / Arduino / IOT, etc., lo que le ayuda a crear prototipos rápidos de aplicaciones de IoT.

Algunas características de esta placa:

  • Módulo ESP-WROOM-32 integrado
  • CP2102 integrado, convertidor de USB a UART
  • Puerto USB para entrada de energía, programación de firmware o depuración UART
  • Cabezales de extensión de 2×19 pines, rompen todos los pines de E / S del módulo
  • 2x teclas, utilizadas como reinicio o definidas por el usuario
  • Especificaciones
  • Módulo WIFI: ESP-WROOM-32
  • Procesador: ESP32-D0WDQ6
  • Flash incorporado: 32 Mbit
  • Antena: antena PCB integrada
  • Interfaz periférica: UART / GPIO / ADC / DAC / SDIO / PWM / I2C / I2S
  • Protocolo WiFi: IEEE 802.11 b / g / n
  • Bluetooth: Bluetooth 4.2
  • Rango de frecuencia: 2.4G ~ 2.5G (2400M ~ 2483.5M)
  • Modo WIFI: Estación / SoftAP / SoftAP + Station
  • Fuente de alimentación: 5 V
  • Nivel lógico: 3,3 V
  • Dimensiones: 48,26 mm x 25,4 mm

En la siguiente imagen podemos ver el montaje realizado:

 Programar el  Node MCU-32S

Para instalar el firmware en el node MCU32S   lo primero es descargar e instalar el IDE de Arduino (Arduino IDE.).

Para instalar el paquete de la placa en Archivo -> Preferencias, agregue http://arduino.esp8266.com/stable/package_esp8266com_index.json al campo URL del Administrador de tableros adicionales.

Después instalaremos la plataforma esp8266 desde Tools -> Board -> Boards Manager.

(En caso de que la placa fuese un ESP32, habría que instalar manualmente el paquete de la placa siguiendo las instrucciones aquí: https://github.com/espressif/arduino-esp32/blob/master/README.md#installation-instructions).

Lo siguiente es descargue esta biblioteca como un archivo zip  aquí.

Instalamos la biblioteca zip descargada desde Sketch -> Incluir biblioteca -> Agregar biblioteca .ZIP.

Ahora ya podemos conectar el módulo ESP a su pc a usando un USB y seleccionado su puerto (y el un módulo ESP) en el menú Herramientas.

Es interesante destaca de que puede según los casos, tengamos que añadir una regla al Cortafuegos de Windows 10 para permitir el acceso desde el ESP32 al Content Server Bróker.

Por ultimo cargaremos el siguiente código en nuestro ESP32 personalizándolo con las características de nuestra red wifi y los datos que vayamos a enviar al Content Bróker:

IMPLEMENTACION EN ESP32

#include <ArduinoJson.h>

#include <WiFi.h>

#include <HTTPClient.h>

#include <SimpleTimer.h>

#include “DHT.h”

#define DHTTYPE DHT11   // DHT 11

const int DHTPin = 5;     // what digital pin we’re connected to

DHT dht(DHTPin, DHTTYPE);

const char* ssid = “MI_RED_WIFI”;

const char* password =”CLAVE_WIFI”;

const char* servidor2=”http://192.168.1.66:1026/v2/entities/Practica2/attrs/&#8221;;

const char* servidor=”http://192.168.1.66:1026/v2/entities/&#8221;;

float dato_temp = 0.0;

float dato_rssi = 0.0;

int dato_conor = 0;

float dato_hall = 0.0;

// the following variables are unsigned longs because the time, measured in

// milliseconds, will quickly become a bigger number than can be stored in an int.

unsigned long lastTime = 0;

// Timer set to 10 minutes (600000)

//unsigned long timerDelay = 600000;

// Set timer to 5 seconds (5000)

unsigned long timerDelay = 5000;

// ledPin refers to ESP32 GPIO 23

const int ledPin = 2;

#define LED 2

#ifdef __cplusplus

extern “C” {

#endif

uint8_t temprature_sens_read();

#ifdef __cplusplus

}

#endif

uint8_t temprature_sens_read();

void setup() {

 Serial.begin(115200);

  delay(4000); // Esperar para que se configure la consola.

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) { // Comprobar la conexión.

    delay(1000);

    Serial.println(“Conectando a la red WiFi…”);

  }

  Serial.print(“Conectado a la red WiFi: “);

  Serial.println(ssid);

  Serial.println(“DHT11 test!”);

  dht.begin();

 Serial.println(“DHT11 test OK !”);

}

void loop() {

delay(2000);

 // Reading temperature or humidity takes about 250 milliseconds!

   float h = dht.readHumidity();

   float t = dht.readTemperature();

 if (isnan(h) || isnan(t)) {

     Serial.println(“!Fallo al leer sensor  DHT !”);

      //return;

    }

   else

   {

  Serial.print(“Temperatura exterior: “);

    Serial.println(t);

      Serial.print(“Humedad exterior:”);

        Serial.println(h);

   }

  //tomar valor de la temperatura interior

  // Convierte de F a ºC

  dato_temp=(temprature_sens_read()-32)/1.8;

   Serial.print(“Temperatura interior :”);

  Serial.println(dato_temp);

// medir nivel señal wifi

 dato_rssi = 0;

 for (int i=0;i < 10;i++){

 dato_rssi += WiFi.RSSI();

 delay(20);

 }

 dato_rssi = dato_rssi/10;

Serial.print(“Nivel WIFI :”);

Serial.println(dato_rssi);

 //sensor Hall

 dato_hall=hallRead();

String quote = “\””;

String mensaje=”{” +quote +”Humedad” +quote +”:{” +quote +”type” +quote +”:” +quote +”*” +quote +”,” +quote +”value” +quote +”:”;

mensaje +=h;

mensaje  +=”,” +quote +”metadata” +quote +”:{” +quote +”accuracy” +quote +”:{” +quote +”type” +quote +”:” +quote +”*” +quote +”,” +quote +”value” +quote +”:9}}},” +quote +”Temperatura” +quote +”:{” +quote +”type” +quote +”:” +quote +”*” +quote +”,” +quote +”value” +quote +”:”;

mensaje +=  t;

mensaje += “,” +quote +”metadata” +quote +”:{}},” +quote +”Temperaturaint” +quote +”:{” +quote +”type” +quote +”:” +quote +”*” +quote +”,” +quote +”value” +quote +”:”;

mensaje += dato_temp;

mensaje +=”,” +quote +”metadata” +quote +”:{}},” +quote +”Wifi” +quote +”:{” +quote +”type” +quote +”:” +quote +”*” +quote +”,” +quote +”value” +quote +”:”;

mensaje += dato_rssi;

mensaje += “,” +quote +”metadata” +quote +”:{}}}”;

//calculo longitud del mensaje

int  mm= mensaje.length()+38;

String longitud= (String) mm;

 //Send an HTTP POST request every 10 minutes

if ((millis() – lastTime) > timerDelay) {

    //Check WiFi connection status

    if(WiFi.status()== WL_CONNECTED){

     // Mostrar mensaje de exito y dirección IP asignada

     Serial.println();

     Serial.print(“Conectado a:\t”);

     Serial.println(WiFi.SSID());

     Serial.print(“IP address:\t”);

     Serial.println(WiFi.localIP());

     Serial.println();

     Serial.print(“**PRUEBA DE ENVIO DE GET:\t”);

     Serial.println(“”);

    //prueba de GET

    HTTPClient http;

    // Your Domain name with URL path or IP address with path

    http.begin(servidor);

    int httpResponseCode = http.GET(); //POST(salidajson);

     String payload = http.getString();

    Serial.println(“respuesta devuelta al comando HTTP.getString( Payload): “);

    Serial.println(payload);

    Serial.print(“HTTP Response code: “);

    Serial.println(httpResponseCode);

    Serial.println();

     http.end();

    delay(10000);

 Serial.print(“**PRUEBA DE ENVIO DE POST:\t”);

 Serial.println(“”);

   digitalWrite(ledPin, HIGH);

   // you’re connected now, so print out the data

   Serial.println();

   Serial.println(“Starting connection to server…”);

   http.begin(servidor2);

  Serial.print(“Enviando mensaje JSON: “);

  // Specify content-type header

  http.addHeader(“Accept”, “application/json”);

  http.addHeader(“Content-Type”, “application/json”);

  http.addHeader(“Content-Length”,longitud);

 Serial.print(“Longitud del mensaje=”);

 Serial.println(longitud );

 Serial.println(“Contenido del mensaje=”);

 Serial.println(mensaje );

int  httpResponseCode2 = http.POST(mensaje);

  Serial.print(“HTTP Response code: “);

  Serial.println(httpResponseCode2);

  String payload2 = http.getString();

  Serial.println(payload2);

  Serial.println();

  http.end();

  salidajson=””;

 digitalWrite(ledPin, LOW);

 delay(10000);

    }

    else {

      Serial.println(“WiFi Disconnected”);

    }

    lastTime = millis();

  }

}

A continuación, mostramos un ejemplo de salida por consola del programa anterior funcionando:

Freeboard

Una vez que ya tenemos datos en la plataforma Fiware, necesitamos no solo que haga de conexión entre diferentes dispositivos, sino que buscamos ver y entender que nos están diciendo nuestros equipos. Hacer esto, hoy por hoy, requiere al menos un cierto manejo de lenguajes de programación como podría ser por ejemplo node-js. Sin embargo, hay quienes están trabajando porque esto no sea así como es el caso de Freeboard, un producto de Bug Labs, una Startup de Nueva York. “A damn-sexy, open source real-time dashboard builder/viewer for IOT and other web mashups”.

Freeboard seguramente no sea la plataforma de aplicaciones más sofisticada técnicamente que existe para el Internet de las Cosas pues estamos ante un panel web que podríamos decir “sencillo” y que muestra la información de los diferentes dispositivos que tengamos conectados en tiempo real.

Destacar también que es una plataforma Open Source, cuyo código fuente está disponible en GitHub donde allí tenemos el código fuente de la parte cliente.

Según sus fundadores, “Freeboard.io trata de convertir el Internet de las Cosas en un entorno mucho más sencillo, simple y accesible para todo el mundo”.

No necesitamos nada más para hacer funcionar tus dispositivos, aunque se podría potenciar mucho el sistema mediante la conexión por ejemplo con dweet.io o IFTTT.com, creando de una forma rápida y sencilla una robusta aplicación IoT. También podemos mezclar plataformas y dispositivos, levantando un excelente entorno desde donde controlar nuestros equipos.

Trabajar con ella es muy sencillo: Freeboard puede ejecutarse bien en un entorno cloud ( freeboard.io)   con  un plan gratuito con 30 días de duración. Una vez registrados podemos crear paneles indicadores configurados a nuestro gusto para visualizar la información, aunque primero habrá que añadir como fuente de datos(datasource) y sobre estos datos montar nuestro propio dashboard.

Otra forma de trabajar podría ser descargando o clonando el repositorio de Github, pero, aunque podría parecer trivial no se trata de abrir “index.html” simplemente en su navegador favorito pues tendremos que tener una servidor web (por ejemplo, Apache web server), tener node-js instalado y por supuesto tener Freeboard correctamente configurado especialmente todo lo relacionado con los CORS( Access-Control-Allow-Origin) donde por cierto la extensión de Chrome  “Allow Cors”  podría ser muy útil.

Como esta instalación podría ser problemática, lo más sencillo es cargar una imagen de docker con Freeboard pues así tendremos todo bien configurado y no tendremos ningún problema a la hora de ejecutar este entorno

No debemos por cierto antes de ejecutar dicha imagen de Freeboard de Docker instalar node-js, necesario para que todos los componentes funcionen correctamente.

Los pasos a seguir para hacer funcionar localmente Freeboad localmente:

  • Instalar node-js (si aún no lo tiene instalado)
  • Instalar Docker en la maquina
  • Crear  y ejecutar el contenedor de Freeboard(https://github.com/h6w/freeboard-docker  ) donde ejecutaremos el resto de contenedores Dockers, para lo cual simplemente desde el directorio desde line de comandos ejecutaremos:docker run --name myfreeboard -p 8080:80 -d tudorh/freeboard (este comando expondrá una instalación de Freeboard en  http://localhost:8080 )
  • Ahora nos iremos a Docker para comprobar que está corriendo en el puerto 8080 el servidor de Freeboard.
  • Ahora nos iremos a la dirección expuesta : http://localhost:8080/
  • Lo más importante es configurar antes de nada el Datasource que es de desde donde se obtendrá toda la información que se mostrará en el dashboard.
    • En Type seleccionaremos JSON
    • En Name elegiremos el nombre que deseemos
    • End headers añadiremos Accept: application/json
  • Una vez hecho esto pulsaremos en el símbolo de refresh en la parte superior y ya debería verse reflejado la hora de esa actualización.

Ahora pulsaremos en “ADD PANE” para crear el entorno donde mostraremos gráficamente las diferentes variables que queremos mostrar en nuestro panel:

  • Temperatura exterior
    • Humedad exterior
    • Temperatura interior
    • Nivel señal wifi
  • Temperatura exterior:

Lo ideal es usar un controlador tipo gauge definiendo el origen de datos, los valores mínimos –máximo así la unidad y el descriptivo.

Asimismo, Freeboard permite añadir un histórico usando el tipo Sparkline.

Por ejemplo, así se mostraría en tiempo real como fluctúa la temperatura exterior:

  • Temperatura interior:Lo ideal, igual que con la temperatura exterior es usar un controlador tipo gauge definiendo el origen de datos, los valores mínimos –máximo así la unidad y el descriptivo.
  • Señal wifi:Lo ideal, es usar un controlador tipo gauge definiendo el origen de datos, los valores mínimos –máximo así la unidad y el descriptivo.
  • Humedad:Lo ideal, es usar un controlador tipo gauge definiendo el origen de datos, los valores mínimos –máximo así la unidad y el descriptivo.

También podemos mostrar la misma información en modo texto:

Es interesante además de mostrar un histórico, de modo que al igual que se ha hecho con la temperatura exterior lo haremos con la humedad exterior usando el control Sparkline:

Para terminar, usaremos un Pointer para mostrar un valor de la humedad mas visible.

Con todos estos cambios pulsaremos en “SAVE FREEBORAD” para almacenar en un fichero Json en local todos los cambios realizados

El aspecto de como queda el panel es el siguiente:

Podemos comprobar que la información es actualizada con la fuente de datos, usando el monitor serie de Arduino:

Extensiones de Chrome

Sin tener instalado Freeboard, aparte de la herramienta Postman (fundamental para depurar los formatos de envió), hay dos herramientas muy interesantes para monitorizar las variables almacenadas en Fiware alimentado por los datos  que nos está enviando nuestra placa ESP32 y el sensor DHT11.

Las dos extensiones de Google Chrome que han resultado muy útiles son las siguientes:

Json Handle

Esta extensión es no solo un browser sino también un editor documentos JSON permitiendo ver de una sola vez de una manera muy visualmente atractiva los datos en nuestro caso de los diferentes sensores.

Easy Auto Refresh

Esta extensión permite recargar la página a intervalos definidos para refrescar los datos y poder mostrar los cambios, lo cual es muy útil para no tener que estar constantemente refrescando la  página desde obtenemos la información del Content bróker ( en nuestro caso http://192.168.1.66:1026/v2/entities/ )

  Información útil

Instalacion de Grafana en Windows


Grafana es un software libre basado en licencia de Apache 2.0,​ que permite la visualización y el formato de datos métricos. Permite crear cuadros de mando y gráficos a partir de múltiples fuentes, incluidas bases de datos de series de tiempo como Graphite, InfluxDB y OpenTSDB​ Originalmente comenzó como un componente de Kibana y que luego le fue realizado una bifurcación.​

Lanzado en 2013 por Grafana Labs,Grafana es una de las soluciones de monitoreo de más rápido crecimiento en uso en 2019. Es multiplataforma sin ninguna dependencia y también se puede implementar con Docker. Está escrito en lenguaje Go y tiene un HTTP API completo. Además de administrar cuadros de mando clásicos (adiciones, eliminaciones, favoritos), Grafana ofrece compartir un cuadro de mando actual mediante la creación de un enlace o una instantánea estática del mismo.

Todos los paneles de control y las fuentes de datos están vinculados a una organización, y los usuarios de la aplicación están vinculados a organizaciones a través de roles.Evita que los usuarios sobrescriban accidentalmente un panel de control. Existe una protección similar cuando se crea un nuevo panel de control cuyo nombre ya existe. La herramienta tambien ofrece la posibilidad de configurar alertas.

Es una solución de dashboarding que conecta a una amplia variedad de orígenes de datos (la mayoría de las bases de datos de series temporales) con el fin de visualizar datos casi en tiempo real siendo uilizada por muchas grandes empresas como el CERN, Digital Ocean o PayPal,Grafana también se utiliza en pequeñas y medianas corporaciones dispuestas a tener retroalimentación sobre la salud de su infraestructura.

Descarga del archivo Grafana desde el sitio web oficial

Para Windows, abra su navegador web y vaya a la página de descargas de Grafana.

Seleccione “Windows” en la lista de sistemas operativos disponibles y haga clic en “Descargar el instalador“.

Grafana for Windows download option

La descarga de MSI debe comenzar.

Cuando haya terminado, simplemente ejecute el instalador msi.

Grafana MSI on Windows

Instalar Grafana en Windows

Al ejecutar el MSI, esto es lo que debería ver.

Grafana installation first step

Haga clic en “Siguiente“.

Grafana installation second step

Acepte los términos del contrato de licencia y haga clic en“Siguiente”.

Grafana installation third  step

Asegúrese de que el sistema operativo Grafana (el servidor Grafana) y la opción Grafana como servicio estén correctamente seleccionados.

Si este es el caso, haga clic en “Siguiente” y en “Instalar

Grafana installation fourth step

En este punto, la instalación de Grafana debe comenzar.

Si en algún momento se le solicita una excepción de firewall, asegúrese de autorizar a Grafana a realizar cambios en el sistema.

Cuando se realiza la instalación, esta es la pantalla que debería ver.

Grafana installation last step

¡Impresionante! Acaba de instalar Grafana en Windows.

Compruebe que su servicio Grafana se está ejecutando

Antes de ir más lejos, debe comprobar que el servidor Grafana se está ejecutando correctamente como un servicio de Windows.

En muchos casos, es posible que el puerto predeterminado de Grafana (3000) ya esté tomado, lo que impide que Grafana se inicie correctamente.

Como consecuencia, así es como puede comprobar que se está ejecutando.

En el menú de búsqueda de Windows, escriba “Servicios” y abra la ventana Servicios.

Windows services panel

En la ventana Servicios, desplácese hasta llegar al servicio Grafana.

Grafana service on Windows

 El servicio Grafana puede comprobar que ya está en funcionamiento.

Iniciar Grafana v6 Web UI

Si el servicio se está ejecutando correctamente, debería poder acceder a la interfaz de usuario de Grafana v6.

Como recordatorio, Grafana se ejecuta de forma predeterminada en el puerto 3000.

Como consecuencia, abra un navegador web y vaya a http://localhost:3000.

Esta es la pantalla que debería ver.

Grafana v6.3 default web UI on Windows

En Grafana, las credenciales predeterminadas son admin (como nombre de usuario) y admin (como contraseña) de forma predeterminada.

En la siguiente ventana, se le pedirá que cambie su contraseña. Elija una contraseña segura para evitar brechas de seguridad.

Grafana change password window

Cuando lo haya hecho pulsar en “Save“.

Ahora debería ver la pantalla predeterminada para Grafana v6.3 en Windows.

Grafana welcome default screen

Antes de crear sus propios paneles, hay algunos pasos de configuración que debe realizar para una nueva instancia.

Definición de su propio archivo de configuración

En las últimas distribuciones grafana para Windows, el servicio es lanzado por NSSM (que es un administrador de servicios para Windows).

De forma predeterminada, Grafana se basa en los archivos de configuración ubicados en la carpeta conf del directorio de instalación.

Mine se encuentra en C:\Program Files\GrafanaLabs\grafana como ejemplo.

Este es el contenido de la carpeta conf.

Grafana configuration folder on Windows

De forma predeterminada, Grafana va a usar el contenido del archivo .ini predeterminado, pero vamos a sobrescribir eso para tener nuestro propio archivo de configuración personalizado.

En caso de que estemos teniendo algunos problemas con nuestro propio archivo de configuración, podemos volver al archivo predeterminado fácilmente.

Haga una copia del archivo predeterminado y asígnele el nombre “custom.ini”

Adding a custom configuration file

Al ejecutar la instalación MSI, Grafana va a almacenar un ejecutable de NSSM en la carpeta GrafanaLabs de la carpeta de instalación.

NSSM executable on Windows

Abra una instancia de Powershell en el equipo como administradory vaya a esta carpeta.

No olvide las comillas alrededor de la ruta de acceso, de lo contrario obtendrá una excepción de Powershell.

$ cd "C:\Program Files\GrafanaLabs"
$ .\nssm.exe edit grafana

Se debe abrir una ventana similar a esta.

NSSM window edit service

Al final de la variable path, agregue una marca –config con el nombre del archivo de configuración que acabamos de crear.

Adding a custom argument on NSSM
Argumentos: --config conf\custom.ini

pulsar en “Edit Service” y debderia ver el siguinte mensajesuccess message.

Service Grafana edit successfully

Reinicie el servicio y asegúrese de que Grafana sigue ejecutándose correctamente (http://localhost:3000)

Avtivar sign-up en Grafana

De forma predeterminada, la creación de la cuenta se encuentra en http://localhost:3000/signup en la instancia de Grafana.

En Grafana v6.3, el registro de la cuenta está deshabilitado de forma predeterminada.

Sign up option on Grafana

Sin embargo, es posible que desee habilitar esta opción en su servidor Grafana, si autoriza a los invitados a tener una cuenta para mostrar algunos paneles especiales.

Para habilitar el registro, diríjase al archivo de configuración personalizado.ini (ubicado en la carpeta conf) y vaya a la sección [usuarios] del archivo.

Modifique la entrada allow_sign_up a true..

Allowing user sign up on Grafana

Para comprobar que todo funciona correctamente, vaya a http://localhost:3000/signup e intente crear una cuenta.

Grafana sign up page

Haga clic en “Registrarse” y debe ser redirigido a la página principal.

Grafana user panel

Activar acceso anonimo

De forma predeterminada, el acceso anónimo está deshabilitado en Grafana.

El acceso anónimo significa que cualquier usuario no autenticado puede examinar la instancia de Grafana, al menos para la organización predeterminada que se les ha asignado.

Grafana anonymous access option

Si va http://localhost:3000, se le redirigirá a la pantalla de inicio de sesión si es un usuario anónimo.

Para cambiar eso, edite el archivo de configuración personalizado.ini y edite la sección [auth.anonymous].

Grafana anonymous access configuration file

Reinicie el servicio Grafana y busque http://localhost:3000 como usuario anónimo (en modo privado, por ejemplo).

Ahora debe tener un permiso viewer para los paneles permitidos.

Access allowed for anonymous users on Grafana on Windows

Aquí hay una selección de artículos que debe leer para mejorar con Grafana :

Seguridad en IOT


El término Internet de las Cosas, en inglés Internet of Things ,hace referencia a la digitalización de todo tipo de dispositivos:

  • Sensores y actuadores 
  • Objetos comunes como vehículos
  • Cámaras de grabación
  • implantes médicos, ropa, etc. 

La conectividad digital de estos dispositivos permite enviar y recibir información para realizar tareas que hasta no hace mucho podrían parecer imposibles como monitorizar el estado de una flota de vehículos ,ver las cámaras de seguridad de la empresa desde un Smartphone, controlar cualquier electrodoméstico de forma remota, etc

Crecimiento

La consultora Gartner  pronostica que para el año 2021 habrá unos 25 mil millones de dispositivos IoT conectados en sectores tan dispares como:

  • Domótica 
  • Salud
  • Transporte y logística 
  • Seguridad y vigilancia

Se podría decir que con el IoT se inicia una revolución en la forma en que vivimos y trabajamos.Sus aplicaciones son muy diversas: monitorización salud , domótica en edificios y ciudades, aplicaciones en industria 4.0.

El acceso a la tecnología ha democratizado el IoT   reduciendo los costes  y con capacidades  avanzadas

  • REDUCIDOS COSTES:
    Los chips para dar inteligencia a los objetos
    Los módulos para dar conectividad a los objetos
    Los entorno de desarrollo para programarlo
    Los costes de hacer un prototipo
  • CAPACIDADES AVANZADAS
    Soluciones de gran capacidad a bajos coste
    Infinidad de tecnologías de comunicación
    Enorme comunidad desarrolladora

El    problema  viene  con algunas aplicaciones de IOT donde nos cuestionamos  hasta que punto los riesgos son mayores que las ventajas  y marabillas en el uso de esta tecnologías: es decir Seguridad vs Confort o lo que es lo mismo RIESGO VS RECOMPENSA

Estas son algunas  brechas que debemos superar:

  • Interacción humana de baja fricción
  • Identificación única de dispositivos
  • Autenticación de dispositivos
  • Asociación dispositivos-usuarios
  • Naturaleza de los datos

Ademas por si fuera poco, tenemos  grandes  retos  y desfios

  • Capacidades limitadas de encriptación
  • Recursos limitados (RAM/ROM)
  • Limitada sincronización
  • El fw debe ser actualizado tiempo al tiempo

Como vemos en la grafica de abajo  pues una de las grandes barreras  para adaptar el IOT es la seguridad:

 

Y es que el mal nunca descansa , como lo demuestran los innumerables ejemplos de  ataques:

Caso Mirai
La botnet Mirai ha sido utilizada en algunos de los ataques del tipo DDoS más grandes y bruscos de la historia, dentro de los que se incluyen el realizado al sitio web de Brian Krebs , y al proveedor Dyn en octubre de 2016.

Mirai es un malware de la familia de las botnets destinada a infectar los equipos conformantes del IoT.​ El objetivo principal de este malware es la infección de routers y cámaras IP, usando estos para realizar ataques de tipo DDoS

Amenazas para el propio dispositivo
Los dispositivos IoT pueden ser una presa fácil para los ciberdelincuentes que buscan este tipo de dispositivos como punto de entrada a las redes de las empresas o a otros puntos que se encuentran más protegidos.

Además, los propios dispositivos IoT no son inmunes a las amenazas pues los ciberdelincuentes pueden enfocar sus esfuerzos en atacar su funcionalidad, siendo la denegación de servicio uno de los principales peligros, dejándolos inoperativos o no accesibles.

Amenazas para el propio dispositivo
Las amenazas a los dispositivos IoT no se reducen a las derivadas de su conectividad a Internet. Muchos de estos aparatos cuentan también con capacidades de conexión inalámbrica como wifi, Bluetooth o Zigbee, lo que puede suponer otro vector de ataque para ciberdelincuentes si se encuentran dentro de su rango de acción

+Amenazas para el dispositivo

Consecuencias graves para la seguridad como:

  • Infectarlos para formar parte de una red zombi que los utilicen para realizar ciberataques, por ejemplo, de denegación de servicio distribuida o DDoS
  • Utilizarlos como puente o punto de entrada para atacar otros equipos de la misma red, para robar información o comprometer servidores o para realizar otras acciones delictivas
  • Reconfigurarlos para inhabilitarlos o cambiar sus condiciones de utilización

Como resumen , estos algunos de los vectores de ataque para los dispositivos IoT:

  • Fallos en la implementación
  • Interceptar datos de tránsito(ataque Man in the Middle)
  • Acceso a la plataforma de administración
  • Vulnerabilidad en el software
  • Configuraciones por defecto
  • Acceso físico al dispositivo
  • Los propios usuarios por ingeniería social

 

Medidas de seguridad

En los dispositivos IoT no se suelen utilizar las soluciones habituales de ciberseguridad como antivirus o cortafuegos; por ello, las siguientes medidas de seguridad están destinadas a proteger el propio dispositivo y, por consiguiente, toda la organización:

  • Acceso seguro al dispositivo (evitar conf. por defecto)
  • Comunicaciones seguras
  • Actualizaciones de seguridad
  • Dispositivos de seguridad perimetral
  • Seguridad física ( ej.: puertos, usb,sd, etc)
  • Concienciación en seguridad de los usuarios

Y  estas son algunas recomendaciones de seguridad:

  • Se comprobará cada cierto tiempo la visibilidad de los dispositivos IoT en Internet con herramientas específicas como Shodan.
  • Si el dispositivo lo permite se habilitará un registro de logs que guarde los eventos que se producen como accesos, cambios de contraseña, actualizaciones, etc.
  • En caso de ser posible, se ha de habilitar algún mecanismo de notificación cuando se produce un evento que pueda afectar a la seguridad del dispositivo.
  • Se monitorizarán de forma centralizada los dispositivos IoT para comprobar su correcto funcionamiento y que no se producen eventos que puedan afectar a su seguridad o a la de la empresa.
  • Se comprobará regularmente la web del fabricante en busca de nuevas actualizaciones de seguridad tanto de firmware como de software siempre que no exista un método alternativo que avise sobre ello
  • Uso de herramientas adicionales (ejemplo https://www.shodan.io)

DISEÑO en IOT:  REGLAS DE DISEÑO

En caso de estar diseñando un nuevo dispositivo IoT , algunos principios que de deberiamos  seguir

Seguridad:

  • CONSTRUIR CON SEGURIDAD INCLUIDA ( NO PUEDE SER AÑADIDA DESPUES)
  • Mantener mecanismos de seguridad simples
  • Usar estándares de seguridad
  • La oscuridad no provee seguridad
  • Encriptar datos sensibles en reposo y en transito
  • Usar bloques criptográficos bien estudiados
  • Identidad y gestión de acceso deben ser parte del diseño
  • Desarrollar un modelo de amenazas realista

Servicios de red

  • ASEGURARSE DE QUE DATOS Y CREDENCIALES SON ENCRIPTADOS MIENTRAS ESTAÑEN TRANSITO
  • USAR CANALES ENCRIPTADOS SEGUROS
  • USAR OPTIMAS LONGITUDES DE CLAVES Y BUENOS ALGORITMOS ( CURVA ELÍPTICA PROVEE UNA ENCRIPTACIÓN EFICIENTE)
  • PROTEGERSE CONTRA ATAQUES REPETITIVOS
  • Encriptación del transporte:
    • ASEGURAR SOLAMENTE LOS PUERTOS ABIERTOS NECESARIOS.
    • ASEGURAR QUE LOS SERVICIOS NO SON VULNERABLES.
    • DESPORDAMIENTO DE BUFEFR Y ATAQUES FUZZING.
    • ASEGURAR QUE LOS SERVICIOS NO SON VULNERABLES A ATAQUES DDNS

Privacidad como parte del diseño

  • Recolectar solamente los datos mínimos para el funcionamiento del dispositivo
  • Asegurarse que datos sensibles recogidos son protegidos con encriptación
  • Asegúrese de que el dispositivo protege adecuadamente los datos personales

Web, movilidad e interfaces cloud

  • No permita credenciales por defecto
  • Asumir accesos al dispositivos internamente y externamente
  • Las credenciales no deberían almacenarse en ficheros planos de texto ni viajar por canales no encriptados
  • Protegerse contra XSS,CSRF,SQLi
  • Implementar un sistema IAM/IRM
  • Protegerse contra la enumeración de cuentas e implementar el bloqueo de cuentas
  • Asegúrese de que su fw no contenga credenciales codificadas ni datos confidenciales
  • Utilice un canal seguro para transmitir el fw durante las actualizaciones
  • Asegúrese de que la actualización esté firmada y verificada antes de permitir la actualización.
  • No envíe la clave pública con el fw, use un hash
  • Asegúrese de que sus repositorios SVN/ GIT no contengan las claves privadas

SOFWARE/ FIRMWARE

  • Seguridad Física
  • Asegurar que el acceso físico a su dispositivo está controlado
  • Los puertos USB o SD accesibles pueden ser eficientes
  • ¿Se puede desmontar fácilmente para acceder al almacenamiento interno (RAM / ROM)?
  • Si los datos locales son confidenciales, considere la posibilidad de cifrarlos

 

Photo by Sebastian Palomino on Pexels.com

DECALOGO SOBRE RECOMENDACIONES DE SEGURIDAD

  1. Minimizar el uso de dispositivos IoT especialmente en empresas utilizando únicamente los que sean estrictamente necesarios.
  2. No usar, en la medida de lo posible, dispositivos IoT que transmitan información o cuya gestión se realice desde servidores externos aunque sea del fabricante.
  3. Comprobar las configuraciones por defecto del dispositivo, especialmente antes de permitir su acceso desde Internet y, de ser posible, elegir aquellos dispositivos que permitan un elevado
    nivel de seguridad.
  4. Si no es posible establecer configuraciones de seguridad robustas no se permitirá el acceso al dispositivo desde Internet y preferiblemente tampoco desde la red local.
  5. Establecer siempre contraseñas de acceso y administración robustas. Siempre que sea posible se forzará su uso.
  6. Establecer siempre contraseñas de acceso y administración robustas. Siempre que sea posible se forzará su uso.
  7. Mantener actualizado el dispositivo a la última versión.
  8. Mantener abiertos a Internet únicamente aquellos servicios que sean necesarios para su administración remota y los que no lo sean se deben deshabilitar. También hay que cambiar los puertos de los servicios cuando sea posible.
  9. Utilizar dispositivos de seguridad perimetral como cortafuegos para proteger la seguridad del dispositivo IoT.
    DECALOGO SOBRE RECOMENDACIONES DE SEGURIDAD
  10. Emplear mecanismos que permitan asegurar la autenticidad,integridad y confidencialidad de las comunicaciones especialmente si estas se realizan vía wifi.
  11. Auditar periódicamente los dispositivos IoT.
  12. Concienciar especialmente a los empleados sobre la importancia de la ciberseguridad en el día a día de su trabajo y en la administración y uso de este tipo de dispositivos.
  13. Comprobar la seguridad física del dispositivo y aplicar
    las medidas necesarias que eviten manipulaciones de terceros
    DECALOGO SOBRE RECOMENDACIONES DE SEGURIDAD

Fuentes
HTTPS://WWW.GARTNER.COM
HTTPS://WWW.INCIBE.ES
HTTPS://WWW.COMPUTING.ES
HTTPS://UNAALDIA.HISPASEC.COM
HTTPS://BLOG.F-SECURE.COM
HTTPS://SOLOELECTRONICOS.COM