Este conteúdo foi traduzido automaticamente. Consulte a Limitação de Responsabilidade da tradução automática.

How to deploy Ollama on the QNAP NAS using Container Station

Como implementar Ollama no NAS QNAP usando Container Station

Data da última modificação: 2026-05-08

Applicable Products

QTS, QuTS hero

Container Station

Scenario

You want to run large language models (LLMs) locally on your QNAP NAS for private AI chat, code assistance, or document analysis without sending data to the cloud. Ollama is the most popular and beginner-friendly inference engine for this purpose. This tutorial explains how to deploy Ollama on the QNAP NAS using Container Station.

System Requirements

Requirement	Detail
QNAP App	Container Station 3.x or later
NAS Architecture	x86_64 (Intel or AMD CPU) (Only a few ARM-based models are supported.)
Memory	At least 8 GB (for 3B models) At least 16 GB (for 7B models)
Storage Space	At least 20 GB of extra free storage space in addition to the model file size. Use an SSD volume if possible.
GPU (Optional)	Compatible NVIDIA GPUs (see the compatibility list) GPU should be set to Container Station Mode in the Control Panel.

Warning

OOM (Out of Memory) Risk
Ollama will attempt to load the entire model into memory by default. If your NAS has only 8–16 GB of RAM, loading a 14B or larger model may exhaust system memory, causing NAS services to become unresponsive or the system to restart.

Data Loss Risk
If you do not mount a persistent volume for /root/.ollama, all downloaded models and configuration will be lost when the container is removed or recreated. Always follow the volume mounting instructions in this tutorial.

Best Practice

Check the model size against your available RAM in advance.
Set memory limits to cap container memory usage.
Start with small models (1B or 3B) and assess system stability before attempting larger models.

Procedure

Method 1: CPU-Only Deployment (No GPU Required)

Create storage folders.
Open File Station and create the following folder to store Ollama model data:
/share/Container/ollama
Screenshot: File Station — creating the Ollama folder under /share/Container/
Best Practice
If your NAS has an NVMe SSD cache or SSD volume, create this folder on the SSD. Model loading speed improves by up to 10 times compared to HDDs.

Create a Docker Compose file.

In Container Station, go to Applications > Create. Name the application ollama and paste the following YAML:

version: "3.8"

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - /share/Container/ollama:/root/.ollama
    environment:
      - OLLAMA_HOST=0.0.0.0
      - OLLAMA_KEEP_ALIVE=10m
    networks:
      - ai-network

networks:
  ai-network:
    name: ai-network
    driver: bridge

Screenshot: Container Station — Application creation screen with YAML editor
Screenshot: Container Station — Set the memory limit

Deploy the container.
Click Create. Container Station will pull the Ollama image and start the container. Wait until the status shows Running.
Screenshot: Container Station — ollama container showing "Running" status
Pull your first model.
Open the container's Terminal (or SSH into your NAS and exec you Docker) and run:
```
# For a lightweight 3B model (recommended for first test):
ollama pull llama3.2:3b

# For a standard 9B model (requires 16 GB+ RAM):
ollama pull qwen3.5:9b
```
The download may take several minutes depending on your internet speed. A 9B Q4_K_M model is approximately 4–7 GB.
Note
- Verify you have sufficient disk space before pulling. Use ollama list to check existing models and their sizes.
- For ARM-based NAS models, we recommend starting with the <1B model to monitor memory usage.
Test the model.
In the container terminal, run:
```
ollama run qwen3.5:9b
```
Type a prompt and confirm that you receive a response. Type /bye to exit.

Method 2: NVIDIA GPU-Accelerated Deployment

Note

Additional prerequisites for GPU Mode:

NVIDIA GPU installed and detected by QTS/QuTS hero
GPU set to Container Station Mode in the Control Panel
NVIDIA GPU Driver and NvKernelDriver installed from App Center

Use the GPU-enabled Docker Compose configuration.

Replace the YAML from Method 1 with the following:

version: "3.8"

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - /share/Container/ollama:/root/.ollama
    environment:
      - OLLAMA_HOST=0.0.0.0
      - OLLAMA_KEEP_ALIVE=10m
      - NVIDIA_VISIBLE_DEVICES=all
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    networks:
      - ai-network

networks:
  ai-network:
    name: ai-network
    driver: bridge

Screenshot: Container Station — GPU-enabled Docker Compose YAML

Note

QNAP's bundled NVIDIA drivers may be older than the latest release. If the container fails to start with GPU enabled, check the driver version with nvidia-smi on the host and ensure it is compatible with the Ollama image version

Deploy and verify GPU access.
After the container starts, open its terminal and run:
```
nvidia-smi
```
You should see your GPU model, driver version, and memory information.
Pull a model and confirm GPU acceleration.
```
ollama pull qwen3.5:9b
ollama run qwen3.5:9b
```
While the model is generating a response, open another terminal and run nvidia-smi. You should observe GPU memory usage and GPU utilization increasing.

Result

After completing this tutorial, you will have:

Ollama running on your QNAP NAS at http://<NAS-IP>:11434
Model data persisted in /share/Container/ollama (survives container rebuilds)
A working LLM accessible via the Ollama API

You can test the API from any device on your local network:

curl http://<NAS-IP>:11434/api/generate -d '{
  "model": "qwen3.5:9b",
  "prompt": "Hello, how are you?",
  "stream": false
}'

Important

The OLLAMA_HOST=0.0.0.0 setting exposes the Ollama API on all network interfaces. Do not expose port 11434 to the internet. Use firewall rules or QNAP's network settings to restrict access to your local network only.

Troubleshooting

Container exits immediately after starting

This may be caused by insufficient RAM or GPU driver mismatch. Check container logs in Container Station. Reduce memory limitations or disable GPU mode.

Model pull fails midway

This may result from insufficient disk space or network timeout. Try to free up storage space. Re-run ollama pull; the system resumes from where it stopped.

Response speed is very slow (1–3 tokens per second)

The model may be running on CPU instead of GPU, or the model is too large for your RAM. Verify your GPU access with nvidia-smi inside the container. Try to use a smaller model.

The NAS becomes unresponsive during inference

This can be an "out of memory" issue: the model is consuming all the system memory. We recommend restarting the NAS. Set a memory usage limit in the application. Or use a smaller model.

"Cannot connect to Ollama" message from Open WebUI

This may be caused by a wrong API URL or Docker network isolation. You can use http://ollama:11434 if you are on the same Docker network.

Produtos Aplicáveis

QTS, QuTS hero

Container Station

Cenário

Pretende executar modelos de linguagem grandes (LLMs) localmente no seu NAS QNAP para chat privado de IA, assistência de código ou análise de documentos sem enviar dados para a nuvem. Ollama é o motor de inferência mais popular e amigável para iniciantes para este propósito. Este tutorial explica como implementar Ollama no NAS QNAP usando Container Station.

Requisitos do Sistema

Requisito	Detalhe
App QNAP	Container Station 3.x ou posterior
Arquitetura NAS	x86_64 (CPU Intel ou AMD) (Apenas alguns modelos baseados em ARM são suportados.)
Memória	Pelo menos 8 GB (para modelos 3B) Pelo menos 16 GB (para modelos 7B)
Espaço Armazenamento	Pelo menos 20 GB de espaço livre extra Armazenamento além do tamanho do ficheiro do modelo. Utilize um volume SSD, se possível.
GPU (Opcional)	GPUs NVIDIA compatíveis (ver o Lista de compatibilidade) A GPU deve ser configurada para o Modo Container Station no Painel de Controlo.

Aviso

Risco de OOM (Out of Memory)
O Ollama tentará carregar todo o modelo na memória por padrão. Se o seu NAS tiver apenas 8–16 GB de RAM, carregar um modelo de 14B ou maior pode esgotar a memória do sistema, fazendo com que os serviços NAS se tornem não responsivos ou o sistema reinicie.

Risco de Perda de Dados
Se não montar um volume persistente para /root/.ollama, todos os modelos e configurações descarregados serão perdidos quando o contentor for removido ou recriado. Siga sempre as instruções de montagem de volume neste tutorial.

Melhores Práticas

Verifique o tamanho do modelo em relação à RAM disponível antecipadamente.
Defina limites de memória para limitar o uso de memória do contentor.
Comece com modelos pequenos (1B ou 3B) e avalie a estabilidade do sistema antes de tentar modelos maiores.

Procedimento

Método 1: Implementação Apenas com CPU (Sem GPU Necessária)

Crie pastas Armazenamento.
Abra File Station e crie a seguinte pasta para armazenar dados do modelo Ollama:
/share/Container/ollama
Captura de ecrã: File Station — criando a pasta Ollama em /share/Container/
Melhores Práticas
Se o seu NAS tiver uma cache SSD NVMe ou volume SSD, crie esta pasta no SSD. A velocidade de carregamento do modelo melhora até 10 vezes em comparação com HDDs.

Crie um ficheiro Docker Compose.

No Container Station, vá para Aplicações > Criar. Nomeie a aplicação ollama e cole o seguinte YAML:

version: "3.8"

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - /share/Container/ollama:/root/.ollama
    environment:
      - OLLAMA_HOST=0.0.0.0
      - OLLAMA_KEEP_ALIVE=10m
    networks:
      - ai-network

networks:
  ai-network:
    name: ai-network
    driver: bridge

Captura de ecrã: Container Station — ecrã de criação de aplicação com editor YAML
Captura de ecrã: Container Station — Defina o limite de memória

