UD3 · Preparación del entorno de ejecución

Objetivos de la unidad

Al finalizar esta unidad el alumno será capaz de:

• Identificar y preparar el SO, firmware y controladores necesarios para inferencia GPU
• Instalar y configurar las dependencias de bajo nivel (CUDA, ROCm)
• Comparar los principales motores de inferencia (llama.cpp, vLLM, Ollama, Triton) y seleccionar el adecuado
• Instalar y configurar un motor de inferencia con los parámetros correctos de modelo, precisión y concurrencia
• Aplicar controles de autenticación y gestión de secretos en el entorno
• Validar el entorno con pruebas de arranque y cargas básicas

Stack de software para inferencia LLM

El entorno de ejecución se construye por capas. Cada capa depende de la inferior.

+--------------------------------------------------+
|  Aplicación / API cliente                        |
+--------------------------------------------------+
|  Motor de inferencia (llama.cpp, vLLM, Ollama)   |
+--------------------------------------------------+
|  Framework ML (PyTorch, ONNX Runtime)            |
+--------------------------------------------------+
|  Librerías de cómputo acelerado (CUDA, ROCm)     |
+--------------------------------------------------+
|  Controladores GPU (NVIDIA driver, AMDGPU)       |
+--------------------------------------------------+
|  Firmware (BIOS/UEFI, Secure Boot)               |
+--------------------------------------------------+
|  Sistema operativo (Ubuntu 22.04, RHEL 9)        |
+--------------------------------------------------+

Cada motor de inferencia requiere una versión específica de CUDA. Revisar la matriz de compatibilidad antes de instalar.

Sistema operativo — preparación base

Distribuciones recomendadas para LLM en producción

Actualización inicial

# Ubuntu / Debian
sudo apt update && sudo apt upgrade -y
sudo apt install -y build-essential curl git wget htop nvtop

# Verificar versión del kernel (mínimo 5.15 para CUDA 12)
uname -r

# Deshabilitar swap si toda la RAM es suficiente
sudo swapoff -a

Instalación de controladores NVIDIA y CUDA

Controladores NVIDIA

# Verificar GPU detectada
lspci | grep -i nvidia

# Instalar driver recomendado (Ubuntu)
sudo ubuntu-drivers autoinstall
# O instalar versión específica
sudo apt install -y nvidia-driver-535

# Reiniciar y verificar
sudo reboot
nvidia-smi

CUDA Toolkit

# Instalar CUDA 12.2 (ejemplo)
wget https://developer.download.nvidia.com/compute/cuda/12.2.0/local_installers/\
cuda_12.2.0_535.54.03_linux.run
sudo sh cuda_12.2.0_535.54.03_linux.run --silent --toolkit

# Añadir al PATH
echo 'export PATH=/usr/local/cuda/bin:$PATH' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc

# Verificar
nvcc --version

ROCm para GPUs AMD

Instalación de ROCm (AMD)

# Ubuntu 22.04
sudo apt update
wget https://repo.radeon.com/amdgpu-install/5.7.3/ubuntu/jammy/amdgpu-install_5.7.3.50703-1_all.deb
sudo dpkg -i amdgpu-install_5.7.3.50703-1_all.deb
sudo amdgpu-install --usecase=rocm

# Añadir usuario al grupo render y video
sudo usermod -aG render,video $USER

# Verificar
rocm-smi
rocminfo | grep "gfx"

Matriz de compatibilidad ROCm

Entornos aislados — Python y conda

Entornos virtuales con venv

# Instalar Python 3.11
sudo apt install -y python3.11 python3.11-venv python3.11-dev

# Crear entorno aislado
python3.11 -m venv /opt/llm-env

# Activar
source /opt/llm-env/bin/activate

# Actualizar pip
pip install --upgrade pip setuptools wheel

Entornos con conda (miniconda)

# Instalar Miniconda
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh -b -p /opt/miniconda3

# Crear entorno para vLLM
conda create -n vllm-env python=3.11 -y
conda activate vllm-env

# Instalar PyTorch con CUDA 12.1
pip install torch==2.1.2+cu121 --index-url https://download.pytorch.org/whl/cu121

Motores de inferencia — comparativa

Criterio de selección: llama.cpp/Ollama para entornos con GPU de consumo o CPU; vLLM para producción con GPU de centro de datos que requiere máximo throughput.

Instalación de llama.cpp

# Clonar y compilar con soporte CUDA
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# Compilar con CUDA
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)

# Verificar que detecta la GPU
./build/bin/llama-cli --list-models

# Lanzar servidor de inferencia
./build/bin/llama-server \
  --model /models/llama-3.1-8b-instruct-q4_k_m.gguf \
  --ctx-size 8192 \
  --n-gpu-layers 35 \
  --parallel 4 \
  --port 8080 \
  --host 0.0.0.0

Parámetros clave de llama-server

Instalación de vLLM

# Instalar vLLM (requiere PyTorch con CUDA)
pip install vllm

# Lanzar servidor compatible con API OpenAI
python -m vllm.entrypoints.openai.api_server \
  --model meta-llama/Llama-3.1-8B-Instruct \
  --dtype bfloat16 \
  --max-model-len 8192 \
  --max-num-seqs 64 \
  --gpu-memory-utilization 0.90 \
  --tensor-parallel-size 1 \
  --port 8000 \
  --host 0.0.0.0

