# Guia Completa para mi Dashboard IOT en Ubuntu 18.04LTS
## Actualizamos los paquetes en Ubuntu
Ejecutar cada vez que ingresamos sesion por primera vez
```
sudo apt update
```
Ejecutar solo si Ubuntu me lo sugiere
```
apt list --upgradable
```
```
sudo apt upgrade
```
## Habilitamos el firewall ufw
Lista las aplicaciones que reconoce ufw
```
sudo ufw app list
```
Habilita la aplicacion OpenSSH
```
sudo ufw allow OpenSSH
```
Habilita el firewall
```
sudo ufw enable
```
Verificamos si la app se activo sin problemas
```
sudo ufw status
```
## Instalamos Nginx
Antes de instalar Nginx actualizamos los paquetes
```
sudo apt update
```
Instalamos nginx con apt
```
sudo apt install nginx
```
Listamos las aplicaciones de nginx que reconoce UFW
```
sudo ufw app list
```
Obtenemos en pantalla lo siguiente
Habilitamos la regla de firewall Nginx HTTP
```
sudo ufw allow 'Nginx HTTP'
```
Verificamos si se ha activado la regla Nginx
```
sudo ufw status
```
Verificamos si Nginx esta ejecutandose correctamente
```
systemctl status nginx
```
Vamos a nuestro navegador digitamos nuestra ip en una nueva pestaña para verificar que Nginx ha iniciado correctamente
http://my_ip
Obtenemos la siguiente pagina web
## Configuramos nuestros DNS para la MV en Godaddy
Nuestro dominio completo seria prueba.atiy.org
## Configuracion del servidor para nuestro subdominio
Se reemplaza example.com por mi dominio o subdominio configuracion para esta MV
Utilizamos la marca para crear el directorio necesario
```
sudo mkdir -p /var/www/example.com/html
```
Le asignamos la propiedad el directorio
```
sudo chown -R $USER:$USER /var/www/example.com/html
```
Le asignamos permisos de raices
```
sudo chmod -R 755 /var/www/example.com
```
Creamos el archivo index.html y a su ingresamos al archivo con nano
```
nano /var/www/prueba.atiy.org/html/index.html
```
Ingresamos este codigo html como prueba de nuestra pagina web para el subdominio
```
<html>
<head>
<title> Welcome to Example.com!</title>
</head>
<body>
<h1>Success! The example.com server block is working!</h1>
</body>
</html>
```
Configuramos el servidor para nuestro subdominio
```
sudo nano /etc/nginx/sites-available/example.com
```
root -> es la direccion donde esta nuestro archivo html
index -> es el nombre de nuestro archivo html
server_name -> el nombre de nuestro subdominio para que apunte a este servidor
```
server {
listen 80;
listen [::]:80;
root /var/www/example.com/html;
index index.html index.htm index.nginx-debian.html;
server_name example.com www.example.com;
location / {
try_files $uri $uri/ = 404;
}
}
```
Creamos el link del archivo de configuracion al directorio de donde nginx lee para mostrar un servidor configurado
```
sudo ln -s /etc/nginx/sites-available/example.com /etc/nginx/sites-enabled/
```
Abrimos el archivo de configuracion de nginx
```
sudo nano /etc/nginx/nginx.conf
```
Descomentamos esta linea en el archivo de configuracion
```
server_names_hash_bucket_size 64;
```
Ejecutamos el siguiente comando para verificar que nginx se ha configurado correctamente
```
sudo nginx -t
```
Obtenemos en pantalla lo siguiente
Reiniciamos Nginx para aplicar los cambios
```
sudo systemctl restart nginx
```
Ahora nos mostrará el html que previamente hemos configurado
## Instalar Grafana en Ubuntu 18.04LTS
Descargamos la clave GPG
```
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -
```
Agregamos el repositorio de Grafana
```
sudo add-apt-repository "deb https://packages.grafana.com/oss/deb stable main"
```
Verificamos que el repositorio haya sido agregado
```
sudo nano /etc/apt/sources.list
```
Actualizamos los paquetes
```
sudo apt update
```
Instalamos Grafana
```
sudo apt install grafana
```
## Iniciamos y habilitamos Grafana con el arranque del sistema
Utilizamos systemctl para iniciar el servidor de Grafana
```
sudo systemctl start grafana-server
```
Verificamos si Grafana se esta ejecutando correctamente
```
sudo systemctl status grafana-server
```
Habilitamos el servicio de Grafana para que arranque con el sistema
```
sudo systemctl enable grafana-server
```
## Configuramos Nginx como servidor proxy inverso
Abrimos el archivo de configuracion de nuestro servidor y modificamos la linea `try_files $uri $uri/ =404;` por `proxy_pass http://localhost:3000;`. Luego guardamos y cerramos
```
sudo nano /etc/nginx/sites-available/example.com
```
Verificamos si tenemos errores en nginx
```
sudo nginx -t
```
Reiniciamos Nginx
```
sudo systemctl restart nginx
```
Nos dirigimos al navegador y seteamos nuestro subdominio. Nos mostrará la pagina web de Grafana.
Credenciales por defecto
```
usuario: admin
contraseña: admin
```
Luego tendremos que ingresar una nueva contraseña y finalmente estaremos dentro de Grafana
## Desactivación de registros y acceso anónimo en Grafana
Comenzamos abriendo el archivo de configuración de Grafana
```
sudo nano /etc/grafana/grafana.ini
```
Localizamos la siguiente directiva `allow_sign_up`, luego descomentamos esta directiva borrando el `;` y modificamos true por false. Quedando así.
A continuación deshabilitamos el acceso anónimo. Buscamos la siguiente directiva `auth.anonymous` lo descomentamos borrando el `;` y lo dejamos como false quedando asi.
Reiniciamos el servidor de Grafana para aplicar los cambios
```
sudo systemctl restart grafana-server
```
## Instalamos Mysql en Ubuntu 18.04LTS
Actualizamos los paquetes
```
sudo apt update
```
Instalamos Mysql utilizando apt
```
sudo apt install mysql-server
```
## Configuramos la seguridad de Mysql
Esto hara que pase por una serie de indicaciones en las que puede hacer algunos cambios de opciones de seguridad en Mysql
```
sudo mysql_secure_installation
```
## Ajustamos la autentificación y los privilegios del usuario root en Mysql
Ingresamos a mysql
```
sudo mysql
```
Consultamos que método de autentificacion usa el usuario root en mysql
```
SELECT user,authentication_string,plugin,host FROM mysql.user;
```
Nos mostrará la siguiente tabla donde vemos que el usuario root no tiene contraseña
Para configurar la cuenta root para autentificarse con contraseña ejecutamos el siguiente comando. Modifricar password por nuestra contraseña.
```
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';
```
Recargamos las tablas para aplicar los cambios
```
FLUSH PRIVILEGES;
```
Salimos de mysql
```
exit
```
Ahora para ingresar a mysql sera de la siguiente manera la cual despues nos pedira nuestra contraseña.
```
mysql -u root -p
```
## Creamos el nuevo usuario para la bd mqtt
Ingresamos como usuario root
```
mysql -u root -p
```
Creamos el usuario
```
CREATE USER 'my_user'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';
```
Recargamos para aplicar los cambios
```
FLUSH PRIVILEGES;
```
## Creamos la bd llamada mqtt
Creamos la base de datos
```
CREATE DATABASE mqtt;
```
Le asignamos los privilegios a la base de datos, modificamos my_user por el nombre de nuestro usuario
```
GRANT ALL PRIVILEGES ON mqtt.* to 'my_user'@'localhost';
```
Recargamos para aplicar los cambios
```
FLUSH PRIVILEGES;
```
Salimos de mysql
```
exit
```
## Instalacion de Node.js y NPM medienda NVM
Actualizamos los paquetes del sistema
```
sudo apt update
```
Descargar la secuencia de comandos de instalacion de nvm
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.36.0/install.sh | bash
```
Cerramos la terminal, volvemos a ingresar y verificamos la version de nvm
```
nvm --version
```
Instalamos node.js y npm utilizando nvm
```
nvm install --lts
```
Verificamos la version de node.js y npm
```
node -v
```
```
npm -v
```
## Instalamos Node-RED
Instalamos node-red con npm
```
npm install -g --unsafe-perm node-red node-red-admin
```
Ejecutamos node-red
```
node-red
```
Obtenemos por consola lo siguiente
Aseguramos Node-RED
```
node-red-admin hash-pw
```
Digitamos nuestra contraseña, despues nos devolvera una cadena de caracteres, lo copiamos y lo guardamos.
Abriremos el archivo de configuracion de node-red
```
nano /home/user/.node-red/settings.js
```
Ubicamos la directiva adminAuth, luego descomentamos las lineas borrando las //, quedando de la siguiente manera. Modificamos el username si queremos y pegamos la cadena de caracteres generada hace un momento entre las comillas de pasword
Despues de hacer los cambios respectivos guardamos, cerramos y ejecutamos node-red
## Utilizaremos PM2 para ejecutar node-red en segundo plano
Instalamos PM2 con NPM
```
npm install pm2 -g
```
Utilizamos pm2 para ejecutar el archivo red.js
```
pm2 start ~/.nvm/versions/node/v14.16.1/lib/node_modules/node-red/red.js
```
Nos dirigiremos a nuestro navegador para verificar que node-red se esta ejecutando correctamente.
Ejecutamos el siguiente comando para que pm2 arranque con el sistema
```
pm2 startup
```
Guardamos la lista de procesos de pm2
```
pm2 save
```
## Configuramos un servidor como proxy inverso para node-red
Primero registramos un subdominio para node-red
Anteriormente se ha hecho, guiarse de la documentacion
Esta vez configuramos el servidor con unas lineas adicionales para que soporte websocket quedando de la siguiente manera:
```
location / {
proxy_pass http://localhost:1880;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "Upgrade";
proxy_set_header Host $host;
}
```
verificamos si hay errores
```
sudo nginx -t
```
Reiniciamos nginx para que se apliquen los cambios
```
sudo systemctl restart nginx
```
## Instalacion del Broker MQTT EMQX
Ingresamos como usuario root
```
sudo su
```
Luego nos dirigiremos al directorio raiz
```
cd /
```
Utilizamos wget para descargar el archivo comprimido
Adjunto link para actualizaciones https://www.emqx.io/downloads#broker
```
wget https://www.emqx.io/downloads/broker/v4.2.11/emqx-ubuntu18.04-4.2.11-x86_64.zip
```
Para descomprimir este archivo instalaremos unzip
```
sudo apt install unzip
```
Descomprimiremos el archivo zip con unzip
```
unzip emqx-ubuntu18.04-4.2.11-x86_64.zip
```
Cambiamos los puertos comunes. Cambiamos el puerto 8083 por el 8093 y el 8084 por el 8094
```
nano /emqx/etc/emqx.conf
```
Guardamos los cambios y cerramos
Modificamos el puerto 8081 al 8090 del siguiente archivo
```
nano /emqx/etc/plugins/emqx_management.conf
```
Guardamos los cambios y cerramos
Listo de puertos que utiliza el Broker MQTT
Salimos del usuario root
```
exit
```
Habilitamos los puertos en el firewall UFW
```
sudo ufw allow 1883/tcp
sudo ufw allow 8883/tcp
sudo ufw allow 8093/tcp
sudo ufw allow 8094/tcp
sudo ufw allow 8090/tcp
```
Como estamos utilizando GCP abriremos los puertos del firewall ahi tambien
Ejecutamos el Broker MQTT
```
sudo /emqx/bin/emqx start
```
Agregaremos un subdominio en nuestro administrador DNS para el Broker MQTT
Configuraremos un nuevo servidor proxy inverso para el Broker MQTT. Seguir la guia como los pasos anterior, recordar que la Dashboard del Broker MQTT utiliza el procotolo Websocket por ende se debe habilitar en el nginx proxy inverso
```
location / {
proxy_pass http://localhost:18083;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "Upgrade";
proxy_set_header Host $host;
}
```
Accedemos a la Dashboard del Broker MQTT con nuestro dominio y modificamos la contraseña por defecto que nos brinda EMQX Boker
```
username: admin
password: public
```
## Configuración del plugin Mysql para la autentificacion de usuario y topicos MQTT
Utilizamos el editor de texto nano para configurar el archivo
```
sudo nano /emqx/etc/plugins/emqx_auth_mysql.conf
```
Modificamos las directivas con nuestras credenciales de la base de datos quedando de la siguiente manera
```
## server address
auth.mysql.server = 127.0.0.1:3306
## Connection pool size
auth.mysql.pool = 8
auth.mysql.username = myuser
auth.mysql.password = mypassword
auth.mysql.database = mqtt
auth.mysql.query_timeout = 5s
```
Guardamos y cerramos el archivo
Desactivamos las conexiones anónimas
```
sudo nano /emqx/etc/emqx.conf
```
Editamos la directiva allow_anonymous de true a false, quedando de la siguiente manera
Guardamos y cerramos
Reiniciamos el broker MQTT para aplicar los cambios
```
sudo /emqx/bin/emqx restart
```
## Creamos las tablas mqtt_user y mqtt_acl para la autentificación de usuario con topicos.
Ingresamos a mysql con nuestro usuario
```
mysql -u my_user -p
```
Seleccionamos la base de datos
```
use mqtt;
```
Creamos la tabla mqtt_user
```
CREATE TABLE `mqtt_user` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`username` varchar(100) DEFAULT NULL,
`password` varchar(100) DEFAULT NULL,
`salt` varchar(35) DEFAULT NULL,
`is_superuser` tinyint(1) DEFAULT 0,
`created` datetime DEFAULT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `mqtt_username` (`username`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
```
Por motivo de que EMQX Broker utiliza SHA256 necesitamos encriptar nuestraseña a este tipo. Utilizamos esta herramienta de internet
https://www.convertstring.com/es/Hash/SHA256
Ingresamos un registro con nuestro usuario y contraseña mqtt
```
INSERT INTO mqtt_user ( username, password, salt)
VALUES (‘mi-usuario’, ‘mi-contraseña-en-SHA256’, NULL)
```
Ahora creamos la tabla mqtt_acl
```
CREATE TABLE `mqtt_acl` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`allow` int(1) DEFAULT 1 COMMENT '0: deny, 1: allow',
`ipaddr` varchar(60) DEFAULT NULL COMMENT 'IpAddress',
`username` varchar(100) DEFAULT NULL COMMENT 'Username',
`clientid` varchar(100) DEFAULT NULL COMMENT 'ClientId',
`access` int(2) NOT NULL COMMENT '1: subscribe, 2: publish, 3: pubsub',
`topic` varchar(100) NOT NULL DEFAULT '' COMMENT 'Topic Filter',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
```
Definicio de los campos de la tabla segun la documentacion de EMQX
Ingresamos la regla para denegar la conexion de todos los usuario a cualquier topico
```
INSERT INTO mqtt_acl (allow, ipaddr, username, clientid, access, topic)
VALUES (0, NULL, ‘$all', NULL, 3, ‘+/#’);
```
Despues de esta regla agregaremos las reglas segun nuestra conveniencia
Sign in with Wallet
Connect another wallet