> For the complete documentation index, see [llms.txt](https://docs.kiloiot.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.kiloiot.io/kilo-docs-es/kilo-center/kilo-mioty-service-center/project-overview.md).
# Resumen del proyecto
Resumen del proyecto KiloCenter — servidor de código abierto nativo de MIOTY con rutas de despliegue en Docker, host Linux y Kubernetes.
## KiloCenter - Servidor de red MIOTY de código abierto
KiloCenter es un servidor de red MIOTY de código abierto para operar estaciones base, endpoints, tráfico uplink y downlink, e integraciones de aplicaciones en un centro de servicio autoalojado.
Es un centro de servicio nativo de MIOTY, construido específicamente para el stack MIOTY desde cero. No es un fork, envoltorio ni adaptación de otro servidor de red LPWAN.
MIOTY es un protocolo LPWAN diseñado para la resiliencia a interferencias, la comunicación de largo alcance y grandes flotas de endpoints. KiloCenter implementa la parte de centro de servicio de ese stack con rutas de despliegue en Docker y en hosts Linux, integraciones gRPC y MQTT, y una consola web de administración.
### Cómo se relaciona con Kilo Cloud
KiloCenter Community Edition es el centro de servicio gratuito, de código abierto y autoalojado. Su límite es la capa de red MIOTY: estaciones base, endpoints, tráfico, operaciones del centro de servicio e interfaces que pasan datos a otra aplicación.
La edición Enterprise de KiloCenter está integrada en **Kilo Cloud**. Elige Kilo Cloud cuando el despliegue también necesite el resto de una plataforma IoT: datos normalizados de dispositivos, paneles visuales, gráficos históricos, un motor visual de reglas, disparadores por condiciones sostenidas, alarmas y escalado, historial de auditoría, control de acceso y un asistente de IA. Los dispositivos MIOTY usan entonces esas funciones directamente en lugar de requerir sistemas descendentes separados.
| Elige | Cuando encaja |
| -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **KiloCenter Community Edition** | Necesitas un centro de servicio MIOTY, quieres operarlo tú mismo y vas a integrar sus datos gRPC o MQTT en tus propias aplicaciones. |
| **Kilo Cloud** | Quieres que el centro de servicio Enterprise se gestione por ti y necesitas reglas, visualización, alarmas u otras capacidades de la plataforma Kilo alrededor de los datos MIOTY. |
| **Plataforma IoT Kilo local** | Necesitas la plataforma empresarial completa dentro de una infraestructura que controlas. |
Ver [¿KiloCenter o Kilo Cloud?](/kilo-docs-es/kilo-center/kilo-mioty-service-center.md#kilocenter-or-kilo-cloud) para el límite de funciones, o empieza con el [conector MIOTY de Kilo Cloud](/kilo-docs-es/kilo-iot-server/connectors/mioty-connector.md).
### Demostración en vivo
Hay un entorno de demostración disponible en
* **Usuario:** `demo [at] kiloiot.io`
* **Contraseña:** `demo1234`
> Reemplaza `[at]` con `@` al iniciar sesión.
### Aviso de uso en producción
La edición comunitaria se proporciona tal cual, sin soporte comercial. Su uso en producción es bajo tu propio riesgo.
Para despliegues de producción con soporte, usa Kilo Cloud o la Plataforma IoT Kilo local (Contactar ventas). La edición Enterprise de KiloCenter está integrada en Kilo Cloud e incluye soporte comercial, operación respaldada por SLA, multitenencia y capacidades MIOTY opcionales, incluyendo subcanales BSSCI, el adjunto Variable MAC (VM) y soporte de extensión ReCon. Kilo Cloud también añade la plataforma completa alrededor de los datos MIOTY: gestión de dispositivos, normalización, paneles, reglas, alarmas, historial de auditoría, control de acceso y operaciones asistidas por IA.
### Funciones
#### Servidor de red MIOTY
* **Protocolo MIOTY BSSCI v1.0.0** - comunicación entre estación base y centro de servicio protegida por TLS
* **Gestión de estaciones base** - autenticación basada en certificados y monitorización de estado
* **Gestión de endpoints** - registro de endpoints con propagación de adjuntos
* **Procesamiento de mensajes** - manejo de uplink y downlink con deduplicación
* **Operación con múltiples estaciones base** - cobertura compartida entre estaciones base dentro de un despliegue autoalojado
* **Soporte para división de telegramas** - manejo nativo del comportamiento PHY de MIOTY
* **Diversidad de patrones** - soporte de transmisión con múltiples patrones para mayor robustez
* **Seguridad** - manejo de claves de red y de aplicación AES-128
#### Funciones del centro de servicio
* **Interfaz BSSCI** - soporte del protocolo entre estación base y centro de servicio
* **Interfaz SCACI** - soporte del protocolo entre centro de servicio y centro de aplicaciones con TLS, persistencia de sesión, monitorización y flujos de cola/estado
* **Sistema de eventos** - persistencia centralizada de eventos y alertas
* **Gestión de certificados** - modelo de confianza basado en CA con soporte para rotación y monitorización
* **Particionado de base de datos** - almacenamiento de mensajes particionado mensualmente
* **Sistema de archivado** - soporte para ciclo de vida y retención de datos
* **Integración MQTT** - ruta de integración de aplicaciones respaldada por Mosquitto
* **API gRPC** - APIs de administración gRPC y gRPC-web a través de KC-Gateway
#### Interfaz de administración
* **Panel web** - consola de administración basada en React
* **Monitorización en tiempo real** - vistas en vivo de estado, tráfico y alertas
* **Registro de estaciones base** - flujos de aprovisionamiento basados en GUI
* **Registro de endpoints** - flujos de trabajo GUI para gestión de endpoints
* **Flujos de trabajo de certificados** - estado, renovación y flujos de certificados de estación base
* **Visor de mensajes** - vistas de tráfico para diferentes tipos de mensajes
#### Funciones de la plataforma
* **Despliegue con Docker Compose** - `postgres`, `redis`, `mosquitto`, `certgen`, `kc-identity`, `kilocenter`, `kc-gateway` y `kc-web`
* **Migraciones de base de datos** - cambios de esquema controlados por versión
* **Registro estructurado** - registros configurables y endpoints de salud
* **Desarrollo multiplataforma** - Linux, macOS y Windows mediante WSL
### Arquitectura
KiloCenter utiliza una disposición modular de servicios:
```
+-----------------+ +-----------------+
| Navegador | --> | KC-Web | (:80 nginx / :5173 dev)
+-----------------+ +--------+--------+
|
| gRPC-web
v
+-----------------+ +-----------------+ +-----------------+
| Externas | --> | KC-Gateway | -------> | KC-Identity |
| Aplicaciones | gRPC| (:9090 externo | público | (:50052 interno|
| / Integradores | / | gRPC + | RPCs | :8088 salud) |
| |gRPC-| gRPC-web, | +--------+--------+
| | web | :8087 salud) | ^
+-----------------+ +--------+--------+ |
| | RPC internos de identidad
| gRPC interna de confianza |
v |
+-----------------+ +-----------------+ |
| Estación base | --> | KC-Core | ------------------+
| (MIOTY BS) |BSSCI| (:50051 interno| org / membresía /
| (:5000 TLS) | | :5000 BSSCI | resolución admin
+-----------------+ | :5001 SCACI |
| :8086 salud) | -------> +-----------------+
+-----------------+ +--------+--------+ SQL | PostgreSQL |
| Centro de | ------------>| | vía KC-DB |
| aplicaciones | SCACI TLS | | (:5433 mapeo host)|
| (:5001 TLS) | | +-----------------+
+-----------------+ |
+-----------------> +-----------------+
| | Redis |
| | (:6379) |
| +-----------------+
|
+-----------------> +-----------------+
| Mosquitto |
| vía KC-MQTT |
| (:1883 / :9001) |
+-----------------+
```
Esta es la vista en tiempo de ejecución. `KC-Gateway` es la entrada de API externa para el centro de servicio. Expone gRPC nativo y gRPC-web en el puerto `9090`, así que tanto `KC-Web` como las aplicaciones de terceros se integran con KiloCenter a través de la misma superficie de API pública. `KC-Core` también usa RPC internos para `KC-Identity` para los flujos de organización, membresía y resolución de administradores. En Docker Compose, también se ejecuta una `certgen` servicio de una sola vez antes de KC-Core en el primer arranque para crear la CA compartida y el conjunto de certificados del servidor. Los módulos del repositorio se enumeran a continuación.
#### Módulos del repositorio
* **KC-Web** - interfaz de administración web servida por nginx en el puerto 80
* **KC-Gateway** - entrada externa gRPC-web y proxy de solicitudes en el puerto 9090
* **KC-Identity** - servicio de identidad y organización en el puerto 50052
* **KC-Core** - BSSCI, SCACI, API interna gRPC y lógica del centro de servicio
* **KC-DB** - migraciones de PostgreSQL, repositorios e interfaces de almacenamiento utilizadas por los servicios en tiempo de ejecución
* **KC-MQTT** - paquete de integración MQTT utilizado por KC-Core; no se despliega como contenedor separado en el stack Docker comunitario
* **pkg** - control de versiones compartido y utilidades comunes de Go usadas en todos los módulos
### Primeros pasos
#### Inicio rápido (Docker Compose)
Requisitos previos:
* Docker y Docker Compose v2
* Git
1. Clona el repositorio:
```
git clone https://github.com/Kiloiot/KiloServiceCenter.git
cd KiloServiceCenter
```
2. Copia la plantilla de entorno:
```
cp .env.example .env
```
3. Inicia el stack:
```
docker compose up --build -d
```
Esto inicia `postgres`, `redis`, `mosquitto`, `certgen`, `kc-identity`, `kilocenter`, `kc-gateway` y `kc-web`.
Los certificados TLS se generan automáticamente en el primer arranque. Las migraciones de la base de datos se ejecutan al iniciar.
4. Abre la interfaz web e inicia sesión con la cuenta de administrador predeterminada:
```
http://localhost/
```
| | |
| ---------------------- | ----------------------------- |
| **Correo electrónico** | `admin [at] kilocenter.local` |
| **Contraseña** | `admin123!` |
> Reemplaza `[at]` con `@` al iniciar sesión.
> **Advertencia:** Cambia la contraseña predeterminada del administrador o elimina esta cuenta antes de cualquier despliegue de producción o de cara al público. Las credenciales predeterminadas están publicadas en este repositorio.
> **Importante:** KC-Identity y KC-Gateway deben compartir el mismo secreto HMAC para que la autenticación JWT funcione. El secreto se configura en `config/config.identity-docker.yaml` y `config/config.gateway-docker.yaml` en `auth.hmac_secret`. Si estos valores difieren, verás `invalid_token` errores después de iniciar sesión. Consulta la [guía de Docker Compose](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/GitBook/02-GettingStarted/03-installation-docker-compose.md#authentication-secret-hmac) para más detalles.
Para detalles específicos de Docker, configuración personalizada del nombre de host TLS y exportación de la CA, consulta [Instalación con Docker Compose](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/GitBook/02-GettingStarted/03-installation-docker-compose.md).
#### Otros modos de instalación
* [Instalación en host Linux](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/GitBook/02-GettingStarted/04-installation-linux-host.md) - despliegue manual en host con `KC-Core/certgen`
* [VM local y automatización](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/GitBook/02-GettingStarted/05-installation-local-vm-and-automation.md) - flujo de trabajo de VM basado en Docker
* [Primeros pasos](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/GitBook/02-GettingStarted/README.md) - arquitectura, requisitos previos y ruta de instalación
#### Exportar el certificado de la CA
Las estaciones base y los centros de aplicaciones SCACI externos necesitan el certificado de la CA para establecer confianza TLS:
```
docker compose cp kilocenter:/app/certificates/ca.crt ./ca.crt
```
#### Detención
```
# Detener servicios y conservar los volúmenes de datos
docker compose down
# Reinicio completo: elimina la base de datos, los certificados y otros volúmenes Docker
docker compose down -v
```
### Configuración
Copia `.env.example` a `.env` y ajústalo según sea necesario. Claves comunes de Docker Compose:
```
KILOCENTER_POSTGRESQL_USERNAME=kilocenter
KILOCENTER_POSTGRESQL_PASSWORD=changeme
KILOCENTER_POSTGRESQL_DATABASE=kilocenter
KILOCENTER_LOG_LEVEL=info
# KILOCENTER_TLS_SERVER_NAME=localhost
```
Establece `KILOCENTER_TLS_SERVER_NAME` antes del primer `docker compose up` si necesitas un certificado de servidor para un nombre de host específico en lugar de `localhost`.
### Documentación de la API
#### Acceso gRPC
* punto final externo gRPC / gRPC-web: `http://localhost:9090`
* Salud del gateway: `http://localhost:8087/health`
* Salud de KC-Core: `http://localhost:8086/health`
* Salud de KC-Identity: `http://localhost:8088/health`
* La reflexión gRPC está habilitada de forma predeterminada en KC-Core y KC-Identity para herramientas
#### Superficies del servicio
* `CoreService` - gestión de dispositivos, operaciones de protocolo, analítica, monitorización, certificados y RPCs de monitorización SCACI
* `IdentityService` - autenticación, usuarios, organizaciones y claves de API
* `KiloCenterService` - superficie de compatibilidad que delega en Core e Identity
En el desarrollo local desde el código fuente, KC-Web puede apuntar su proxy Vite a un destino de gateway diferente mediante `INGRESS_GRPC_URL`. En despliegues en contenedores, KC-Web es servido por nginx y hace proxy a KC-Gateway automáticamente.
### Despliegue desde código y en host
Docker Compose es la vía de instalación recomendada para evaluación y para la mayoría de los despliegues.
Si necesitas un flujo de trabajo sin contenedores, usa las guías dedicadas en lugar de un arranque manual improvisado:
* [Instalación en host Linux](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/GitBook/02-GettingStarted/04-installation-linux-host.md)
* [VM local y automatización](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/GitBook/02-GettingStarted/05-installation-local-vm-and-automation.md)
#### Kubernetes
Se proporciona un gráfico Helm para el despliegue en Kubernetes. Consulta [helm/kilocenter/](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/helm/kilocenter) para el gráfico completo y la referencia de configuración.
```
# Instalar KiloCenter (requiere PostgreSQL y Redis externos)
helm install kilocenter helm/kilocenter -f my-values.yaml
```
Consulta el [README del gráfico Helm](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/helm/kilocenter/README.md) para requisitos previos, opciones de configuración y valores de ejemplo.
### Soporte del protocolo MIOTY
KiloCenter implementa el stack de centro de servicio MIOTY definido por la MIOTY Alliance:
* Conciencia de la capa física para la división de telegramas
* Manejo de mensajes en las capas MAC y de red
* Soporte para endpoints unidireccionales y bidireccionales
* Manejo de direcciones cortas
* Flujos de adjunto y desadjunto
* Soporte de cifrado de extremo a extremo
La edición comunitaria se centra en el stack principal del centro de servicio. Las capacidades MIOTY opcionales, como los subcanales BSSCI, el adjunto Variable MAC (VM), las extensiones ReCon y la operación empresarial multitenencia, pertenecen a la oferta empresarial.
#### Perfiles y comportamientos compatibles
* MIOTY TS-UNB
* Operación de endpoints alimentados por batería
* Múltiples patrones de redundancia
* Manejo de recepción en múltiples estaciones base
### Despliegue en producción
Este repositorio no es el vehículo recomendado para el despliegue en producción. Usa Kilo Cloud o la Plataforma IoT Kilo local para despliegues de producción que requieran soporte comercial, garantías operativas, cobertura SLA, multitenencia y capacidades MIOTY opcionales como subcanales BSSCI, Variable MAC (VM) y extensiones ReCon. Elige Kilo Cloud cuando el despliegue también necesite reglas visuales, paneles, datos históricos, alarmas y escalado, historial de auditoría u otros flujos de trabajo de plataforma sin tener que construir esos sistemas tú mismo alrededor de la Community Edition.
#### Requisitos del sistema
* Mínimo: 2 núcleos de CPU, 4 GB de RAM, 20 GB de almacenamiento
* Recomendado: 4 núcleos de CPU, 8 GB de RAM, 100 GB de SSD
* SO: Linux (se recomienda Ubuntu 22.04 LTS)
#### Consideraciones de seguridad
* Usa siempre certificados TLS en producción
* Cambia las credenciales predeterminadas antes del despliegue
* Restringe BSSCI (`5000`) y SCACI (`5001`) a redes de confianza
* Realiza copias de seguridad de la base de datos con regularidad
* Supervisa las alertas del sistema y la expiración de certificados
### Documentación
* [Primeros pasos](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/GitBook/02-GettingStarted/README.md)
* [Arquitectura y componentes](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/GitBook/02-GettingStarted/01-architecture-and-components.md)
* [Instalación con Docker Compose](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/GitBook/02-GettingStarted/03-installation-docker-compose.md)
* [Instalación en host Linux](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/GitBook/02-GettingStarted/04-installation-linux-host.md)
* [Conceptos básicos de configuración](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/GitBook/02-GettingStarted/06-configuration-basics.md)
* [Documentación de la API](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/GitBook/04-Integrations/02-api.md)
* [Integración MQTT](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/GitBook/04-Integrations/03-mqtt-first-steps.md)
* [Seguridad](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/GitBook/05-Security/01-security-and-tenant-isolation-basics.md)
### Licencia
KiloCenter Community Edition está licenciada bajo la [GNU Affero General Public License v3.0 o posterior](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/LICENSE).
Si ejecutas una versión modificada como servicio de red, la AGPL exige que pongas el código fuente modificado a disposición de los usuarios. El repositorio de origen es [github.com/Kiloiot/KiloServiceCenter](https://github.com/Kiloiot/KiloServiceCenter).
Ver [TRADEMARKS.md](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/TRADEMARKS.md) para la política de marcas registradas.
Copyright 2024-2026 Tim Kravchunovsky y colaboradores.
### Soporte
* **Incidencias**: [Incidencias de GitHub](https://github.com/Kiloiot/KiloServiceCenter/issues)
* **Documentación**: [GitBook/](https://github.com/Kiloiot/kilo-service-center/blob/3d0674b296989f1f2337563549e59d6ebd480b65/GitBook)
* **MIOTY Alliance**: [mioty-alliance.com](https://mioty-alliance.com/)
### Agradecimientos
KiloCenter está construido sobre estándares definidos por la MIOTY Alliance y sobre patrones operativos comunes para infraestructuras IoT autoalojadas.
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://docs.kiloiot.io/kilo-docs-es/kilo-center/kilo-mioty-service-center/project-overview.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.