# Verificar que arranca correctamente
curl http://localhost:8000/health

Parámetros clave de vLLM

Instalación de Ollama

# Instalar Ollama (script oficial)
curl -fsSL https://ollama.com/install.sh | sh

# Iniciar servicio
sudo systemctl start ollama
sudo systemctl enable ollama

# Descargar y ejecutar un modelo
ollama pull llama3.1:8b
ollama run llama3.1:8b

# Usar la API REST
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1:8b",
  "prompt": "Explica qué es un transformer en dos frases.",
  "stream": false
}'

# Listar modelos disponibles
ollama list

Ollama gestiona automáticamente la descarga, el almacenamiento y la carga del modelo. Ideal para entornos de desarrollo o usuarios sin experiencia en MLOps.

Contenedores Docker para inferencia

# Dockerfile para vLLM con CUDA 12.1
FROM vllm/vllm-openai:latest

ENV MODEL_PATH=/models/llama-3.1-8b-instruct
ENV MAX_MODEL_LEN=8192
ENV MAX_NUM_SEQS=32

EXPOSE 8000

CMD ["python", "-m", "vllm.entrypoints.openai.api_server", \
     "--model", "${MODEL_PATH}", \
     "--dtype", "bfloat16", \
     "--max-model-len", "${MAX_MODEL_LEN}", \
     "--max-num-seqs", "${MAX_NUM_SEQS}", \
     "--host", "0.0.0.0", \
     "--port", "8000"]

# Ejecutar con GPU
docker run --gpus all \
  -v /data/models:/models \
  -p 8000:8000 \
  --name llm-server \
  mi-imagen-vllm:latest

Autenticación y gestión de secretos

Por qué gestionar secretos correctamente

Un endpoint de LLM sin autenticación es un recurso que cualquiera puede consumir. Las API keys y tokens nunca deben estar en código fuente ni en variables de entorno del sistema sin cifrado.

Opciones de gestión de secretos

# Proteger el endpoint con autenticación Bearer token (vLLM)
python -m vllm.entrypoints.openai.api_server \
  --model /models/llama-3.1-8b \
  --api-key "$(cat /run/secrets/llm_api_key)" \
  --port 8000

# Recuperar secreto desde Vault
export LLM_API_KEY=$(vault kv get -field=api_key secret/llm/prod)

Validación del entorno

# 1. Verificar uso de GPU durante la carga del modelo
watch -n 1 nvidia-smi

# 2. Prueba de arranque — petición de salud
curl http://localhost:8000/health
curl http://localhost:11434/api/tags  # Ollama

# 3. Primera petición de inferencia
curl http://localhost:8000/v1/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "llama-3.1-8b", "prompt": "Hola", "max_tokens": 50}'

# 4. Verificar uso de recursos durante inferencia
nvidia-smi --query-gpu=memory.used,memory.total,utilization.gpu \
  --format=csv -l 2

# 5. Prueba básica de concurrencia (10 peticiones en paralelo)
for i in $(seq 1 10); do
  curl -s http://localhost:8000/v1/completions \
    -d '{"model":"llama-3.1-8b","prompt":"Cuenta hasta 5","max_tokens":30}' &
done
wait
echo "Prueba de concurrencia completada"

Actividad práctica — Instalación de entorno

Escenario

Preparar un entorno de inferencia local en una máquina con Ubuntu 22.04 y una GPU NVIDIA RTX 4090 (24 GB VRAM) para servir el modelo Mistral-7B-Instruct-v0.3 en formato GGUF Q4_K_M.

Tareas

1. Redacta la secuencia completa de comandos para instalar controladores NVIDIA y CUDA
2. Elige entre llama.cpp y Ollama para este caso de uso — justifica la elección
3. Escribe el comando de arranque del motor con los parámetros correctos para:
   • Contexto de 4 096 tokens
   • 8 usuarios concurrentes máximo
   • GPU-only (todas las capas en GPU)
4. Diseña una prueba de validación que verifique: arranque correcto, uso de VRAM esperado y respuesta a peticiones concurrentes
5. Indica cómo proteger el endpoint con autenticación por API key

Puntos clave — UD3

• La compatibilidad entre versión del driver NVIDIA, versión de CUDA y versión del motor de inferencia debe verificarse antes de instalar. Un mismatch provoca errores difíciles de diagnosticar.

• llama.cpp/Ollama son ideales para entornos con GPUs de consumo o requisitos de instalación sencilla. vLLM es la elección para producción con GPU de centro de datos por su mayor throughput (PagedAttention).

• Los contenedores Docker con imagen oficial (vllm-openai, ollama) aceleran el despliegue y garantizan reproducibilidad del entorno.

• Las API keys y secretos nunca deben estar en código fuente. Usar variables de entorno o, en producción, un gestor de secretos (Vault, AWS Secrets Manager).

• La validación debe comprobar tres cosas: que el motor arranca sin errores, que usa la GPU (no CPU accidentalmente) y que responde correctamente a peticiones concurrentes.

Criterios de evaluación — UD3

Referencia: resultado de aprendizaje RA3 — "Prepara el entorno instalando y verificando el motor de inferencia, dependencias y componentes."

← Volver a MP04

Navegación

← UD2 · Selección y dimensionamiento…  ·  Volver al módulo  ·  UD4 · Puesta en servicio del modelo →