¿cuanta gente a visto el blog?

LAs APIS

 se usan para automatizacion

integracion de datos

funcionalidad

programar con esta informacion, presentar de otra formna


son populares porque estan diseñadas en los productosm Mikrotik por ejemplo


las camaras pemiten por apis

Las Apps que permiten registrar compras, aplicaciones sincronicas


las apps asincronicas es ciando piden un recursos y deben esperar un rato


EL CLIENTE y el servidor deben ser independientes entre si

no se va a bloquear en estados

Tener modelo cache

indicar si las respuestas se pueden guardar en cache o ni


como en el servidort dns interno, no necesita salir a intetrnet si esta en un servidor dns


solo proporsiona servicios a la capa superior


El HTTP esta en diferentes conceptos


da 4 componentes, el URI , como una URL

    http metod



EL URI, Se tiene el tipo de procolo que se usara, en este caso el htttp

Ver el tipo de protcolo, que equipo mne voy a conectar, peurto, a quer  voy a consumir y que voy a preguntar 

direccion-puerto-recursos-quelevpyapedir

ghypi

 da gifs


http method

Post crea un objetoi
get obtiene informacion
put actualiza o reemoplaza akgoi
patch, actualiza algunso detalles del recurso
delete borra recursos del sistema


necesit especificar el token 

no se puede conectar asi porque si, requiere un token de autenficiacion

el servidor responde con codigo estadus, header y bog

http

el tipo de informacion debe ir comprimida
la secuencia DE USO DE un apired


descargar postman
Requiere crearse una cuenta en Giphy, crear un Token, 
hay una gif URL, la direccion que van a generar

Raid con PHP

 Crear archivos

lsblk 
dnf install -y mdadm

sudo dnf update


mdadm --version
sudo nano /var/www/html/configurar_raid.sh

#!/bin/bash

# Parámetros recibidos
TIPO_RAID=$1           # Tipo de RAID (ejemplo: 0, 1, 5)
DISCO1=$2              # Primer disco
DISCO2=$3              # Segundo disco
MOUNTPOINT=$4          # Punto de montaje

# Verificar que los parámetros no estén vacíos
if [ -z "$TIPO_RAID" ] || [ -z "$DISCO1" ] || [ -z "$DISCO2" ] || [ -z "$MOUNTPOINT" ]; then
    echo "Error: Faltan parámetros. Uso: ./configurar_raid.sh <TIPO_RAID> <DISCO1> <DISCO2> <MOUNTPOINT>"
    exit 1
fi

# Crear el RAID
sudo mdadm --create --verbose /dev/md0 --level=$TIPO_RAID --raid-devices=2 $DISCO1 $DISCO2

# Crear un sistema de archivos en el RAID
sudo mkfs.ext4 /dev/md0

# Crear el directorio de montaje si no existe
sudo mkdir -p $MOUNTPOINT

# Montar el RAID
sudo mount /dev/md0 $MOUNTPOINT

# Verificar que el RAID esté montado
if mount | grep /dev/md0; then
    echo "RAID $TIPO_RAID creado y montado correctamente en $MOUNTPOINT."
else
    echo "Error al montar el RAID."
fi
sudo chmod +x /var/www/html/configurar_raid.sh



sudo nano /var/www/html/raid_config.php

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Configurar RAID</title>
</head>
<body>
    <h1>Configurar RAID</h1>
    <form action="raid_config.php" method="post">
        <label for="tipo_raid">Tipo de RAID:</label>
        <input type="text" id="tipo_raid" name="tipo_raid" placeholder="Ejemplo: 0, 1, 5" required><br><br>

        <label for="disco1">Primer Disco:</label>
        <input type="text" id="disco1" name="disco1" placeholder="/dev/nvme0n2" required><br><br>

        <label for="disco2">Segundo Disco:</label>
        <input type="text" id="disco2" name="disco2" placeholder="/dev/nvme0n3" required><br><br>

        <label for="mountpoint">Punto de Montaje:</label>
        <input type="text" id="mountpoint" name="mountpoint" placeholder="/mnt/raid" required><br><br>

        <button type="submit">Configurar RAID</button>
    </form>

    <?php
    if ($_SERVER['REQUEST_METHOD'] === 'POST') {
        $tipo_raid = escapeshellarg($_POST['tipo_raid']);
        $disco1 = escapeshellarg($_POST['disco1']);
        $disco2 = escapeshellarg($_POST['disco2']);
        $mountpoint = escapeshellarg($_POST['mountpoint']);



        // Ejecutar el script Bash
        $comando = "/var/www/html/configurar_raid.sh $tipo_raid $disco1 $disco2 $mountpoint";
        $salida = shell_exec("sudo $comando 2>&1");

        echo "<h2>Resultado:</h2>";
        echo "<pre>$salida</pre>";
    }
    ?>
