# Requisitos del servidor Sherpa AI Server

## Requisitos del servidor Sherpa AI Server

#### Requisitos del sistema

* **OS**: se recomienda Ubuntu 20.04+, sin embargo, generalmente no hay problemas con otras distribuciones de Linux, la compatibilidad ha sido verificada con RedOS, AstraLinux, AltLinux, Debian
* **CPU**: x86\_64 con AVX2
* **RAM**: mínimo 16 GB, se recomiendan 32 GB+
* **Disco**: 100 GB+ de espacio libre
* **GPU**: NVIDIA con CUDA 11.8+ (recomendado)
* **Red**: Conexión a Internet estable
* **Acceso**: permisos sudo para la instalación

**Importante:**

* La instalación toma horas debido a la descarga de modelos de IA (10-50 GB)
* Después de la instalación, no se requiere Internet

#### Preparación del servidor

**Verificación de recursos**

A continuación se utiliza la sintaxis de Ubuntu, si el comando no es adecuado, deberá cambiar la sintaxis según su SO.

```bash
# Verifique los recursos del sistema
df -h          # Espacio en disco
free -h        # Memoria RAM
nvidia-smi     # GPU (si está instalada)
```

<details>

<summary>💡 Comentarios sobre la verificación de recursos</summary>

**df -h** - muestra el uso del espacio en disco en un formato legible por humanos **free -h** - muestra información sobre la memoria RAM **nvidia-smi** - muestra información sobre la GPU NVIDIA (si está instalada)

</details>

**Instalación de herramientas básicas**

```bash
# Actualice el sistema e instale herramientas
sudo apt update
sudo apt install -y ca-certificates curl tar
```

<details>

<summary>💡 Comentarios sobre la instalación de herramientas básicas</summary>

**sudo apt update** - actualiza la lista de paquetes disponibles desde los repositorios **sudo apt install -y ca-certificates curl tar** - instala las herramientas necesarias:

* `ca-certificates` - certificados raíz para verificación SSL
* `curl` - herramienta para descargar archivos
* `tar` - utilidad para trabajar con archivos comprimidos
* `-y` - confirmación automática de la instalación

</details>

#### Instalación de Docker (omitir si ya está instalado)

Sherpa AI Server funciona en contenedores Docker.

**Instalación de Docker CE**

```bash
# Agregue la clave GPG oficial de Docker
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Agregue el repositorio de Docker
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Instale Docker
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
```

<details>

<summary>💡 Comentarios sobre la instalación de Docker</summary>

**Agregar la clave GPG:**

* `sudo install -m 0755 -d /etc/apt/keyrings` - crea un directorio para las claves con los permisos correctos
* `sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc` - descarga la clave GPG de Docker
* `sudo chmod a+r /etc/apt/keyrings/docker.asc` - establece permisos de lectura para todos

**Agregar el repositorio:**

* `echo "deb [...]` - agrega el repositorio oficial de Docker a la lista de fuentes APT
* Utiliza variables de entorno para determinar la arquitectura y la versión de Ubuntu

**Instalación de paquetes:**

* `sudo apt update` - actualiza la lista de paquetes después de agregar un nuevo repositorio
* `sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin` - instala Docker y componentes

</details>

**Configuración y verificación**

```bash
# Agregue el usuario al grupo docker (opcional)
sudo usermod -aG docker $USER

# Verifique la instalación
docker --version
docker compose version
```

<details>

<summary>💡 Comentarios sobre la configuración de Docker</summary>

**sudo usermod -aG docker $USER** - agrega al usuario actual al grupo docker

* `-a` - append (agrega a grupos existentes)
* `-G docker` - agrega al grupo docker
* `$USER` - variable con el nombre del usuario actual

**docker --version** - muestra la versión de Docker **docker compose version** - muestra la versión de Docker Compose

**Resultado esperado:** Docker ejecuta correctamente un contenedor de prueba.

</details>

**Resultado esperado:** Docker ejecuta correctamente un contenedor de prueba.

#### Instalación de soporte para GPU (NVIDIA + Toolkit) (omitir si ya está instalado)

Si el servidor tiene una GPU NVIDIA, instale los controladores y el Container Toolkit:

