# Requisitos do servidor Sherpa AI Server

## Requisitos do servidor Sherpa AI Server

#### Requisitos do sistema

* **OS**: recomenda-se Ubuntu 20.04+, no entanto, geralmente não há problemas com outras distribuições Linux, a compatibilidade foi verificada com RedOS, AstraLinux, AltLinux, Debian
* **CPU**: x86\_64 com AVX2
* **RAM**: 16 GB no mínimo, 32 GB+ recomendado
* **Disco**: 100 GB+ de espaço livre
* **GPU**: NVIDIA com CUDA 11.8+ (recomendado)
* **Rede**: Conexão de internet estável
* **Acesso**: permissões sudo para instalação

**Importante:**

* A instalação leva horas devido ao download dos modelos de IA (10-50 GB)
* Após a instalação, a internet não é necessária

#### Preparação do servidor

**Verificação de recursos**

A seguir, utiliza-se a sintaxe do Ubuntu, se o comando não for adequado, você precisará alterar a sintaxe de acordo com seu SO

```bash
# Verifique os recursos do sistema
df -h          # Espaço em disco
free -h        # Memória RAM
nvidia-smi     # GPU (se instalada)
```

<details>

<summary>💡 Comentários sobre a verificação de recursos</summary>

**df -h** - mostra o uso do espaço em disco em formato legível por humanos **free -h** - mostra informações sobre a memória RAM **nvidia-smi** - mostra informações sobre a GPU NVIDIA (se instalada)

</details>

**Instalação de ferramentas básicas**

```bash
# Atualize o sistema e instale as ferramentas
sudo apt update
sudo apt install -y ca-certificates curl tar
```

<details>

<summary>💡 Comentários sobre a instalação de ferramentas básicas</summary>

**sudo apt update** - atualiza a lista de pacotes disponíveis dos repositórios **sudo apt install -y ca-certificates curl tar** - instala as ferramentas necessárias:

* `ca-certificates` - certificados raiz para verificação SSL
* `curl` - ferramenta para download de arquivos
* `tar` - utilitário para trabalhar com arquivos compactados
* `-y` - confirmação automática da instalação

</details>

#### Instalação do Docker (pule se já estiver instalado)

Sherpa AI Server funciona em contêineres Docker.

**Instalação do Docker CE**

```bash
# Adicione a chave GPG oficial do 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

# Adicione o repositório 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 o Docker
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
```

<details>

<summary>💡 Comentários sobre a instalação do Docker</summary>

**Adicionando a chave GPG:**

* `sudo install -m 0755 -d /etc/apt/keyrings` - cria o diretório para as chaves com as permissões corretas
* `sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc` - baixa a chave GPG do Docker
* `sudo chmod a+r /etc/apt/keyrings/docker.asc` - define permissões de leitura para todos

**Adicionando o repositório:**

* `echo "deb [...]` - adiciona o repositório oficial do Docker à lista de fontes APT
* Usa variáveis de ambiente para determinar a arquitetura e a versão do Ubuntu

**Instalação de pacotes:**

* `sudo apt update` - atualiza a lista de pacotes após adicionar um novo repositório
* `sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin` - instala o Docker e os componentes

</details>

**Configuração e verificação**

```bash
# Adicione o usuário ao grupo docker (opcional)
sudo usermod -aG docker $USER

# Verifique a instalação
docker --version
docker compose version
```

<details>

<summary>💡 Comentários sobre a configuração do Docker</summary>

**sudo usermod -aG docker $USER** - adiciona o usuário atual ao grupo docker

* `-a` - append (adiciona aos grupos existentes)
* `-G docker` - adiciona ao grupo docker
* `$USER` - variável com o nome do usuário atual

**docker --version** - mostra a versão do Docker **docker compose version** - mostra a versão do Docker Compose

**Resultado esperado:** Docker inicia com sucesso um contêiner de teste.

</details>

**Resultado esperado:** Docker inicia com sucesso um contêiner de teste.

#### Instalação de suporte a GPU (NVIDIA + Toolkit) (pule se já estiver instalado)

Se o servidor tiver uma GPU NVIDIA, instale os drivers e o Container Toolkit:

> **💡 Instalação offline:** Se o servidor não tiver acesso à internet, use a seção Instalação offline de suporte a GPU (NVIDIA) abaixo.

**Instalação dos drivers NVIDIA**

```bash
# Remova drivers antigos e instale novos
sudo apt purge 'nvidia-*'
sudo apt autoremove
sudo apt install -y nvidia-driver-580

# Reinicie o servidor
sudo reboot
```

<details>