</body>
</html>
sudo visudo

apache ALL=(ALL) NOPASSWD: /var/www/html/configurar_raid.sh

*Presiona ESC y luego / en tu teclado. Esto habilita el modo de búsqueda. 

apache ALL=(ALL) NOPASSWD: /var/www/html/configurar_raid.sh

como saber que se creo correctamente

cat /proc/mdstat

mount | grep /dev/md0
echo "Prueba de RAID 0" > /mnt/raid/prueba.txt
cat /mnt/raid/prueba.txt

sudo mdadm --detail /dev/md0
lsblk 
mkdir -p /root/scripts


crea un RAID 0 usando los discos nvme0n2 y nvme0n3

nano /root/scripts/crear_raid0.sh
#!/bin/bash

# Asegurarse de que el script se ejecuta como root
if [ "$EUID" -ne 0 ]; then
  echo "Por favor, ejecuta este script como root."
  exit 1
fi

# Instalar mdadm si no está instalado
if ! command -v mdadm &> /dev/null; then
  echo "mdadm no está instalado. Instalando..."
  yum install -y mdadm  # Para sistemas basados en RHEL, como AlmaLinux
fi

# Crear el RAID 0 con nvme0n2 y nvme0n3
echo "Creando RAID 0 con nvme0n2 y nvme0n3..."
mdadm --create --verbose /dev/md0 --level=0 --raid-devices=2 /dev/nvme0n2 /dev/nvme0n3

# Crear el sistema de archivos en el RAID
echo "Creando sistema de archivos ext4 en /dev/md0..."
mkfs.ext4 /dev/md0

# Crear un punto de montaje y montar el RAID
echo "Montando el RAID en /mnt/raid0..."
mkdir -p /mnt/raid0
mount /dev/md0 /mnt/raid0

# Añadir el RAID al archivo fstab para montar automáticamente al iniciar
echo "Añadiendo el RAID al archivo /etc/fstab..."
echo "/dev/md0 /mnt/raid0 ext4 defaults 0 0" >> /etc/fstab

# Confirmar que el RAID se creó correctamente
cat /proc/mdstat

echo "RAID 0 creado y montado en /mnt/raid0. ¡Listo!"

 chmod +x /root/scripts/crear_raid0.sh
sudo /root/scripts/crear_raid0.sh


raid 1

nano /root/scripts/crear_raid1.sh

#!/bin/bash

# Asegurarse de que el script se ejecuta como root
if [ "$EUID" -ne 0 ]; then
  echo "Por favor, ejecuta este script como root."
  exit 1
fi

# Instalar mdadm si no está instalado
if ! command -v mdadm &> /dev/null; then
  echo "mdadm no está instalado. Instalando..."
  yum install -y mdadm
fi

# Crear el RAID 1 con nvme0n4 y nvme0n5
echo "Creando RAID 1 con nvme0n4 y nvme0n5..."
mdadm --create --verbose /dev/md1 --level=1 --raid-devices=2 /dev/nvme0n4 /dev/nvme0n5

# Crear el sistema de archivos en el RAID
echo "Creando sistema de archivos ext4 en /dev/md1..."
mkfs.ext4 /dev/md1

# Crear un punto de montaje y montar el RAID
echo "Montando el RAID en /mnt/raid1..."
mkdir -p /mnt/raid1
mount /dev/md1 /mnt/raid1

# Añadir el RAID al archivo fstab para montar automáticamente al iniciar
echo "Añadiendo el RAID al archivo /etc/fstab..."
echo "/dev/md1 /mnt/raid1 ext4 defaults 0 0" >> /etc/fstab