> **💡 Instalación sin conexión:** Si el servidor no tiene acceso a Internet, utilice la sección Instalación sin conexión de soporte para GPU (NVIDIA) a continuación.

**Instalación de controladores NVIDIA**

```bash
# Elimine los controladores antiguos e instale los nuevos
sudo apt purge 'nvidia-*'
sudo apt autoremove
sudo apt install -y nvidia-driver-580

# Reinicie el servidor
sudo reboot
```

<details>

<summary>💡 Comentarios sobre la instalación de controladores NVIDIA</summary>

**sudo apt purge 'nvidia-\*'** - elimina todos los paquetes de NVIDIA

* `purge` - elimina paquetes y sus archivos de configuración
* `'nvidia-*'` - patrón para buscar todos los paquetes que comienzan con nvidia

**sudo apt autoremove** - elimina dependencias innecesarias **sudo apt install -y nvidia-driver-580** - instala los controladores NVIDIA versión 580

**sudo reboot** - reinicia el sistema para aplicar los cambios

</details>

**Verificación de GPU**

```bash
# Después de reiniciar, verifique la GPU
nvidia-smi
```

<details>

<summary>💡 Comentarios sobre la verificación de GPU</summary>

**nvidia-smi** - Interfaz de Gestión del Sistema para GPU NVIDIA

* Muestra información sobre la GPU, controladores, procesos
* Se utiliza para diagnóstico y monitoreo

**Salida esperada:**

```
NVIDIA-SMI 580.xx.xx
Driver Version: 580.xx.xx
```

</details>

**Instalación de NVIDIA Container Toolkit**

```bash
# Agregue el repositorio e instale el toolkit
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | \
  sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit.gpg

curl -fsSL https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

sudo apt update
sudo apt install -y nvidia-container-toolkit

# Configure Docker para GPU
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker
```

<details>

<summary>💡 Comentarios sobre la instalación de NVIDIA Container Toolkit</summary>

**Agregar el repositorio de NVIDIA Container Toolkit:**

* `curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey` - descarga la clave GPG
* `sudo gpg --dearmor` - convierte la clave a formato binario
* `curl ... nvidia-container-toolkit.list` - descarga la configuración del repositorio
* `sed 's#deb https://#deb [signed-by=...] https://#g'` - agrega la firma de la clave a la configuración

**sudo apt update** - actualiza la lista de paquetes **sudo apt install -y nvidia-container-toolkit** - instala el toolkit

**sudo nvidia-ctk runtime configure --runtime=docker** - configura el runtime de Docker para NVIDIA **sudo systemctl restart docker** - reinicia el daemon de Docker para aplicar los cambios

</details>

#### Instalación sin conexión de soporte para GPU (NVIDIA)

Si el servidor no tiene acceso a Internet, realice la instalación de los controladores NVIDIA y el Container Toolkit en modo sin conexión. La preparación de los paquetes se puede realizar paralelamente a la descarga de imágenes de Docker.

**Preparación de paquetes en una máquina con Internet**

**Requisitos:** Máquina con Ubuntu/Debian y acceso a Internet.

**Importante:**

* La preparación de paquetes se puede realizar en cualquier máquina con Ubuntu/Debian (no necesariamente en el servidor de destino)
* Asegúrese de tener suficiente espacio en disco (alrededor de 1 GB para todos los paquetes)
* Todos los comandos se ejecutan en una sola sesión de terminal, preste atención al directorio actual

En la máquina con acceso a Internet (Ubuntu/Debian), prepare un archivo comprimido con los paquetes NVIDIA:

**Descarga de controladores NVIDIA**

**Importante:** Elija uno de los dos métodos: descargue el archivo .run desde el sitio web de NVIDIA o utilice paquetes .deb a través de apt download.**Método 1: Descarga del archivo .run desde el sitio oficial de NVIDIA (recomendado para principiantes)**

1. Vaya al sitio oficial de NVIDIA: <https://www.nvidia.com/Download/index.aspx>
2. Seleccione las opciones:
   * **Tipo de producto**: GeForce / Quadro / Tesla (dependiendo de su tarjeta gráfica)
   * **Serie de producto**: seleccione la serie de su tarjeta gráfica
   * **Producto**: seleccione el modelo específico
   * **Sistema operativo**: Linux 64-bit
   * **Tipo de descarga**: Controlador de Linux
   * **Idioma**: English (US)