<summary>💡 Comentários sobre a instalação dos drivers NVIDIA</summary>

**sudo apt purge 'nvidia-\*'** - remove todos os pacotes NVIDIA

* `purge` - remove pacotes e seus arquivos de configuração
* `'nvidia-*'` - padrão para buscar todos os pacotes que começam com nvidia

**sudo apt autoremove** - remove dependências desnecessárias **sudo apt install -y nvidia-driver-580** - instala os drivers NVIDIA versão 580

**sudo reboot** - reinicia o sistema para aplicar as alterações

</details>

**Verificação da GPU**

```bash
# Após reiniciar, verifique a GPU
nvidia-smi
```

<details>

<summary>💡 Comentários sobre a verificação da GPU</summary>

**nvidia-smi** - Interface de Gerenciamento de Sistema para GPU NVIDIA

* Mostra informações sobre GPU, drivers, processos
* Usado para diagnóstico e monitoramento

**Saída esperada:**

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

</details>

**Instalação do NVIDIA Container Toolkit**

```bash
# Adicione o repositório e instale o 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 o Docker para GPU
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker
```

<details>

<summary>💡 Comentários sobre a instalação do NVIDIA Container Toolkit</summary>

**Adicionando o repositório do NVIDIA Container Toolkit:**

* `curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey` - baixa a chave GPG
* `sudo gpg --dearmor` - converte a chave para formato binário
* `curl ... nvidia-container-toolkit.list` - baixa a configuração do repositório
* `sed 's#deb https://#deb [signed-by=...] https://#g'` - adiciona a assinatura da chave na configuração

**sudo apt update** - atualiza a lista de pacotes **sudo apt install -y nvidia-container-toolkit** - instala o toolkit

**sudo nvidia-ctk runtime configure --runtime=docker** - configura o runtime do Docker para NVIDIA **sudo systemctl restart docker** - reinicia o daemon do Docker para aplicar as alterações

</details>

#### Instalação offline de suporte a GPU (NVIDIA)

Se o servidor não tiver acesso à internet, execute a instalação dos drivers NVIDIA e do Container Toolkit em modo offline. A preparação dos pacotes pode ser feita paralelamente ao download das imagens do Docker.

**Preparação dos pacotes em uma máquina com internet**

**Requisitos:** Máquina com Ubuntu/Debian e acesso à internet.

**Importante:**

* A preparação dos pacotes pode ser feita em qualquer máquina com Ubuntu/Debian (não necessariamente no servidor de destino)
* Certifique-se de que você tem espaço suficiente em disco (cerca de 1 GB para todos os pacotes)
* Todos os comandos são executados em uma única sessão de terminal, preste atenção ao diretório atual

Na máquina com acesso à internet (Ubuntu/Debian), prepare um arquivo com os pacotes NVIDIA:

**Download dos drivers NVIDIA**

**Importante:** Escolha uma das duas maneiras - ou baixe o arquivo .run do site da NVIDIA, ou use pacotes .deb através do apt download.**Método 1: Download do arquivo .run do site oficial da NVIDIA (recomendado para iniciantes)**

1. Acesse o site oficial da NVIDIA: <https://www.nvidia.com/Download/index.aspx>
2. Selecione as opções:
   * **Tipo de Produto**: GeForce / Quadro / Tesla (dependendo da sua placa de vídeo)
   * **Série do Produto**: escolha a série da sua placa de vídeo
   * **Produto**: escolha o modelo específico
   * **Sistema Operacional**: Linux 64-bit
   * **Tipo de Download**: Linux Driver
   * **Idioma**: English (US)
3. Clique em "Search" e baixe o arquivo do driver (por exemplo, `NVIDIA-Linux-x86_64-580.XX.XX.run`)
4. Crie um diretório para os pacotes e salve o arquivo .run:

   ```bash
   mkdir -p nvidia-offline-packages/drivers
   # Mova o arquivo .run baixado para este diretório
   mv ~/Downloads/NVIDIA-Linux-x86_64-*.run nvidia-offline-packages/drivers/
   ```

**Método 2: Download de pacotes .deb via apt (para usuários experientes)**

Se você estiver usando Ubuntu/Debian e quiser usar pacotes .deb:

```bash
# Crie um diretório para os pacotes
mkdir -p nvidia-offline-packages/drivers
cd nvidia-offline-packages/drivers

# Baixe o driver via apt download (se o repositório estiver disponível)
# Primeiro adicione o repositório da NVIDIA (se ainda não estiver adicionado)
sudo add-apt-repository ppa:graphics-drivers/ppa
sudo apt update

# Baixe o pacote do driver
apt download nvidia-driver-580

# Baixe as dependências do driver (execute o comando linha por linha)
# Primeiro descubra a lista de dependências:
apt-cache depends nvidia-driver-580 | grep "Depends:" | cut -d: -f2 | tr -d ' ' > /tmp/deps.txt

# Em seguida, baixe cada dependência:
while read dep; do
	apt download "$dep" 2>/dev/null || echo "Dependência ignorada: $dep"
done < /tmp/deps.txt

# Exclua o arquivo temporário
rm /tmp/deps.txt
```

**Download do NVIDIA Container Toolkit**

**Sobre as chaves GPG:**

* As chaves GPG são usadas para verificar a autenticidade dos pacotes durante a instalação via `apt install`
* Ao instalar offline via `dpkg -i`, as chaves GPG **NÃO são necessárias** - os pacotes são instalados diretamente
* As chaves GPG são necessárias apenas se você planeja usar `apt install` ou configurar o repositório para futuras atualizações
* Para simplificar, você pode pular o download das chaves GPG e instalar os pacotes via `dpkg -i`

```bash
# Volte para o diretório dos pacotes
cd nvidia-offline-packages

# Crie um diretório para o Container Toolkit
mkdir -p toolkit

# Adicione o repositório do NVIDIA Container Toolkit (se ainda não estiver adicionado)
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

# Baixe o pacote do Container Toolkit e todas as suas dependências
cd toolkit
apt download nvidia-container-toolkit

# Baixe as dependências do Container Toolkit (execute o comando linha por linha)
# Primeiro descubra a lista de dependências:
apt-cache depends nvidia-container-toolkit | grep "Depends:" | cut -d: -f2 | tr -d ' ' > /tmp/toolkit-deps.txt

# Em seguida, baixe cada dependência:
while read dep; do
  apt download "$dep" 2>/dev/null || echo "Dependência ignorada: $dep"
done < /tmp/toolkit-deps.txt

# Exclua o arquivo temporário
rm /tmp/toolkit-deps.txt

# Opcional: Baixe a chave GPG e o arquivo do repositório (necessários apenas se você planeja usar apt install em vez de dpkg)
# Para instalação offline via dpkg -i, as chaves GPG NÃO são necessárias
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
```

**Empacotamento do arquivo**

```bash
# Volte para o diretório raiz dos pacotes
cd nvidia-offline-packages

# Verifique se todos os arquivos estão no lugar:
# - drivers/ - contém pacotes .deb ou arquivo .run do driver
# - toolkit/ - contém pacotes .deb do Container Toolkit
# - keys/ - contém chaves GPG e arquivos do repositório (opcional, se houver)

# Crie um arquivo com todos os pacotes
# Se o diretório keys/ estiver vazio ou ausente, você pode criar o arquivo sem ele:
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 "Atenção: Chaves GPG não incluídas no arquivo (não são obrigatórias para instalação via dpkg)"
fi

# Verifique o tamanho do arquivo
ls -lh nvidia-packages-offline.tar.gz
```

<details>

<summary>💡 Comentários sobre a preparação dos pacotes</summary>

**Download dos drivers:**

* O site oficial da NVIDIA fornece versões atualizadas dos drivers para todos os modelos de GPU
* A versão do driver deve atender aos requisitos (recomendado 580+)
* Pacotes .deb são mais convenientes para instalação via dpkg (recomendado para Ubuntu/Debian)
* Arquivos .run são instaladores universais da NVIDIA, funcionam em qualquer distribuição Linux, mas requerem a parada do servidor gráfico durante a instalação

**Download do Container Toolkit:**

* `apt download` baixa o pacote sem instalá-lo
* Dependências são baixadas separadamente para uma instalação offline completa
* Chaves GPG e arquivos do repositório são opcionais - são necessárias apenas se você planeja usar `apt install` em vez de `dpkg -i`, ou se deseja configurar o repositório para futuras atualizações

**Tamanho do arquivo:** O tamanho esperado do arquivo é de cerca de 200-500 MB, dependendo das versões dos pacotes.

</details>

**Transferência do arquivo para o servidor de destino**

Transfira o arquivo `nvidia-packages-offline.tar.gz` para o servidor de destino de qualquer maneira conveniente (SCP, SFTP, pen drive, etc.). Recomenda-se transferir o arquivo junto com as imagens do Docker.

**Instalação no servidor de destino**

Após transferir o arquivo para o servidor de destino, execute a instalação:

**Instalação dos drivers NVIDIA a partir dos pacotes .deb**