# Confirmar que el RAID se creó correctamente
cat /proc/mdstat

echo "RAID 1 creado y montado en /mnt/raid1. ¡Listo!"

chmod +x /root/scripts/crear_raid1.sh

sudo /root/scripts/crear_raid1.sh

raid 5

nano /root/scripts/crear_raid5.sh

#!/bin/bash

# Asegurarse de que el script se ejecuta como root
if [ "$EUID" -ne 0 ]; then
  echo "Por favor, ejecuta este script como root."
  exit 1
fi

# Instalar mdadm si no está instalado
if ! command -v mdadm &> /dev/null; then
  echo "mdadm no está instalado. Instalando..."
  yum install -y mdadm
fi

# Crear el RAID 5 con nvme0n6, nvme0n7, y nvme0n8
echo "Creando RAID 5 con nvme0n6, nvme0n7 y nvme0n8..."
mdadm --create --verbose /dev/md2 --level=5 --raid-devices=3 /dev/nvme0n6 /dev/nvme0n7 /dev/nvme0n8

# Crear el sistema de archivos en el RAID
echo "Creando sistema de archivos ext4 en /dev/md2..."
mkfs.ext4 /dev/md2

# Crear un punto de montaje y montar el RAID
echo "Montando el RAID en /mnt/raid5..."
mkdir -p /mnt/raid5
mount /dev/md2 /mnt/raid5

# Añadir el RAID al archivo fstab para montar automáticamente al iniciar
echo "Añadiendo el RAID al archivo /etc/fstab..."
echo "/dev/md2 /mnt/raid5 ext4 defaults 0 0" >> /etc/fstab

# Confirmar que el RAID se creó correctamente
cat /proc/mdstat

echo "RAID 5 creado y montado en /mnt/raid5. ¡Listo!"

raid 6

nano /root/scripts/crear_raid6.sh

#!/bin/bash

# Asegurarse de que el script se ejecuta como root
if [ "$EUID" -ne 0 ]; then
  echo "Por favor, ejecuta este script como root."
  exit 1
fi

# Instalar mdadm si no está instalado
if ! command -v mdadm &> /dev/null; then
  echo "mdadm no está instalado. Instalando..."
  yum install -y mdadm
fi

# Crear el RAID 6 con nvme0n2 a nvme0n8
echo "Creando RAID 6 con nvme0n2, nvme0n3, nvme0n4, nvme0n5, nvme0n6, nvme0n7 y nvme0n8..."
mdadm --create --verbose /dev/md3 --level=6 --raid-devices=7 /dev/nvme0n2 /dev/nvme0n3 /dev/nvme0n4 /dev/nvme0n5 /dev/nvme0n6 /dev/nvme0n7 /dev/nvme0n8

# Crear el sistema de archivos en el RAID
echo "Creando sistema de archivos ext4 en /dev/md3..."
mkfs.ext4 /dev/md3

# Crear un punto de montaje y montar el RAID
echo "Montando el RAID en /mnt/raid6..."
mkdir -p /mnt/raid6
mount /dev/md3 /mnt/raid6

# Añadir el RAID al archivo fstab para montar automáticamente al iniciar
echo "Añadiendo el RAID al archivo /etc/fstab..."
echo "/dev/md3 /mnt/raid6 ext4 defaults 0 0" >> /etc/fstab

# Confirmar que el RAID se creó correctamente
cat /proc/mdstat

echo "RAID 6 creado y montado en /mnt/raid6. ¡Listo!"

chmod +x /root/scripts/crear_raid6.sh

sudo /root/scripts/crear_raid6.sh

raid 10 

nano /root/scripts/crear_raid10.sh

#!/bin/bash

# Asegurarse de que el script se ejecuta como root
if [ "$EUID" -ne 0 ]; then
  echo "Por favor, ejecuta este script como root."
  exit 1
fi

# Instalar mdadm si no está instalado
if ! command -v mdadm &> /dev/null; then
  echo "mdadm no está instalado. Instalando..."
  yum install -y mdadm
fi