3. Haga clic en "Search" y descargue el archivo del controlador (por ejemplo, `NVIDIA-Linux-x86_64-580.XX.XX.run`)
4. Cree un directorio para los paquetes y guarde el archivo .run:

   ```bash
   mkdir -p nvidia-offline-packages/drivers
   # Mueva el archivo .run descargado a este directorio
   mv ~/Descargas/NVIDIA-Linux-x86_64-*.run nvidia-offline-packages/drivers/
   ```

**Método 2: Descarga de paquetes .deb a través de apt (para usuarios avanzados)**

Si está utilizando Ubuntu/Debian y desea usar paquetes .deb:

```bash
# Cree un directorio para los paquetes
mkdir -p nvidia-offline-packages/drivers
cd nvidia-offline-packages/drivers

# Descargue el controlador a través de apt download (si el repositorio está disponible)
# Primero, agregue el repositorio de NVIDIA (si aún no se ha agregado)
sudo add-apt-repository ppa:graphics-drivers/ppa
sudo apt update

# Descargue el paquete del controlador
apt download nvidia-driver-580

# Descargue las dependencias del controlador (ejecute el comando línea por línea)
# Primero, obtenga la lista de dependencias:
apt-cache depends nvidia-driver-580 | grep "Depends:" | cut -d: -f2 | tr -d ' ' > /tmp/deps.txt

# Luego, descargue cada dependencia:
while read dep; do
	apt download "$dep" 2>/dev/null || echo "Dependencia omitida: $dep"
done < /tmp/deps.txt

# Elimine el archivo temporal
rm /tmp/deps.txt
```

**Descarga del NVIDIA Container Toolkit**

**Sobre las claves GPG:**

* Las claves GPG se utilizan para verificar la autenticidad de los paquetes al instalar a través de `apt install`
* Al instalar sin conexión a través de `dpkg -i`, las claves GPG **NO son necesarias** - los paquetes se instalan directamente
* Las claves GPG son necesarias solo si planea usar `apt install` o configurar el repositorio para futuras actualizaciones
* Para simplificar, puede omitir la descarga de las claves GPG e instalar los paquetes a través de `dpkg -i`

```bash
# Regrese al directorio de paquetes
cd nvidia-offline-packages

# Cree un directorio para el Container Toolkit
mkdir -p toolkit

# Agregue el repositorio del NVIDIA Container Toolkit (si aún no se ha agregado)
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | \
  sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit.gpg

curl -fsSL https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

sudo apt update

# Descargue el paquete del Container Toolkit y todas sus dependencias
cd toolkit
apt download nvidia-container-toolkit

# Descargue las dependencias del Container Toolkit (ejecute el comando línea por línea)
# Primero, obtenga la lista de dependencias:
apt-cache depends nvidia-container-toolkit | grep "Depends:" | cut -d: -f2 | tr -d ' ' > /tmp/toolkit-deps.txt

# Luego, descargue cada dependencia:
while read dep; do
  apt download "$dep" 2>/dev/null || echo "Dependencia omitida: $dep"
done < /tmp/toolkit-deps.txt

# Elimine el archivo temporal
rm /tmp/toolkit-deps.txt

# Opcional: Descargue la clave GPG y el archivo del repositorio (solo son necesarios si planea usar apt install en lugar de dpkg)
# Para la instalación sin conexión a través de dpkg -i, las claves GPG NO son necesarias
cd ..
mkdir -p keys
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey -o keys/nvidia-container-toolkit.gpg
curl -fsSL https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list -o keys/nvidia-container-toolkit.list
```

**Empaquetado del archivo**

