SYSTEMS & IOT GUIDES • C++20, CROW & MQTT

Ghid Dezvoltare, Testare și IoT în C++ pe VPS

Acest ghid descrie pas cu pas cum instalezi lanțul de instrumente C++ (gcc/g++, cmake), cum configurezi un serviciu HTTP API REST performant cu Crow Framework, cum gestionezi brokerul MQTT (Mosquitto) pentru dispozitive IoT și cum rulezi/expui aplicațiile C++20 pe VPS-ul Ubuntu (63.250.40.142).

1. Instalarea Compilatorului C++ și a Instrumentelor de Build

Conectează-te la VPS prin SSH:
```
ssh root@63.250.40.142
```
Instalează pachetele esențiale pentru compilare, debugging și gestionare proiecte:
```
apt update && apt install -y build-essential gdb cmake git curl pkg-config unzip
```
Verifică versiunile instalate ale compilatorului g++ și utilitarului cmake:
```
g++ --version
cmake --version
```
(Trebuie să ai o versiune g++ 11+ care oferă suport complet pentru C++20).

2. Crearea și Testarea unui Proiect C++ Simplu

Vom crea un micro-proiect C++20 pentru a testa procesul de compilare direct pe VPS.

A. Creează un director dedicat

mkdir -p /root/projects/cpp-demo
cd /root/projects/cpp-demo

B. Creează fișierul de cod sursă main.cpp

nano main.cpp

#include <iostream>
#include <vector>
#include <string>
#include <chrono>

int main() {
    std::cout << "=== Test C++20 pe VPS Bytebook ===" << std::endl;
    
    std::vector<std::string> servicii = {"PostgreSQL", "Redis", "Kafka", "MQTT", "C++ Engine"};
    
    std::cout << "Servicii integrate:" << std::endl;
    for (const auto& s : servicii) {
        std::cout << " - " << s << std::endl;
    }
    
    auto acum = std::chrono::system_clock::now();
    std::time_t timp = std::chrono::system_clock::to_time_t(acum);
    std::cout << "Data si ora VPS: " << std::ctime(&timp);

    return 0;
}

C. Compilează și rulează aplicația

g++ -std=c++20 main.cpp -o app_demo
./app_demo

3. Construirea unui Server Web/API REST IoT cu C++ (Crow Framework)

Pentru IoT și microservicii ultra-rapide în C++, framework-ul Crow este opțiunea ideală.

Instalează dependențele de rețea (Asio/Boost):
```
apt install -y libasio-dev
```

Descarcă header-ul single-file Crow în directorul proiectului:

cd /root/projects/cpp-demo
wget https://github.com/CrowCpp/Crow/releases/download/v1.0+5/crow_all.h -O crow.h

Creează fișierul iot_server.cpp:
```
nano iot_server.cpp
```

Adaugă codul API-ului IoT:

#include "crow.h"
#include <iostream>

int main() {
    crow::SimpleApp app;

    // Ruta principala
    CROW_ROUTE(app, "/")([](){
        return "<h1>C++ IoT Engine pe VPS (63.250.40.142)</h1>";
    });

    // Endpoint JSON pentru senzori IoT
    CROW_ROUTE(app, "/api/sensor").methods("POST"_method)([](const crow::request& req){
        auto x = crow::json::load(req.body);
        if (!x)
            return crow::response(400, "JSON Invalid!");

        std::cout << "[IoT Log] Temp: " << x["temperatura"].d() 
                  << "C | Umiditate: " << x["umiditate"].d() << "%" << std::endl;

        crow::json::wvalue res;
        res["status"] = "success";
        res["message"] = "Date senzor salvate cu succes!";
        return crow::response(res);
    });

    // Pornire server pe portul 8085
    app.port(8085).multithreaded().run();
}

Compilează, rulează și testează serverul:

g++ -std=c++20 -O3 iot_server.cpp -o iot_server -lpthread
./iot_server &
curl -X POST http://localhost:8085/api/sensor \
     -H "Content-Type: application/json" \
     -d '{"temperatura": 24.5, "umiditate": 55.0}'

4. Configurarea Brokerului MQTT (Mosquitto) pentru IoT

Pentru comunicarea cu microcontrollere (ESP32, ESP8266, Raspberry Pi, Arduino), se folosește protocolul MQTT.

Instalează Mosquitto Broker și clientul CLI:
```
apt install -y mosquitto mosquitto-clients
```

Pornește și activează serviciul:

systemctl enable mosquitto
systemctl start mosquitto

Testează comunicarea pe un topic de senzori:
Într-un terminal, ascultă mesajele (Subscriber):
```
mosquitto_sub -h localhost -t "casa/senzori/#"
```
În alt terminal, trimite un mesaj de test (Publisher):
```
mosquitto_pub -h localhost -t "casa/senzori/temperatura" -m "23.8"
```

5. Expunerea API-ului C++ prin Caddy Reverse Proxy

Pentru a face API-ul IoT accesibil public prin HTTPS pe cpp-iot.bytebook.xyz:

Configurare Namecheap: Adaugă un A Record (Host: cpp-iot, Value: 63.250.40.142).
Editează /etc/caddy/Caddyfile:
```
nano /etc/caddy/Caddyfile
```

Adaugă blocul de configurare:

cpp-iot.bytebook.xyz {
    reverse_proxy localhost:8085
}

Reîncarcă Caddy:
```
systemctl reload caddy
```

6. Crearea Serviciului systemd 24/7 pentru Aplicația C++

Pentru ca serverul C++ să ruleze neîntrerupt și să pornească automat la boot:

Creează fișierul de serviciu:

nano /etc/systemd/system/cpp-iot.service

Adaugă următoarea configurație:

[Unit]
Description=C++ IoT Engine Service
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=/root/projects/cpp-demo
ExecStart=/root/projects/cpp-demo/iot_server
Restart=always
RestartSec=3

[Install]
WantedBy=multi-user.target

Încarcă, activează și verifică serviciul:

systemctl daemon-reload
systemctl enable cpp-iot
systemctl start cpp-iot
systemctl status cpp-iot

7. Gestionarea Pachetelor și Librăriilor C++ cu vcpkg (Opțional)

Pentru proiecte complexe care necesită librării externe (Boost, OpenCV, nlohmann-json):

Instalează vcpkg:

cd /opt
git clone https://github.com/microsoft/vcpkg.git
./vcpkg/bootstrap-vcpkg.sh

Instalează orice librărie C++ cu o singură comandă:
```
/opt/vcpkg/vcpkg install nlohmann-json
```