> 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/getting-started/installation-docker-compose.md).

# Instalación: Docker Compose

Instala KiloCenter con Docker Compose — inicia la pila MIOTY de cuatro servicios, incluido KC-Web, sin toolchain en el host.

### Objetivo

Inicia una pila local funcional usando Docker Compose. La pila completa —incluido KC-Web— se ejecuta íntegramente en contenedores. No se requiere la cadena de herramientas Go del host ni el runtime Bun.

### Paso 1: Configurar el entorno

Desde `kilocenter-modules/`:

```bash
cp .env.example .env
```

Editar `.env` si quieres cambiar las credenciales de la base de datos o el nivel de registro. Los valores predeterminados funcionan para una evaluación local.

### Paso 2: Generar certificados TLS

KC-Core requiere certificados TLS para BSSCI y SCACI. Genéralos usando el `certgen` servicio integrado en la imagen de KC-Core:

```bash
docker compose run --rm certgen
```

> **Propiedad de los archivos (Linux):** Si los archivos generados pertenecen a root, vuelve a ejecutarlo con `UID=$(id -u) GID=$(id -g)` antepuesto.

Esto crea cuatro archivos en `KC-Core/certificates/`:

| Archivo      | Propósito                                                                            |
| ------------ | ------------------------------------------------------------------------------------ |
| `ca.crt`     | Certificado CA (distribuir a las estaciones base)                                    |
| `ca.key`     | Clave privada de la CA (mantener segura, se usa para firmar certificados de cliente) |
| `server.crt` | Certificado del servidor (usado por los listeners TLS de KC-Core BSSCI/SCACI)        |
| `server.key` | Clave privada del servidor                                                           |

Para un FQDN de producción, pasa `-server`:

```bash
docker compose run --rm certgen -dir /app/certificates -days 365 -server bssci.example.com
```

> **Importante:** KC-Core no se iniciará sin estos certificados. Consulta la página de Seguridad para ver la referencia completa de opciones de certgen, la renovación de certificados y la generación de certificados de cliente.

### Paso 3: Iniciar todos los servicios

```bash
docker compose up --build -d
```

Esto compila e inicia los siete servicios de tiempo de ejecución. Los inicios posteriores después de una recompilación usan capas en caché cuando es posible.

### Paso 4: Validar el inicio

```bash
# Verifica que todos los servicios estén activos
docker compose ps

# Estado de KC-Core
curl -s http://localhost:8086/health

# Estado de KC-Gateway
curl -s http://localhost:8087/health

# Verifica el proxy gRPC-web de nginx (200/401/403 = OK; 502/404 = proxy roto)
curl -s -o /dev/null -w "%{http_code}" \
  -X POST \
  -H "Content-Type: application/grpc-web+proto" \
  -H "X-Grpc-Web: 1" \
  --data-binary $'\x00\x00\x00\x00\x00' \
  http://localhost/kilocenter.api.v1.KiloCenterService/GetSystemStatus
```

Luego abre KC-Web en tu navegador:

* <http://localhost/>

> **Nota:** La integración MQTT está deshabilitada de forma predeterminada. El broker Mosquitto se ejecuta en Docker, pero KC-Core no se conecta a él hasta que habilites MQTT en `config/config.docker.yaml`. Consulta Primeros pasos con MQTT cuando estés listo para configurar MQTT.

### Detener todos los servicios

```bash
docker compose down
```

Para eliminar también los volúmenes de datos persistentes:

```bash
docker compose down -v
```

***

### Modo de desarrollo desde el código fuente

Para los colaboradores que quieran ejecutar KC-Core, KC-Gateway y KC-Web desde el código fuente:

#### Paso 1: Iniciar contenedores de infraestructura

```bash
docker compose up -d postgres redis mosquitto
```

Esto inicia PostgreSQL (asignado al puerto 5433 del host), Redis (6379) y Mosquitto (1883).

#### Paso 2: Generar certificados TLS

Igual que arriba — usa el `certgen` servicio compose:

```bash
docker compose run --rm certgen
```

#### Paso 3: Instalar dependencias de KC-Web

Desde `kilocenter-modules/KC-Web/`:

```bash
bun install
```

#### Paso 4: Iniciar todos los servicios desde el código fuente

Desde `kilocenter-modules/`:

```bash
./start-dev.sh
```

Esto compila e inicia KC-Core, KC-Gateway y KC-Web. Los registros se escriben en `logs/runtime/`. KC-Web está disponible en `http://localhost:5173`.

#### Detener servicios desde el código fuente

```bash
./stop-all-services.sh

# Detener contenedores de infraestructura
docker compose stop postgres redis mosquitto
```


---

# 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/getting-started/installation-docker-compose.md?ask=<question>&goal=<endgoal>
```

`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.