```bash
# Regrese al directorio raíz de los paquetes
cd nvidia-offline-packages

# Asegúrese de que todos los archivos estén en su lugar:
# - drivers/ - contiene paquetes .deb o el archivo .run del controlador
# - toolkit/ - contiene paquetes .deb del Container Toolkit
# - keys/ - contiene claves GPG y archivos del repositorio (opcional, si existen)

# Cree un archivo comprimido con todos los paquetes
# Si el directorio keys/ está vacío o no existe, se puede crear el archivo comprimido sin él:
if [ -d "keys" ] && [ "$(ls -A keys)" ]; then
    tar -czf nvidia-packages-offline.tar.gz drivers/ toolkit/ keys/
else
    tar -czf nvidia-packages-offline.tar.gz drivers/ toolkit/
    echo "Advertencia: Las claves GPG no están incluidas en el archivo (no son obligatorias para la instalación a través de dpkg)"
fi

# Verifique el tamaño del archivo comprimido
ls -lh nvidia-packages-offline.tar.gz
```

<details>

<summary>💡 Comentarios sobre la preparación de paquetes</summary>

**Descarga de controladores:**

* El sitio oficial de NVIDIA proporciona versiones actualizadas de controladores para todos los modelos de GPU
* La versión del controlador debe cumplir con los requisitos (se recomienda 580+)
* Los paquetes .deb son más convenientes para la instalación a través de dpkg (recomendado para Ubuntu/Debian)
* Los archivos .run son instaladores universales de NVIDIA, funcionan en cualquier distribución de Linux, pero requieren detener el servidor gráfico durante la instalación

**Descarga del Container Toolkit:**

* `apt download` descarga el paquete sin instalarlo
* Las dependencias se descargan por separado para una instalación completamente sin conexión
* Las claves GPG y los archivos del repositorio son opcionales: solo son necesarios si planea usar `apt install` en lugar de `dpkg -i`, o si desea configurar el repositorio para futuras actualizaciones

**Tamaño del archivo:** El tamaño esperado del archivo es de aproximadamente 200-500 MB dependiendo de las versiones de los paquetes.

</details>

**Transferencia del archivo al servidor de destino**

Transfiera el archivo `nvidia-packages-offline.tar.gz` al servidor de destino de cualquier manera conveniente (SCP, SFTP, unidad USB, etc.). Se recomienda transferir el archivo junto con las imágenes de Docker.

**Instalación en el servidor de destino**

Después de transferir el archivo al servidor de destino, realice la instalación:

**Instalación de controladores NVIDIA desde paquetes .deb**

Si ha descargado paquetes .deb de controladores:

```bash
# Descomprima el archivo
tar -xzf nvidia-packages-offline.tar.gz
cd nvidia-offline-packages

# Verifique la presencia de archivos .deb en el directorio drivers
ls -la drivers/*.deb

# Instale los controladores NVIDIA
cd drivers
sudo dpkg -i *.deb

# Verifique el resultado de la instalación
if [ $? -eq 0 ]; then
    echo "Controladores instalados exitosamente"
else
    echo "Se encontraron errores de dependencias, corrigiendo..."
    # Si hubo errores de dependencias, instálelas desde la caché o corrija las dependencias
    sudo apt install --fix-broken -y
    
    # Si fix-broken no ayudó, intente instalar las dependencias manualmente
    # Asegúrese de que todas las dependencias se hayan descargado en el directorio drivers
    echo "Verifique que todas las dependencias se hayan descargado en el directorio drivers/"
    ls -la *.deb
fi

# Reinicie el servidor para aplicar los controladores
echo "Reiniciando el servidor en 10 segundos... Presione Ctrl+C para cancelar"
sleep 10
sudo reboot
```

**Si la instalación terminó con un error:**

* Verifique qué paquetes no se instalaron: `dpkg -l | grep nvidia`
* Asegúrese de que todas las dependencias se hayan descargado: `ls -la drivers/*.deb | wc -l` (debería haber varios archivos)
* Intente instalar los paquetes uno por uno: `sudo dpkg -i nombre_del_paquete.deb`

**Instalación de controladores NVIDIA desde el archivo .run**

Si ha descargado el archivo .run del controlador desde el sitio oficial de NVIDIA:

**Importante antes de comenzar:**

