Proyecto: servidor de inferencia

123456789101112131415

servidor/
├── CMakeLists.txt
├── Dockerfile
├── include/
│   ├── httplib.h          # biblioteca HTTP (una sola cabecera)
│   ├── nlohmann/
│   │   └── json.hpp       # JSON (una sola cabecera)
│   └── model.hpp
├── models/
│   └── logistic.json      # pesos y metadatos del modelo
├── src/
│   ├── model.cpp          # carga y prediccion
│   ├── predecir.cpp       # cliente de consola, sin red
│   └── main.cpp           # servidor HTTP
└── payload.json           # cuerpo de prueba para ab

1234567

mkdir -p include/nlohmann

curl -L -o include/httplib.h \
  https://raw.githubusercontent.com/yhirose/cpp-httplib/v0.16.3/httplib.h

curl -L -o include/nlohmann/json.hpp \
  https://raw.githubusercontent.com/nlohmann/json/v3.11.3/single_include/nlohmann/json.hpp

123456

{
  "version": "1.0.0",
  "features": ["edad", "ingreso_mensual", "visitas", "deuda"],
  "bias": -1.2,
  "weights": [0.03, 0.00012, 0.4, -0.002]
}

1234567891011121314151617181920212223242526272829

#pragma once

#include <cstddef>
#include <string>
#include <vector>

struct Prediccion {
    double probabilidad;
    int etiqueta;
};

// Regresion logistica con pesos cargados desde JSON.
// Es inmutable tras cargar: se puede usar desde varios hilos sin sincronizar.
class ModeloLogistico {
public:
    static ModeloLogistico cargar(const std::string& ruta);

    std::size_t num_features() const noexcept { return pesos_.size(); }
    const std::string& version() const noexcept { return version_; }
    const std::vector<std::string>& features() const noexcept { return features_; }

    Prediccion predecir(const std::vector<double>& x) const;

private:
    std::string version_;
    std::vector<std::string> features_;
    std::vector<double> pesos_;
    double sesgo_ = 0.0;
};

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051

#include "model.hpp"

#include <cmath>
#include <fstream>
#include <nlohmann/json.hpp>
#include <stdexcept>

ModeloLogistico ModeloLogistico::cargar(const std::string& ruta) {
    std::ifstream entrada(ruta);
    if (!entrada) {
        throw std::runtime_error("no se pudo abrir el modelo: " + ruta);
    }

    nlohmann::json documento;
    try {
        documento = nlohmann::json::parse(entrada);
    } catch (const nlohmann::json::parse_error& error) {
        throw std::runtime_error(std::string("JSON invalido en el modelo: ") + error.what());
    }

    ModeloLogistico modelo;
    try {
        modelo.version_ = documento.at("version").get<std::string>();
        modelo.features_ = documento.at("features").get<std::vector<std::string>>();
        modelo.pesos_ = documento.at("weights").get<std::vector<double>>();
        modelo.sesgo_ = documento.at("bias").get<double>();
    } catch (const nlohmann::json::exception& error) {
        throw std::runtime_error(std::string("modelo incompleto: ") + error.what());
    }

    if (modelo.pesos_.size() != modelo.features_.size()) {
        throw std::runtime_error("el modelo tiene " + std::to_string(modelo.pesos_.size()) +
                                 " pesos y " + std::to_string(modelo.features_.size()) + " features");
    }
    return modelo;
}

Prediccion ModeloLogistico::predecir(const std::vector<double>& x) const {
    if (x.size() != pesos_.size()) {
        throw std::invalid_argument("se esperaban " + std::to_string(pesos_.size()) +
                                    " features y llegaron " + std::to_string(x.size()));
    }

    double z = sesgo_;
    for (std::size_t i = 0; i < pesos_.size(); ++i) {
        z += pesos_[i] * x[i];
    }

    const double probabilidad = 1.0 / (1.0 + std::exp(-z));
    return {probabilidad, probabilidad >= 0.5 ? 1 : 0};
}

123456789101112131415161718192021

#include <exception>
#include <iostream>
#include <vector>

#include "model.hpp"

int main() {
    try {
        const ModeloLogistico modelo = ModeloLogistico::cargar("models/logistic.json");
        const std::vector<double> x{34.0, 2500.0, 4.0, 1200.0};
        const Prediccion p = modelo.predecir(x);

        std::cout << "modelo " << modelo.version() << " con " << modelo.num_features() << " features\n";
        std::cout << "probabilidad = " << p.probabilidad << "\n";
        std::cout << "etiqueta = " << p.etiqueta << "\n";
    } catch (const std::exception& error) {
        std::cerr << "error: " << error.what() << "\n";
        return 1;
    }
    return 0;
}

12345678

g++ -O2 -std=c++20 -Wall -Wextra -Iinclude \
    src/model.cpp src/predecir.cpp -o predecir

./predecir

# modelo 1.0.0 con 4 features
# probabilidad = 0.336261
# etiqueta = 0

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103

#include <atomic>
#include <cstdlib>
#include <exception>
#include <iostream>
#include <string>
#include <vector>

#include <nlohmann/json.hpp>

#include "httplib.h"
#include "model.hpp"

namespace {

using nlohmann::json;

std::string variable_entorno(const char* nombre, const std::string& por_defecto) {
    const char* valor = std::getenv(nombre);
    return valor != nullptr ? std::string(valor) : por_defecto;
}

void responder_error(httplib::Response& res, int codigo, const std::string& mensaje) {
    res.status = codigo;
    res.set_content(json{{"error", mensaje}}.dump(), "application/json");
}

}  // namespace