Implemente o contentor.
Clique em Criar. Container Station irá puxar a imagem Ollama e iniciar o contentor. Aguarde até que o estado mostre A correr.
Captura de ecrã: Container Station — contentor ollama mostrando estado "A correr"
Puxe o seu primeiro modelo.
Abra o Terminal do contentor (ou aceda ao seu NAS via SSH e execute o seu Docker) e execute:
```
# Para um modelo 3B leve (recomendado para o primeiro teste):
ollama pull llama3.2:3b

# Para um modelo 9B padrão (requer 16 GB+ RAM):
ollama pull qwen3.5:9b
```
O download pode demorar vários minutos, dependendo da velocidade da sua internet. Um modelo 9B Q4_K_M tem aproximadamente 4–7 GB.
Nota
- Verifique se tem espaço suficiente em disco antes de puxar. Use ollama list para verificar os modelos existentes e os seus tamanhos.
- Para modelos NAS baseados em ARM, recomendamos começar com o modelo <1B para monitorizar o uso de memória.
Teste o modelo.
No terminal do contentor, execute:
```
ollama run qwen3.5:9b
```
Digite um prompt e confirme que recebe uma resposta. Digite /bye para sair.

Método 2: Implementação Acelerada por GPU NVIDIA

Nota

Pré-requisitos adicionais para o Modo GPU:

GPU NVIDIA instalada e detetada pelo QTS/QuTS hero
GPU configurada para o Modo Container Station no Painel de Controlo
Driver NVIDIA GPU e NvKernelDriver instalados a partir de App Center

Utilize a configuração de Compose Docker com suporte para GPU.

Substitua o YAML do Método 1 pelo seguinte:

version: "3.8"

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - /share/Container/ollama:/root/.ollama
    environment:
      - OLLAMA_HOST=0.0.0.0
      - OLLAMA_KEEP_ALIVE=10m
      - NVIDIA_VISIBLE_DEVICES=all
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    networks:
      - ai-network

networks:
  ai-network:
    name: ai-network
    driver: bridge

Captura de ecrã: Container Station — Compose YAML com suporte para GPU Docker

Nota

Os drivers NVIDIA fornecidos pela QNAP podem ser mais antigos do que a versão mais recente. Se o contentor não iniciar com GPU ativada, verifique a versão do driver com nvidia-smi no host e certifique-se de que é compatível com a versão da imagem Ollama

Implemente e verifique o acesso à GPU.
Após o início do contentor, abra o seu terminal e execute:
```
nvidia-smi
```
Deverá ver o modelo da sua GPU, a versão do driver e informações de memória.
Transfira um modelo e confirme a aceleração da GPU.
```
ollama pull qwen3.5:9b
ollama run qwen3.5:9b
```
Enquanto o modelo está a gerar uma resposta, abra outro terminal e execute nvidia-smi. Deverá observar o aumento do uso de memória da GPU e da utilização da GPU.

Resultado

Após completar este tutorial, terá:

Ollama a funcionar no seu NAS QNAP em http://<NAS-IP>:11434
Dados do modelo persistidos em /share/Container/ollama (sobrevivem a reconstruções de contentores)
Um LLM funcional acessível através da API Ollama

Pode testar a API a partir de qualquer dispositivo na sua rede local:

curl http://<NAS-IP>:11434/api/generate -d '{
  "model": "qwen3.5:9b",
  "prompt": "Olá, como está?",
  "stream": false
}'

Importante

A configuração OLLAMA_HOST=0.0.0.0 expõe a API Ollama em todas as interfaces de rede. Não exponha a porta 11434 à internet. Utilize regras Firewall ou as definições de rede da QNAP para restringir o acesso apenas à sua rede local.

Resolução de problemas

O contentor sai imediatamente após iniciar

Isso pode ser causado por RAM insuficiente ou incompatibilidade de drivers da GPU. Verifique os logs do contentor em Container Station. Reduza as limitações de memória ou desative o modo GPU.

Falha na transferência do modelo a meio

Isso pode resultar de espaço insuficiente em disco ou timeout de rede. Tente liberar espaço em Armazenamento. Execute novamente ollama pull; o sistema retoma de onde parou.

A velocidade de resposta é muito lenta (1–3 tokens por segundo)

O modelo pode estar a funcionar no CPU em vez de na GPU, ou o modelo é demasiado grande para a sua RAM. Verifique o acesso à GPU com nvidia-smi dentro do contentor. Tente usar um modelo menor.

O NAS torna-se não responsivo durante a inferência

Isso pode ser um problema de "falta de memória": o modelo está a consumir toda a memória do sistema. Recomendamos reiniciar o NAS. Defina um limite de uso de memória na aplicação. Ou use um modelo menor.

Mensagem "Não é possível conectar ao Ollama" do Open WebUI

Isso pode ser causado por um URL de API errado ou isolamento de rede Docker. Pode usar http://ollama:11434 se estiver na mesma rede Docker.

Este artigo foi útil?

Sim. Não.

100% das pessoas acham que foi útil.

Para obter mais ajuda, pergunte a outros usuários e aos especialistas da QNAP na comunidade. Ir para a Comunidade QNAP

Conte-nos como podemos melhorar este artigo:

Informações importantes estão faltando no artigo
As soluções do artigo não funcionam
O artigo é muito complicado
O artigo contém informações incorretas
O artigo está desatualizado

Se quiser enviar outros comentários, escreva-os abaixo.