Se você baixou pacotes .deb dos drivers:

```bash
# Extraia o arquivo
tar -xzf nvidia-packages-offline.tar.gz
cd nvidia-offline-packages

# Verifique a presença de arquivos .deb no diretório drivers
ls -la drivers/*.deb

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

# Verifique o resultado da instalação
if [ $? -eq 0 ]; then
    echo "Drivers instalados com sucesso"
else
    echo "Erros de dependência encontrados, corrigindo..."
    # Se houver erros de dependência, instale-os do cache ou corrija as dependências
    sudo apt install --fix-broken -y
    
    # Se o fix-broken não ajudou, tente instalar as dependências manualmente
    # Verifique se todas as dependências foram baixadas para o diretório drivers
    echo "Verifique se todas as dependências foram baixadas para o diretório drivers/"
    ls -la *.deb
fi

# Reinicie o servidor para aplicar os drivers
echo "Reiniciando o servidor em 10 segundos... Pressione Ctrl+C para cancelar"
sleep 10
sudo reboot
```

**Se a instalação falhar:**

* Verifique quais pacotes não foram instalados: `dpkg -l | grep nvidia`
* Certifique-se de que todas as dependências foram baixadas: `ls -la drivers/*.deb | wc -l` (deve haver vários arquivos)
* Tente instalar os pacotes um por um: `sudo dpkg -i nome_do_pacote.deb`

**Instalação dos drivers NVIDIA a partir do arquivo .run**

Se você baixou o arquivo .run do driver do site oficial da NVIDIA:

**Importante antes de começar:**

* Certifique-se de que você tem acesso ao servidor via SSH ou acesso físico (caso ocorram problemas)
* Se houver uma interface gráfica instalada no servidor, descubra qual gerenciador de exibição está sendo usado (gdm3, lightdm, sddm)
* Para servidores sem interface gráfica, os passos para parar o servidor gráfico podem ser pulados.\`\`\`bash

## Descompacte o arquivo (se o arquivo .run foi adicionado ao arquivo)

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

## Encontre o arquivo .run do driver (por exemplo, NVIDIA-Linux-x86\_64-580.XX.XX.run)

ls -la \*.run

## Torne o arquivo executável

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

## Determine qual servidor gráfico está sendo usado (execute um dos comandos):

## Verificação para GNOME/GDM3:

systemctl status gdm3 > /dev/null 2>&1 && echo "Usando gdm3"

## Verificação para LightDM:

systemctl status lightdm > /dev/null 2>&1 && echo "Usando lightdm"

## Verificação para SDDM (KDE):

systemctl status sddm > /dev/null 2>&1 && echo "Usando sddm"

## Pare o servidor gráfico (execute APENAS um comando correspondente ao seu gerenciador de exibição):

## Para Ubuntu com GNOME:

sudo systemctl stop gdm3

## OU para Ubuntu com LightDM:

## sudo systemctl stop lightdm

## OU para sistemas com KDE:

## sudo systemctl stop sddm

## OU se não houver interface gráfica, pule esta etapa

## Instale o driver (use as flags para instalação automática)

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

## Verifique o resultado da instalação (deve haver uma mensagem de sucesso)

echo $?

## Se o servidor gráfico foi parado, inicie-o novamente (use o mesmo comando que para parar):

sudo systemctl start gdm3 # ou lightdm/sddm dependendo do seu sistema

## Reinicie o servidor para aplicar os drivers

sudo reboot

````

**Se a instalação falhar:**

* Verifique os logs: `sudo cat /var/log/nvidia-installer.log`
* Certifique-se de que o módulo nouveau está desativado: `lsmod | grep nouveau`
* Tente a instalação com a flag `--no-opengl-files` se o erro estiver relacionado ao OpenGL

<details>

<summary>💡 Comentários sobre a instalação do arquivo .run</summary>

**Flags do instalador:**

* `--silent` - instalação automática sem perguntas interativas
* `--no-nouveau-check` - ignora a verificação do módulo nouveau (driver aberto da NVIDIA)
* `--no-opengl-files` - não instala bibliotecas OpenGL (importante para servidores sem GUI)
* `--disable-nouveau` - desativa o módulo nouveau antes da instalação

**Parando o servidor gráfico:**

* Em servidores sem interface gráfica, esta etapa não é necessária
* Se o servidor gráfico não for parado, a instalação pode falhar
* Após a instalação, o servidor gráfico pode ser iniciado novamente

**Método alternativo (sem parar o GUI):** Se parar o servidor gráfico não for possível, você pode usar o console de texto:

1. Mude para o console de texto (Ctrl+Alt+F1)
2. Faça login no sistema
3. Execute a instalação do arquivo .run
4. Volte para o modo gráfico (Ctrl+Alt+F7 ou reinicie)

</details>

**Verificação da instalação dos drivers**

Após reiniciar, verifique a instalação dos drivers:

```bash
# Verifique o GPU (este comando deve mostrar informações sobre a placa de vídeo)
nvidia-smi
````