# Crear el RAID 10 con nvme0n2 a nvme0n8
echo "Creando RAID 10 con nvme0n2, nvme0n3, nvme0n4, nvme0n5, nvme0n6, nvme0n7 y nvme0n8..."
mdadm --create --verbose /dev/md4 --level=10 --raid-devices=6 /dev/nvme0n2 /dev/nvme0n3 /dev/nvme0n4 /dev/nvme0n5 /dev/nvme0n6 /dev/nvme0n7

# Crear el sistema de archivos en el RAID
echo "Creando sistema de archivos ext4 en /dev/md4..."
mkfs.ext4 /dev/md4

# Crear un punto de montaje y montar el RAID
echo "Montando el RAID en /mnt/raid10..."
mkdir -p /mnt/raid10
mount /dev/md4 /mnt/raid10

# Añadir el RAID al archivo fstab para montar automáticamente al iniciar
echo "Añadiendo el RAID al archivo /etc/fstab..."
echo "/dev/md4 /mnt/raid10 ext4 defaults 0 0" >> /etc/fstab

# Confirmar que el RAID se creó correctamente
cat /proc/mdstat

echo "RAID 10 creado y montado en /mnt/raid10. ¡Listo!"

chmod +x /root/scripts/crear_raid10.sh

sudo /root/scripts/crear_raid10.sh

todo en uno 

Archivo PHP: raid_manager.php 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>RAID Manager</title>
</head>
<body>
    <h1>RAID Manager</h1>
    <form method="POST" action="raid_manager.php">
        <label for="raid_type">Seleccione el tipo de RAID:</label>
        <select name="raid_type" id="raid_type" required>
            <option value="0">RAID 0</option>
            <option value="1">RAID 1</option>
            <option value="5">RAID 5</option>
            <option value="6">RAID 6</option>
            <option value="10">RAID 10</option>
        </select>
        <br><br>
        <label for="disks">Seleccione los discos a usar (Ctrl + clic para selección múltiple):</label>
        <select name="disks[]" id="disks" multiple required>
            <option value="nvme0n2">nvme0n2</option>
            <option value="nvme0n3">nvme0n3</option>
            <option value="nvme0n4">nvme0n4</option>
        </select>
        <br><br>
        <button type="submit" name="execute">Ejecutar</button>
    </form>
    <?php
    if ($_SERVER['REQUEST_METHOD'] === 'POST' && isset($_POST['execute'])) {
        $raidType = $_POST['raid_type'];
        $disks = $_POST['disks'];
        if (count($disks) < 2) {
            echo "<p style='color: red;'>Debe seleccionar al menos dos discos.</p>";
            exit;
        }
        $disks = array_map(function ($disk) {
            return "/dev/" . $disk;
        }, $disks);
        $diskList = implode(' ', $disks);
        $bashScript = "/root/scripts/configure_raid.sh";
        $command = "sudo $bashScript $raidType $diskList";
        $output = shell_exec($command . ' 2>&1');
        echo "<h2>Resultado:</h2>";
        echo "<p>Comando ejecutado: <code>$command</code></p>";
        echo "<pre>$output</pre>";
    }
    ?>
</body>
</html>


configure_raid.sh

#!/bin/bash
if [ "$EUID" -ne 0 ]; then
    echo "Por favor, ejecuta este script como root."
    exit 1
