# Ejecución de dos contenedores LLM simultáneamente

En esta sección se describe la configuración para ejecutar dos modelos de lenguaje simultáneamente en un servidor con múltiples GPU.

### Cuándo es necesario

Ejecutar dos contenedores LLM es útil cuando:

* Tiene varias GPU y desea utilizarlas para diferentes modelos
* Necesita ejecutar diferentes modelos al mismo tiempo (por ejemplo, uno para chat, otro para tareas especializadas)
* Se requiere distribuir la carga entre varios modelos

### Requisitos

* Servidor con al menos 2 GPU NVIDIA
* Cada GPU debe tener suficiente memoria para el modelo seleccionado
* Docker y Docker Compose instalados
* NVIDIA Container Toolkit instalado

### Configuración

#### Paso 1: Verificación de GPU disponibles

Asegúrese de que tiene al menos 2 GPU:

```bash
nvidia-smi
```

**Resultado esperado:** Debe ver al menos 2 GPU en la lista.

#### Paso 2: Descomentar el segundo contenedor LLM

Abra el archivo `docker-compose.yml` y busque el bloque comentado `aiserver-llm-server2` (aproximadamente líneas 103-142).

Descomente todo el bloque, eliminando los caracteres `#` al inicio de cada línea:

```yaml
# Antes:
# aiserver-llm-server2:
#   container_name: aiserver-llm-server2
#   image: aiserver-llm-server:latest
#   ...

# Después:
aiserver-llm-server2:
  container_name: aiserver-llm-server2
  image: aiserver-llm-server:latest
  ...
```

#### Paso 3: Configuración de puertos

Asegúrese de que los puertos no entren en conflicto:

* **aiserver-llm-server** (primer contenedor): puerto `3003:8000`
* **aiserver-llm-server2** (segundo contenedor): el puerto debe ser diferente, por ejemplo `3006:8000` o `3007:8000`

En el bloque comentado, verifique la línea:

```yaml
ports:
  - 3006:8000  # o otro puerto libre
```

#### Paso 4: Configuración de GPU para cada contenedor

Es importante configurar qué GPU será utilizada por cada contenedor.

**Para el primer contenedor (aiserver-llm-server)**

Generalmente utiliza la GPU 0 (por defecto). Verifique las variables de entorno en el archivo `.env` o en el propio `docker-compose.yml`:

```yaml
environment:
  LLM_CUDA_VISIBLE_DEVICES: 0  # o no especificar, entonces se utilizará la GPU 0
```

**Para el segundo contenedor (aiserver-llm-server2)**

En el bloque descomentado, busque la línea:

```yaml
environment:
  LLM_CUDA_VISIBLE_DEVICES: 1  # Utiliza la GPU 1
```

Asegúrese de que el valor corresponda al número de la segunda GPU (generalmente `1` para la segunda GPU).

#### Paso 5: Configuración de modelos

Asegúrese de que cada modelo esté configurado correctamente:

**Primer contenedor (aiserver-llm-server)**

Utiliza la configuración del archivo `.env` o los valores predeterminados. Verifique la variable:

```bash
LLM_COMPLETION_MODEL_NAME=/model-store/nombre-del-modelo-1
```

**Segundo contenedor (aiserver-llm-server2)**

En el bloque descomentado, busque la línea:

```yaml
environment:
  LLM_COMPLETION_MODEL_NAME: "/model-store/Qwen3-30B-A3B-AWQ"
```

Cámbielo al modelo deseado, si se requiere otro.

#### Paso 6: Verificación de la configuración

Antes de ejecutar, verifique la configuración:

```bash
# Verifique la sintaxis del archivo docker-compose
docker compose -f docker-compose.yml config

# Verifique que los puertos no estén ocupados
netstat -tuln | grep -E '3003|3006'
```

#### Paso 7: Ejecución de contenedores

```bash
# Detenga los contenedores actuales (si están en ejecución)
docker compose -f docker-compose.yml down

# Inicie todos los contenedores incluyendo el segundo servidor LLM
docker compose -f docker-compose.yml up -d

# Verifique que ambos contenedores estén en ejecución
docker compose -f docker-compose.yml ps | grep llm-server
```

**Resultado esperado:** Debe ver dos contenedores:

* `aiserver-llm-server` (puerto 3003)
* `aiserver-llm-server2` (puerto 3006)

#### Paso 8: Verificación de funcionamiento

```bash
# Verifique los registros del primer contenedor
docker logs aiserver-llm-server

# Verifique los registros del segundo contenedor
docker logs aiserver-llm-server2

# Verifique el uso de GPU
nvidia-smi
```

**Resultado esperado:**

* Ambos contenedores deben iniciarse correctamente
* En `nvidia-smi` deben verse procesos en diferentes GPU
* Los registros no deben contener errores críticos

### Configuración de variables de entorno