* Asegúrese de tener acceso al servidor a través de SSH o acceso físico (en caso de problemas)
* Si hay una interfaz gráfica instalada en el servidor, averigüe qué gestor de pantalla se utiliza (gdm3, lightdm, sddm)
* Para servidores sin interfaz gráfica, se pueden omitir los pasos para detener el servidor gráfico.\`\`\`bash

## Descomprima el archivo (si el archivo .run fue agregado al archivo)

tar -xzf nvidia-packages-offline.tar.gz cd nvidia-offline-packages/drivers

## Encuentre el archivo .run del controlador (por ejemplo, NVIDIA-Linux-x86\_64-580.XX.XX.run)

ls -la \*.run

## Haga que el archivo sea ejecutable

chmod +x NVIDIA-Linux-x86\_64-\*.run

## Determine qué servidor gráfico se está utilizando (ejecute uno de los comandos):

## Verificación para GNOME/GDM3:

systemctl status gdm3 > /dev/null 2>&1 && echo "Se está utilizando gdm3"

## Verificación para LightDM:

systemctl status lightdm > /dev/null 2>&1 && echo "Se está utilizando lightdm"

## Verificación para SDDM (KDE):

systemctl status sddm > /dev/null 2>&1 && echo "Se está utilizando sddm"

## Detenga el servidor gráfico (ejecute SOLO un comando correspondiente a su gestor de pantalla):

## Para Ubuntu con GNOME:

sudo systemctl stop gdm3

## O PARA Ubuntu con LightDM:

## sudo systemctl stop lightdm

## O PARA sistemas con KDE:

## sudo systemctl stop sddm

## O si no hay interfaz gráfica, omita este paso

## Instale el controlador (utilice los flags para una instalación automática)

sudo ./NVIDIA-Linux-x86\_64-\*.run\
\--silent\
\--no-nouveau-check\
\--no-opengl-files\
\--disable-nouveau

## Verifique el resultado de la instalación (debe haber un mensaje de éxito)

echo $?

## Si el servidor gráfico fue detenido, inícielo nuevamente (utilice el mismo comando que para detenerlo):

sudo systemctl start gdm3 # o lightdm/sddm dependiendo de su sistema

## Reinicie el servidor para aplicar los controladores

sudo reboot

````

**Si la instalación terminó con un error:**

* Verifique los registros: `sudo cat /var/log/nvidia-installer.log`
* Asegúrese de que el módulo nouveau esté deshabilitado: `lsmod | grep nouveau`
* Intente la instalación con el flag `--no-opengl-files` si el error está relacionado con OpenGL

<details>

<summary>💡 Comentarios sobre la instalación del archivo .run</summary>

**Flags del instalador:**

* `--silent` - instalación automática sin preguntas interactivas
* `--no-nouveau-check` - omite la verificación del módulo nouveau (controlador abierto de NVIDIA)
* `--no-opengl-files` - no instala bibliotecas de OpenGL (importante para servidores sin GUI)
* `--disable-nouveau` - desactiva el módulo nouveau antes de la instalación

**Detención del servidor gráfico:**

* En servidores sin interfaz gráfica, este paso no es necesario
* Si el servidor gráfico no está detenido, la instalación puede fallar
* Después de la instalación, el servidor gráfico se puede reiniciar

**Método alternativo (sin detener la GUI):** Si no es posible detener el servidor gráfico, se puede utilizar la consola de texto:

1. Cambie a la consola de texto (Ctrl+Alt+F1)
2. Inicie sesión
3. Realice la instalación del archivo .run
4. Regrese al modo gráfico (Ctrl+Alt+F7 o reinicie)

</details>

**Verificación de la instalación de los controladores**

Después de reiniciar, verifique la instalación de los controladores:

```bash
# Verifique la GPU (este comando debe mostrar información sobre la tarjeta gráfica)
nvidia-smi
````

**Resultado esperado:** Debería ver una tabla con información sobre la GPU, por ejemplo:

```
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 580.XX       Driver Version: 580.XX       CUDA Version: 12.X  |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  NVIDIA GeForce ...  Off  | 00000000:01:00.0 Off |                  N/A |
| ...                                                                         |
+-----------------------------------------------------------------------------+
```

**Si el comando nvidia-smi no funciona o muestra un error:**

* Verifique que el controlador esté cargado: `lsmod | grep nvidia`
* Verifique los registros: `dmesg | grep -i nvidia`
* Asegúrese de que la GPU sea visible para el sistema: `lspci | grep -i nvidia`

**Instalación del NVIDIA Container Toolkit**

Después de una instalación exitosa de los controladores, instale el Container Toolkit:

**Importante:**

* Docker debe estar instalado antes de instalar el Container Toolkit
* Asegúrese de que Docker esté en ejecución: `sudo systemctl status docker`

```bash
# Regrese al directorio de paquetes (reemplace con la ruta real donde descomprimió el archivo)
# Por ejemplo, si el archivo se descomprimió en el directorio personal:
cd ~/nvidia-offline-packages
# O si está en otro lugar, indique la ruta completa:
# cd /ruta/completa/a/nvidia-offline-packages

# Verifique que todos los archivos estén en su lugar
ls -la toolkit/*.deb

# Opcional: Instale la clave GPG (NO es obligatorio para la instalación a través de dpkg)
# Las claves GPG son necesarias solo si:
# 1. Planea usar apt install en lugar de dpkg -i
# 2. Desea configurar el repositorio para futuras actualizaciones (cuando haya internet)
# Para una instalación simple fuera de línea a través de dpkg -i, se puede omitir este paso
if [ -f "keys/nvidia-container-toolkit.gpg" ]; then
    echo "Instalando clave GPG (opcional)..."
    sudo mkdir -p /usr/share/keyrings
    sudo cp keys/nvidia-container-toolkit.gpg /tmp/nvidia-container-toolkit.gpg
    sudo gpg --dearmor /tmp/nvidia-container-toolkit.gpg -o /usr/share/keyrings/nvidia-container-toolkit.gpg
    sudo rm /tmp/nvidia-container-toolkit.gpg
    echo "Clave GPG instalada"
else
    echo "Clave GPG no encontrada - omitiendo instalación (no crítico para dpkg -i)"
fi

# Instale el Container Toolkit desde los paquetes locales
cd toolkit
sudo dpkg -i *.deb

# Verifique el resultado de la instalación
if [ $? -eq 0 ]; then
    echo "Container Toolkit instalado exitosamente"
else
    echo "Se encontraron errores de dependencias, corrigiendo..."
    # Corrija las dependencias si es necesario
    sudo apt install --fix-broken -y
    
    # Si fix-broken no ayudó, verifique que todas las dependencias estén descargadas
    echo "Verifique la presencia de todas las dependencias en el directorio toolkit/"
    ls -la *.deb
fi

# Configure Docker para GPU
sudo nvidia-ctk runtime configure --runtime=docker

# Reinicie Docker para aplicar los cambios
sudo systemctl restart docker

# Verifique que Docker esté en ejecución
sudo systemctl status docker

# Verifique la instalación de la GPU en Docker
nvidia-smi
```

**Si hubo problemas con la instalación:**

* Verifique que Docker vea la GPU: `docker info | grep -i runtime`
* Verifique la configuración: `cat /etc/docker/daemon.json`
* Asegúrese de que nvidia-container-toolkit esté instalado: `dpkg -l | grep nvidia-container-toolkit`
* Verifique los registros de Docker: `sudo journalctl -u docker -n 50`

<details>

<summary>💡 Comentarios sobre la instalación en el servidor de destino</summary>

**Instalación de controladores:**

* `dpkg -i *.deb` - instala todos los paquetes .deb del directorio
* `apt install --fix-broken` - corrige dependencias utilizando la caché local de paquetes (si está disponible)
* El reinicio es obligatorio para activar los controladores NVIDIA

**Instalación del Container Toolkit:**

* Al instalar a través de `dpkg -i`, las claves GPG NO son necesarias - los paquetes se instalan directamente sin verificación de firma
* Las claves GPG son necesarias solo si utiliza `apt install` o planea configurar un repositorio para actualizaciones
* `dpkg -i` - un método más simple para la instalación fuera de línea, no requiere configuración de claves

**Posibles problemas:**

* Si `apt install --fix-broken` no funciona sin internet, asegúrese de que todas las dependencias estén descargadas en el directorio de paquetes
* Verifique la compatibilidad de versiones de los controladores y el Container Toolkit con su versión de Ubuntu/Debian

</details>

**Resultado esperado:** Después de la instalación, el comando `nvidia-smi` debe mostrar información sobre la GPU, y los contenedores de Docker deben tener acceso a la 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/trebovaniya-k-serveru-sherpa-ai-server.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.