fi
RAID_TYPE=$1
shift
DISKS=("$@")
DEVICE="/dev/md$RAID_TYPE"
echo "Creando RAID $RAID_TYPE con los discos: ${DISKS[*]}"
yes | mdadm --create --verbose $DEVICE --level=$RAID_TYPE --raid-devices=${#DISKS[@]} "${DISKS[@]}"
mkfs.ext4 $DEVICE
MOUNT_POINT="/mnt/raid$RAID_TYPE"
mkdir -p $MOUNT_POINT
mount $DEVICE $MOUNT_POINT
echo "$DEVICE $MOUNT_POINT ext4 defaults 0 0" >> /etc/fstab
echo "RAID $RAID_TYPE configurado y montado en $MOUNT_POINT."

http://10.10.10.129/raid_manager.php 


1. Limpiar el dispositivo RAID existente  


nano /root/scripts/borrar_raid.sh
#!/bin/bash

# Asegurarse de que el script se ejecuta como root
if [ "$EUID" -ne 0 ]; then
  echo "Por favor, ejecuta este script como root."
  exit 1
fi

echo "Desmontando y deteniendo todos los RAID configurados..."

# Desmontar RAID 0
if mount | grep "/mnt/raid0" &> /dev/null; then
  echo "Desmontando /mnt/raid0..."
  umount /mnt/raid0
fi

if [ -e /dev/md0 ]; then
  echo "Deteniendo /dev/md0 (RAID 0)..."
  mdadm --stop /dev/md0
fi

# Desmontar RAID 1
if mount | grep "/mnt/raid1" &> /dev/null; then
  echo "Desmontando /mnt/raid1..."
  umount /mnt/raid1
fi

if [ -e /dev/md1 ]; then
  echo "Deteniendo /dev/md1 (RAID 1)..."
  mdadm --stop /dev/md1
fi

# Desmontar RAID 5
if mount | grep "/mnt/raid5" &> /dev/null; then
  echo "Desmontando /mnt/raid5..."
  umount /mnt/raid5
fi

if [ -e /dev/md2 ]; then
  echo "Deteniendo /dev/md2 (RAID 5)..."
  mdadm --stop /dev/md2
fi

# Borrar configuraciones de RAID en los discos
echo "Eliminando configuraciones de RAID de los discos..."
mdadm --zero-superblock /dev/nvme0n2
mdadm --zero-superblock /dev/nvme0n3
mdadm --zero-superblock /dev/nvme0n4
mdadm --zero-superblock /dev/nvme0n5
mdadm --zero-superblock /dev/nvme0n6
mdadm --zero-superblock /dev/nvme0n7
mdadm --zero-superblock /dev/nvme0n8

# Eliminar entradas de RAID en /etc/fstab
echo "Eliminando entradas de RAID en /etc/fstab..."
sed -i '/\/mnt\/raid0/d' /etc/fstab
sed -i '/\/mnt\/raid1/d' /etc/fstab
sed -i '/\/mnt\/raid5/d' /etc/fstab

echo "Todos los RAID han sido eliminados y los discos han vuelto a su estado normal."



chmod +x /root/scripts/borrar_raid.sh
sudo /root/scripts/borrar_raid.sh

umount /mnt/raid6
mdadm --stop /dev/md3

umount /mnt/raid10
mdadm --stop /dev/md4


MQTT

 necesita un Broker que va a recibir la informacion

Necesita de suscriptores y publicadores

sudo dnf update -y

sudo dnf install epel-release -y


sudo dnf install mosquitto -y

sudo dnf install -y gcc-c++ make cmake


sudo tee /etc/yum.repos.d/mosquitto.repo <<EOF

[mosquitto]

name=Mosquitto Repository

baseurl=http://repo.mosquitto.org/mosquitto/centos/8/x86_64/

enabled=1

gpgcheck=1

gpgkey=http://repo.mosquitto.org/mosquitto-repo.gpg

EOF


sudo dnf install mosquitto -y


sudo systemctl enable mosquitto
sudo systemctl start mosquitto
sudo systemctl status mosquitto

sudo firewall-cmd --zone=public --add-port=1883/tcp --permanent
sudo firewall-cmd --reload

mosquitto_sub -h localhost -t "test/topic"

mosquitto_pub -h localhost -t "test/topic" -m "Hola, Mosquitto!"
sudo dnf install mosquitto mosquitto-clients -y
sudo nano /etc/mosquitto/mosquitto.conf


(al ultimo añadir, debe ser la ip de la maquina virtual que uso) listener 1883 10.10.10.129

allow_anonymous true





cd /etc/mosquito/

sudo mosquitto -c moquito.conf


  • listener 1883 192.168.96.65: Configura el broker Mosquitto para escuchar en la IP 192.168.96.65 y en el puerto 1883 (puerto por defecto de MQTT).
  • allow_anonymous true: Permite que cualquier cliente se conecte sin necesidad de credenciales.

  • sudo systemctl restart mosquitto  

    • Abre una nueva pestaña o sesión de PuTTY.
    • Usa las mismas credenciales que utilizaste para configurar "Prmas" (el usuario que usas habitualmente para conectarte a tu máquina virtual).
    • Una vez conectado, estarás listo para ejecutar el comando de suscripción.

    2. Ejecuta el comando mosquitto_sub

    En esta nueva sesión de PuTTY, escribe el siguiente comando para suscribirte al tema casa/cocina/nevera:

    mosquitto_sub -h 10.10.10.129 -p 1883 -t "casa/cocina/nevera"

    Ahora, regresa a tu sesión original de PuTTY (o a otra pestaña) y ejecuta el comando para publicar un mensaje en el mismo tema:



    ¿Qué pasa si no funciona?

    1. Revisa el puerto:
      • Asegúrate de que el puerto 1883 esté abierto en el firewall de Alma Linux.
      • Para deshabilitar el firewall temporalmente para pruebas (no recomendado en producción):
        sudo systemctl stop firewalld
    2. Verifica que Mosquitto esté corriendo:
      • Comprueba si Mosquitto está activo:
        sudo systemctl status mosquitto
    3. Asegúrate de que la IP sea correcta:
      • La IP que usas (10.10.10.129) debe ser la misma que configuraste en mosquitto.conf.

    dnf install jjs

    sudo nano /etc/yum.repos.d/nodesource.repo

    [nodesource-nodejs]
    name=Node.js Packages for Enterprise Linux 8 - $basearch
    baseurl=https://rpm.nodesource.com/pub_16.x/el/8/$basearch
    enabled=1
    gpgcheck=0



    sudo dnf install -y nodejs


    node -v
    npm -v


    sudo nano /etc/yum.repos.d/mosquitto.repo

    [mosquitto]
    name=Mosquitto Repository
    baseurl=https://repo.mosquitto.org/mosquitto/centos/8/x86_64/
    enabled=1
    gpgcheck=1
    gpgkey=https://repo.mosquitto.org/mosquitto.org.gpg


    sudo dnf update

    sudo nano /etc/mosquitto/mosquitto.conf

    listener 9001
    protocol websocketa

    sudo systemctl restart mosquitto

    npm install mqtt axios

    sudo nano /var/www/html/mqtt_server.js

    const mqtt = require('mqtt');
    const axios = require('axios');

    // Configuración del cliente MQTT
    const mqttClient = mqtt.connect('mqtt://localhost:1883'); // Cambia la IP si es necesario

    mqttClient.on('connect', () => {
      console.log('Conectado a Mosquitto');

      // Suscribirse al tema de MQTT
      mqttClient.subscribe('casa/cocina/nevera', (err) => {
        if (err) {
          console.error('Error al suscribirse:', err);
        } else {
          console.log('Suscripción exitosa al tema casa/cocina/nevera');
        }
      });
    });

    // Cuando se recibe un mensaje
    mqttClient.on('message', (topic, message) => {
      // El mensaje es un Buffer, por lo que lo convertimos a un string
      const mensaje = message.toString();
      console.log(`Mensaje recibido: ${mensaje}`);

      // Enviar el mensaje al script PHP para almacenarlo en la base de datos
      axios.post('http://10.10.10.129/guardar_mqtt.php', {
        topic: topic,
        mensaje: mensaje
      })
      .then(response => {
        console.log('Datos enviados al servidor PHP:', response.data);
      })
      .catch(error => {
        console.error('Error al enviar los datos a PHP:', error);
      });
    });

    node /var/www/html/mqtt_server.js

    mosquitto_pub -h 10.10.10.129 -p 1883 -t "casa/cocina/nevera" -m '{"temp": 30}'

    mysql -u root -p

    USE MQTT_Data; 
    SELECT * FROM mensajes;

     Crear una nueva base de datos

    sudo mysql -u root -p

    CREATE DATABASE MQTT_Data;
    USE MQTT_Data;
    CREATE TABLE mensajes (
        id INT AUTO_INCREMENT PRIMARY KEY,
        topic VARCHAR(255) NOT NULL,
        mensaje TEXT NOT NULL,
        fecha TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    );

    EXIT;


    cd /var/www/html
    sudo nano guardar_mqtt.php

    <?php
    // Datos de conexión a la base de datos
    $servername = "localhost";
    $username = "root"; // Cambia esto si usas otro usuario de MySQL
    $password = "tu_contraseña_mysql"; // Ingresa tu contraseña de MySQL
    $dbname = "MQTT_Data";

    // Conexión a la base de datos
    $conn = new mysqli($servername, $username, $password, $dbname);

    // Verificar conexión
    if ($conn->connect_error) {
        die("Conexión fallida: " . $conn->connect_error);
    }

    // Obtener datos enviados por MQTT (por POST)
    $topic = $_POST['topic'];
    $mensaje = $_POST['mensaje'];

    // Insertar datos en la base de datos
    $sql = "INSERT INTO mensajes (topic, mensaje) VALUES ('$topic', '$mensaje')";

    if ($conn->query($sql) === TRUE) {
        echo "Mensaje guardado correctamente";
    } else {
        echo "Error al guardar el mensaje: " . $conn->error;
    }

    // Cerrar conexión
    $

    hi chart

     https://www.highcharts.com/

    descargar core

    https://www.highcharts.com/blog/download/

    abrir

    solid

     Ese archivo u el archivo cox que esta afuera 



    Formulario en html/php

    Metodo get
    Concatena los valores
    Metodo Post
    Oculta los valores en el post
     
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Sensor Data Form</title>
    </head>
    <body>
        <h1>Sensor Data Form</h1>
        <form action="control.php" method="POST">
            <label for="sensor1">Sensor 1:</label>
            <input type="text" id="sensor1" name="sensor1" required>
            <br><br>
           
            <label for="sensor2">Sensor 2:</label>
            <input type="text" id="sensor2" name="sensor2" required>
            <br><br>
           
            <label for="sensor3">Sensor 3:</label>
            <input type="text" id="sensor3" name="sensor3" required>
            <br><br>
           
            <label for="sensor4">Sensor 4:</label>
            <input type="text" id="sensor4" name="sensor4" required>
            <br><br>
           
            <button type="submit">Submit</button>
        </form>
    </body>
    </html>


    sudo dnf update -y

    sudo dnf install epel-release -y
    sudo dnf install phpmyadmin -y
    sudo nano /etc/httpd/conf.d/phpMyAdmin.conf

    sudo mysql -u root -p

    CREATE DATABASE datos;

    USE datos;

    CREATE TABLE sensores (
        id INT AUTO_INCREMENT PRIMARY KEY,
        temperatura FLOAT NOT NULL,
        humedad FLOAT NOT NULL,
        voltaje FLOAT NOT NULL
    );

    CREATE USER 'comunicaciones'@'localhost' IDENTIFIED BY 'comunicaciones';
    GRANT ALL PRIVILEGES ON datos.* TO 'comunicaciones'@'localhost';
    FLUSH PRIVILEGES;

    EXIT



    sudo nano /var/www/html/ejemplogato.php
    <?php
    // Declaración
    class Gato
    {
        // Variables públicas
        public $nombre = 'Felix';
        public string $MySQL_host;
        public string $MySQL_user;
        public string $MySQL_passwd;
        public string $MySQL_dbname;
        public $connection;

        function __construct()
        {
            $this->MySQL_host = 'localhost';        
            $this->MySQL_user = 'comunicaciones';  
            $this->MySQL_passwd = 'comunicaciones';
            $this->MySQL_dbname = 'datos';

            // Crear conexión a la base de datos
            $this->connection = $this->connect();
        }

        function connect()
        {
            // Crear conexión
            $conn = mysqli_connect($this->MySQL_host, $this->MySQL_user, $this->MySQL_passwd , $this->MySQL_dbname);

            // Verificar conexión
            if (!$conn) {
                die("Fallo en la conexión: " . mysqli_connect_error());
            }

            echo "Conexión exitosa<br>";
            return $conn;
        }

        function query($sentence)
        {
            if ($result = mysqli_query($this->connection, $sentence)) {
                echo $this->saludo();
            } else {
                echo "Error: " . $sentence . "<br>" . mysqli_error($this->connection);
            }

            return $result;
        }

        function insertar($t, $h, $d)
        {
            echo "Ingreso a insertar<br>";

            $sql = "INSERT INTO sensores (id, temperatura, humedad, voltaje) VALUES (NULL, '$t', '$h', '$d')";

            if ($this->query($sql)) {
                echo "Se realizó el registro<br>";
            } else {
                echo "Error al insertar<br>";
            }
        }

        function saludo(): string
        {
            return 'Consulta realizada con éxito<br>';
        }
    }
    ?>


    sudo nano /var/www/html/controll.php
    <?php

    // Incluir la clase Gato
    include_once("ejemplogato.php");

    // Crear una instancia de la clase Gato
    $bd = new Gato();

    // Insertar datos en la tabla sensores
    $temperatura = 25.5;
    $humedad = 60.0;
    $voltaje = 3.3;

    // Llama al método insertar con los valores
    $bd->insertar($temperatura, $humedad, $voltaje);

    ?>


    sudo systemctl start httpd 
    sudo systemctl start mysqld
    http://10.10.10.129/controll.php

    sudo mysql -u root -p
    SELECT * FROM sensores;
    EXIT

    sudo chmod 644 /var/www/html/ejemplogato.php
    sudo chmod 644 /var/www/html/controll.php


    Crear formulario en PHP

    sudo nano /var/www/html/formulario_sensores.php


    <!DOCTYPE html>

    <html lang="en">

    <head>

        <meta charset="UTF-8">

        <meta name="viewport" content="width=device-width, initial-scale=1.0">

        <title>Datos de Sensores</title>

    </head>

    <body>

        <h1>Registrar Datos de Sensores</h1>

        <form action="guardar_datos.php" method="POST">

            <label for="temperatura">Temperatura (°C):</label><br>

            <input type="number" id="temperatura" name="temperatura" step="0.1" required><br><br>


            <label for="humedad">Humedad (%):</label><br>

            <input type="number" id="humedad" name="humedad" step="0.1" required><br><br>


            <label for="distancia">Distancia (cm):</label><br>

            <input type="number" id="distancia" name="distancia" step="0.1" required><br><br>


            <label for="luminosidad">Luminosidad (lux):</label><br>

            <input type="number" id="luminosidad" name="luminosidad" step="0.1" required><br><br>


            <button type="submit">Guardar Datos</button>

        </form>

    </body>

    </html>


    sudo nano /var/www/html/guardar_datos.php

    <?php
    // Configuración de la conexión a la base de datos
    $host = "localhost";
    $usuario = "root"; // Cambia esto si tu usuario es diferente
    $contraseña = ""; // Cambia esto si tu contraseña es diferente
    $base_de_datos = "sensores";

    // Conexión a MySQL
    $conexion = new mysqli($host, $usuario, $contraseña, $base_de_datos);

    // Verificar si hay errores de conexión
    if ($conexion->connect_error) {
        die("Error al conectar a la base de datos: " . $conexion->connect_error);
    }

    // Obtener los datos del formulario
    $temperatura = $_POST['temperatura'];
    $humedad = $_POST['humedad'];
    $distancia = $_POST['distancia'];
    $luminosidad = $_POST['luminosidad'];

    // Insertar los datos en la base de datos
    $sql = "INSERT INTO datos_sensores (temperatura, humedad, distancia, luminosidad) 
            VALUES ('$temperatura', '$humedad', '$distancia', '$luminosidad')";

    if ($conexion->query($sql) === TRUE) {
        echo "Datos guardados correctamente.";
    } else {
        echo "Error al guardar los datos: " . $conexion->error;
    }

    // Cerrar la conexión
    $conexion->close();
    ?>



    Crear la base de datos y la tabla en MySQL
    sudo mysql -u root -p 
    CREATE DATABASE sensores; 
    USE sensores; 
    CREATE TABLE datos_sensores (
        id INT AUTO_INCREMENT PRIMARY KEY,
        temperatura FLOAT NOT NULL,
        humedad FLOAT NOT NULL,
        distancia FLOAT NOT NULL,
        luminosidad FLOAT NOT NULL,
        fecha_registro TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    );
    EXIT
    http://10.10.10.129/formulario_sensores.php