**Resultado esperado:** Você deve ver uma tabela com informações sobre o GPU, por exemplo:

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

**Se o comando nvidia-smi não funcionar ou mostrar erro:**

* Verifique se o driver está carregado: `lsmod | grep nvidia`
* Verifique os logs: `dmesg | grep -i nvidia`
* Certifique-se de que o GPU é visível para o sistema: `lspci | grep -i nvidia`

**Instalação do NVIDIA Container Toolkit**

Após a instalação bem-sucedida dos drivers, instale o Container Toolkit:

**Importante:**

* O Docker deve estar instalado antes da instalação do Container Toolkit
* Certifique-se de que o Docker está em execução: `sudo systemctl status docker`

```bash
# Volte para o diretório dos pacotes (substitua pelo caminho real onde você descompactou o arquivo)
# Por exemplo, se o arquivo foi descompactado no diretório home:
cd ~/nvidia-offline-packages
# Ou se em outro lugar, especifique o caminho completo:
# cd /caminho/completo/para/nvidia-offline-packages

# Verifique se todos os arquivos estão no lugar
ls -la toolkit/*.deb

# Opcional: Instale a chave GPG (NÃO é obrigatório para instalação via dpkg)
# As chaves GPG são necessárias apenas se:
# 1. Você planeja usar apt install em vez de dpkg -i
# 2. Você deseja configurar o repositório para futuras atualizações (quando a internet estiver disponível)
# Para uma instalação offline simples via dpkg -i, você pode pular esta etapa
if [ -f "keys/nvidia-container-toolkit.gpg" ]; then
    echo "Instalando chave 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 "Chave GPG instalada"
else
    echo "Chave GPG não encontrada - pulando instalação (não crítico para dpkg -i)"
fi

# Instale o Container Toolkit a partir dos pacotes locais
cd toolkit
sudo dpkg -i *.deb

# Verifique o resultado da instalação
if [ $? -eq 0 ]; then
    echo "Container Toolkit instalado com sucesso"
else
    echo "Erros de dependência encontrados, corrigindo..."
    # Corrija as dependências se necessário
    sudo apt install --fix-broken -y
    
    # Se o fix-broken não ajudou, verifique se todas as dependências foram baixadas
    echo "Verifique a presença de todas as dependências no diretório toolkit/"
    ls -la *.deb
fi

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

# Reinicie o Docker para aplicar as alterações
sudo systemctl restart docker

# Verifique se o Docker está em execução
sudo systemctl status docker

# Verifique a instalação do GPU no Docker
nvidia-smi
```

**Se houver problemas com a instalação:**

* Verifique se o Docker vê o GPU: `docker info | grep -i runtime`
* Verifique a configuração: `cat /etc/docker/daemon.json`
* Certifique-se de que o nvidia-container-toolkit está instalado: `dpkg -l | grep nvidia-container-toolkit`
* Verifique os logs do Docker: `sudo journalctl -u docker -n 50`

<details>

<summary>💡 Comentários sobre a instalação no servidor de destino</summary>

**Instalação dos drivers:**

* `dpkg -i *.deb` - instala todos os pacotes .deb do diretório
* `apt install --fix-broken` - corrige dependências usando o cache local de pacotes (se disponível)
* Reiniciar é obrigatório para ativar os drivers NVIDIA

**Instalação do Container Toolkit:**

* Ao instalar via `dpkg -i`, chaves GPG NÃO são necessárias - os pacotes são instalados diretamente sem verificação de assinatura
* Chaves GPG são necessárias apenas se você usar `apt install` ou planejar configurar um repositório para atualizações
* `dpkg -i` - um método mais simples para instalação offline, não requer configuração de chaves

**Possíveis problemas:**

* Se `apt install --fix-broken` não funcionar sem internet, certifique-se de que todas as dependências foram baixadas para o diretório de pacotes
* Verifique a compatibilidade das versões dos drivers e do Container Toolkit com sua versão do Ubuntu/Debian

</details>

**Resultado esperado:** Após a instalação, o comando `nvidia-smi` deve mostrar informações sobre o GPU, e os contêineres do Docker devem ter acesso ao 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/pt/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.