int main() {
    const std::string ruta_modelo = variable_entorno("MODELO_PATH", "models/logistic.json");
    const int puerto = std::stoi(variable_entorno("PORT", "8080"));

    ModeloLogistico modelo;
    try {
        modelo = ModeloLogistico::cargar(ruta_modelo);
    } catch (const std::exception& error) {
        std::cerr << "no se pudo cargar el modelo: " << error.what() << "\n";
        return 1;
    }

    std::atomic<long> peticiones{0};
    httplib::Server servidor;

    servidor.set_payload_max_length(64 * 1024);
    servidor.set_read_timeout(5, 0);
    servidor.set_write_timeout(5, 0);

    servidor.Get("/health", [&modelo](const httplib::Request&, httplib::Response& res) {
        res.set_content(json{{"estado", "ok"},
                             {"modelo", modelo.version()},
                             {"features", modelo.num_features()}}
                            .dump(),
                        "application/json");
    });

    servidor.Get("/stats", [&peticiones](const httplib::Request&, httplib::Response& res) {
        res.set_content(json{{"peticiones", peticiones.load()}}.dump(), "application/json");
    });

    servidor.Post("/predict",
                  [&modelo, &peticiones](const httplib::Request& req, httplib::Response& res) {
                      ++peticiones;

                      json cuerpo;
                      try {
                          cuerpo = json::parse(req.body);
                      } catch (const json::parse_error&) {
                          responder_error(res, 400, "el cuerpo no es JSON valido");
                          return;
                      }

                      if (!cuerpo.contains("features") || !cuerpo["features"].is_array()) {
                          responder_error(res, 400, "falta el array 'features'");
                          return;
                      }

                      std::vector<double> x;
                      try {
                          x = cuerpo["features"].get<std::vector<double>>();
                      } catch (const json::type_error&) {
                          responder_error(res, 400, "'features' debe contener solo numeros");
                          return;
                      }

                      try {
                          const Prediccion p = modelo.predecir(x);
                          res.set_content(json{{"probabilidad", p.probabilidad},
                                               {"etiqueta", p.etiqueta},
                                               {"modelo", modelo.version()}}
                                              .dump(),
                                          "application/json");
                      } catch (const std::exception& error) {
                          responder_error(res, 400, error.what());
                      }
                  });

    std::cout << "escuchando en 0.0.0.0:" << puerto << " con modelo " << modelo.version() << "\n";
    if (!servidor.listen("0.0.0.0", puerto)) {
        std::cerr << "no se pudo abrir el puerto " << puerto << "\n";
        return 1;
    }
    return 0;
}

123456789101112131415161718192021

g++ -O2 -std=c++20 -Wall -Wextra -Iinclude -pthread \
    -DCPPHTTPLIB_THREAD_POOL_COUNT=64 \
    -DCPPHTTPLIB_LISTEN_BACKLOG=128 \
    src/model.cpp src/main.cpp -o servidor

./servidor &
# escuchando en 0.0.0.0:8080 con modelo 1.0.0

curl -s localhost:8080/health
# {"estado":"ok","features":4,"modelo":"1.0.0"}

curl -s -X POST localhost:8080/predict \
     -H 'Content-Type: application/json' \
     -d '{"features":[34,2500,4,1200]}'
# {"etiqueta":0,"modelo":"1.0.0","probabilidad":0.33626130259564735}

curl -s -X POST localhost:8080/predict -d '{"x":1}'
# {"error":"falta el array 'features'"}

curl -s -X POST localhost:8080/predict -d '{"features":[1,2,3]}'
# {"error":"se esperaban 4 features y llegaron 3"}

1234567891011

printf '{"features":[34,2500,4,1200]}' > payload.json

ab -n 3000 -c 50 -k -p payload.json -T application/json \
   http://127.0.0.1:8080/predict

# Complete requests:      3000
# Failed requests:        0
# Requests per second:    41424.45 [#/sec] (mean)
# Time per request:       1.207 [ms] (mean)
#  50%      1
#  99%      7

1234567891011121314151617181920212223242526

# ---- etapa 1: compilacion ----
FROM debian:bookworm-slim AS build
RUN apt-get update \
    && apt-get install -y --no-install-recommends g++ cmake make \
    && rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY include/ include/
COPY src/ src/
COPY models/ models/
COPY CMakeLists.txt .
RUN cmake -S . -B build -DCMAKE_BUILD_TYPE=Release \
    && cmake --build build -j"$(nproc)"

# ---- etapa 2: imagen final, sin compilador ----
FROM debian:bookworm-slim
RUN apt-get update \
    && apt-get install -y --no-install-recommends libstdc++6 curl \
    && rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY --from=build /app/build/servidor /usr/local/bin/servidor
COPY models/ models/
ENV MODELO_PATH=/app/models/logistic.json
ENV PORT=8080
EXPOSE 8080
USER nobody
ENTRYPOINT ["/usr/local/bin/servidor"]

1234567891011

docker build -t inferencia:0.1 .

docker run --rm -d --name inferencia -p 8080:8080 inferencia:0.1

curl -s localhost:8080/health
# {"estado":"ok","features":4,"modelo":"1.0.0"}

docker logs inferencia
# escuchando en 0.0.0.0:8080 con modelo 1.0.0

docker stop inferencia