Si necesita cambiar la configuración del segundo contenedor, edite el bloque `environment` en `docker-compose.yml`:

```yaml
aiserver-llm-server2:
  environment:
    LLM_COMPLETION_MODEL_NAME: "/model-store/su-modelo"
    LLM_CUDA_VISIBLE_DEVICES: 1  # Número de GPU (0, 1, 2, etc.)
    LLM_TENSOR_PARALLEL_SIZE: "1"
    LLM_MAX_MODEL_LEN: "16000"
    LLM_GPU_MEMORY_UTILIZATION: "0.85"
    # ... otras configuraciones
```

### Problemas posibles

#### El contenedor no se inicia

**Problema:** El segundo contenedor no se inicia o falla con un error.

**Solución:**

1. Verifique los registros: `docker logs aiserver-llm-server2`
2. Asegúrese de que la GPU esté disponible: `nvidia-smi`
3. Verifique que el puerto esté libre: `netstat -tuln | grep 3006`
4. Verifique que el modelo exista: `ls -la llm-server/models/`

#### Conflicto de puertos

**Problema:** Error "el puerto ya está asignado".

**Solución:**

* Cambie el puerto del segundo contenedor a uno libre (por ejemplo, `3007:8000`)
* O detenga el servicio que ocupa el puerto

#### Memoria GPU insuficiente

**Problema:** El modelo no se carga, errores de memoria.

**Solución:**

* Reduzca `LLM_GPU_MEMORY_UTILIZATION` (por ejemplo, a `0.7`)
* Utilice modelos de menor tamaño
* Libere memoria en la GPU deteniendo otros procesos

#### Ambos contenedores utilizan una GPU

**Problema:** Ambos contenedores utilizan la GPU 0 en lugar de diferentes GPU.

**Solución:**

* Asegúrese de que `LLM_CUDA_VISIBLE_DEVICES` esté configurada correctamente para cada contenedor
* Verifique que la variable no se esté redefiniendo en el archivo `.env`
* Reinicie los contenedores después de cambiar la configuración

### Ejemplo de configuración completa

Ejemplo de configuración de dos contenedores en `docker-compose.yml`:

```yaml
aiserver-llm-server:
  container_name: aiserver-llm-server
  image: aiserver-llm-server:latest
  restart: always
  env_file:
    - .env
  ports:
    - 3003:8000
  environment:
    LLM_CUDA_VISIBLE_DEVICES: 0  # GPU 0
  deploy:
    resources:
      reservations:
        devices:
          - driver: nvidia
            count: all
            capabilities: [ gpu ]
  volumes:
    - "./llm-server/models:/model-store"
  networks:
    - llm-net

aiserver-llm-server2:
  container_name: aiserver-llm-server2
  image: aiserver-llm-server:latest
  restart: always
  ports:
    - 3006:8000
  environment:
    LLM_COMPLETION_MODEL_NAME: "/model-store/Qwen3-30B-A3B-AWQ"
    LLM_CUDA_VISIBLE_DEVICES: 1  # GPU 1
    LLM_TENSOR_PARALLEL_SIZE: "1"
    LLM_MAX_MODEL_LEN: "16000"
    LLM_GPU_MEMORY_UTILIZATION: "0.85"
  deploy:
    resources:
      reservations:
        devices:
          - driver: nvidia
            count: all
            capabilities: [ gpu ]
  volumes:
    - "./llm-server/models:/model-store"
  networks:
    - llm-net
```

### Configuraciones adicionales

#### Uso de diferentes modelos

Puede ejecutar diferentes modelos en cada contenedor:

```yaml
# Primer contenedor - modelo para chat
LLM_COMPLETION_MODEL_NAME: "/model-store/Llama-3-8B"

# Segundo contenedor - modelo para código
LLM_COMPLETION_MODEL_NAME: "/model-store/Qwen3-30B-A3B-AWQ"
```

#### Configuración de memoria

Si tiene GPU con diferentes cantidades de memoria, configure el uso de memoria para cada contenedor:

```yaml
# Para GPU con menor memoria
LLM_GPU_MEMORY_UTILIZATION: "0.7"

# Para GPU con mayor memoria
LLM_GPU_MEMORY_UTILIZATION: "0.9"
```

### Monitoreo

Para monitorear el funcionamiento de ambos contenedores:

```bash
# Estado de los contenedores
docker compose -f docker-compose.yml ps

# Uso de recursos
docker stats aiserver-llm-server aiserver-llm-server2

# Uso de GPU
watch -n 1 nvidia-smi
```

**Resultado esperado:** Ambos contenedores deben funcionar de manera estable, utilizando diferentes GPU.


---

# Agent Instructions: 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:

```
GET https://docs.sherparpa.ru/es/sherpa-ai/sherpa-ai-server/ustanovka-sherpa-ai-server/zapusk-dvukh-llm-konteinerov-odnovremenno.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.