Qualsiasi Docker

Esempio 1: Server LLM Compatibile OpenAI con vLLM tramite HF

Questo esempio spiega passo dopo passo come eseguire un'API compatibile con vLLM OpenAI utilizzando il template Trooper.AI any-docker.
È redatto per essere comprensibile anche con conoscenze minime di Docker o di AI.

Questa configurazione utilizza Qwen/Qwen3-4B, che è supportato ed eseguibile su tutti i Trooper.AI GPU servers.

Cosa fa questa configurazione

• Avvia un vLLM server all'interno di Docker
• Carica il modello Qwen/Qwen3-4B da Hugging Face
• Espone un API HTTP compatibile con OpenAI
• Funziona con driver moderni NVIDIA (CUDA 13 / 580+)

Perché questa configurazione è necessaria

Con driver più recenti di NVIDIA, le immagini Docker di vLLM più vecchie potrebbero andare in crash con errori CUDA durante l'avvio.
Per evitare ciò, il template any-docker:

• Utilizza l'immagine vLLM nightly
• Forza Docker a caricare le librerie dei driver NVIDIA dell'host

Non è necessario modificare questa logica — utilizzi semplicemente la configurazione sotto.

Variabili del modello

Come mostrato nello screenshot qui sotto, ecco come configurare e di seguito il testo completo da copiare e incollare.

Nota importante su LD_LIBRARY_PATH

Questa impostazione è obbligatoria nei sistemi con CUDA 13.
Senza di essa, vLLM potrebbe non avviare correttamente a causa di incompatibilità dei driver NVIDIA.

Non rimuoverlo.

Come verificare che funzioni

Esegua il seguente comando:

curl https://XXXXXXXX.apps01.trooper.ai/v1/models

Se Lei vede Qwen/Qwen3-4B nella risposta, il server è in esecuzione correttamente.

Esempio di utilizzo con curl

curl https://XXXXXXXX.apps01.trooper.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer dummy-key" \
  -d '{
    "model": "Qwen/Qwen3-4B",
    "messages": [
      { "role": "user", "content": "What is Trooper.AI?" }
    ]
  }'

Esempio di utilizzo con Node.js

Richiesta semplice

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "dummy-key",
  baseURL: "https://XXXXXXXX.apps01.trooper.ai/v1",
});

const result = await client.chat.completions.create({
  model: "Qwen/Qwen3-4B",
  messages: [{ role: "user", content: "What is Trooper.AI?" }],
});

console.log(result.choices[0].message.content);

Test di carico concorrente Node.js (16 richieste parallele)

Questo esempio invia 16 richieste concorrenti all'API e stampa un riassunto semplice della throughput.

import OpenAI from "openai";
import crypto from "crypto";

const client = new OpenAI({
  apiKey: "dummy-key",
  baseURL: "https://XXXXXXXX.apps01.trooper.ai/v1",
});

const CONCURRENCY = 16;

function randomPrompt() {
  return `Explain this random concept in one sentence: ${crypto.randomUUID()}`;
}

const startTime = Date.now();

const requests = Array.from({ length: CONCURRENCY }, () =>
  client.chat.completions.create({
    model: "Qwen/Qwen3-4B",
    messages: [{ role: "user", content: randomPrompt() }],
  })
);

const responses = await Promise.all(requests);

const endTime = Date.now();
const durationSeconds = (endTime - startTime) / 1000;

let totalTokens = 0;
for (const r of responses) {
  totalTokens += r.usage.total_tokens;
}

const tokensPerSecond = (totalTokens / durationSeconds).toFixed(2);

console.log(
  `${tokensPerSecond} token/s of total ${totalTokens} tokens in ${durationSeconds.toFixed(
    2
  )} seconds on ${CONCURRENCY} concurrent connections`
);

Questo test è utile per:

• verifica della concorrenza
• stima della throughput
• verifiche rapide di sanità delle prestazioni

Come ottenere supporto per il vLLM GPU Server?

In caso di problemi con vLLM, La preghiamo di contattare il supporto, siamo molto esperti nell’utilizzo di vLLM: Support Contacts

Si prega di fare riferimento alla nostra Sezione Benchmark per confrontare la Sua installazione di vLLM con i nostri test di prestazioni, concentrandosi sui risultati di multi-concorrenza.

Guida rapida sull'autenticazione vLLM: Come impostare e utilizzare la chiave Api

vLLM esegue un API compatibile con OpenAI, ma non richiede una chiave API reale per impostazione predefinita.

Lei ha due opzioni:

Opzione 1: Utilizzare una chiave di prova (predefinita, la più semplice)

Se l'autenticazione è non obbligatoria, può utilizzare qualunque stringa come chiave API.

curl

-H "Authorization: Bearer dummy-key"

Node.js

apiKey: "dummy-key"

Questo è sufficiente per la maggior parte dei deployment interni, privati o su reti sicure.

Opzione 2: Impostare una vera chiave API (consigliato per endpoint pubblici)

Lei può imporre un API key impostandolo come variabile d'ambiente al momento dell'avvio del container.

Nel template any-docker (start_args):

--env OPENAI_API_KEY=your-secret-key

vLLM richiederà quindi questa chiave in ogni richiesta.

Esempio richiesta con curl:

curl https://your-endpoint/v1/models \
  -H "Authorization: Bearer your-secret-key"

Esempio Node.js:

const client = new OpenAI({
  apiKey: "your-secret-key",
  baseURL: "https://your-endpoint/v1",
});

Come ruotare o modificare la chiave

• Aggiornare OPENAI_API_KEY nel modello
• Fare clic su «aggiorna modello»
• Le chiavi vecchie smettono di funzionare immediatamente

Riassunto

• Nessuna chiave necessaria → usi dummy-key
• Endpoint pubblico → impostare OPENAI_API_KEY
• La Key è mai generata automaticamente; Lei la definisce

Questo mantiene l'autenticazione semplice ed esplicita.

Esempio 2: Esecuzione di Qdrant su un GPU Server

Qdrant è un database vettoriale ad alte prestazioni che supporta ricerca di similarità, ricerca semantica e embeddings su larga scala.
Quando installato su un server Trooper.AI alimentato da GPU, Qdrant può indicizzare e interrogare milioni di vettori in modo estremamente veloce — ideale per sistemi RAG, memoria LLM, motori di personalizzazione e sistemi di raccomandazione.

La seguente guida illustra come eseguire Qdrant tramite Docker, come appare nel dashboard e come interrogarlo correttamente utilizzando Node.js.

Esecuzione del contenitore Docker di Qdrant

Lei può facilmente avviare l'ufficiale qdrant/qdrant Contenitore Docker con le impostazioni mostrate di seguito.
Queste schermate mostrano una configurazione tipica utilizzata su server GPU di Trooper.AI, tra cui:

• Porta esposta dell'API REST
• Accesso alla dashboard
• Persistenza dei dati
• Accelerazione facoltativa con GPU (se abilitata nel Suo ambiente)

Una volta avviato, Lei avrà accesso immediato sia al Qdrant Dashboard che al REST API.

Anteprima della Dashboard di Qdrant

Il dashboard Le consente di ispezionare le collezioni, i vettori, i payload e gli indici.
Un esempio di configurazione della dashboard è questa:

Da qui, Lei può:

• Crea raccolte
• Aggiunga vettori
• Eseguire ricerche di esempio
• Esaminare i metadati
• Monitorare le prestazioni

Interrogazione di Qdrant da Node.js

Di seguito è riportato un esempio funzionante e corretto di Node.js che utilizza il Qdrant REST API.

Correzioni importanti rispetto all'esempio originale:

• Qdrant richiede di chiamare un endpoint come:
  /collections/<collection_name>/points/search
• vector deve essere un array, non (a, b, c)
• Il moderno Node.js ha nativo fetch, quindi non serve node-fetch

ESempio NODEJS

// Qdrant Vector Search Example – fully compatible with Qdrant 1.x and 2.x

async function queryQdrant() {
  // Replace "my_collection" with your actual collection name
  const url = 'https://AUTOMATIC-SECURE-URL.trooper.ai/collections/my_collection/points/search';

  const payload = {
    vector: [0.1, 0.2, 0.3, 0.4],  // Must be an array
    limit: 5
  };

  try {
    const response = await fetch(url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(payload)
    });

    if (!response.ok) {
      throw new Error(`Qdrant request failed with status: ${response.status}`);
    }

    const data = await response.json();
    console.log('Qdrant Response:', data);
    return data;

  } catch (error) {
    console.error('Error querying Qdrant:', error);
    return null;
  }
}

queryQdrant();

Payload di ricerca valido per Qdrant

Qdrant si aspetta un body in JSON come questo:

{
  "vector": [0.1, 0.2, 0.3, 0.4],
  "limit": 5
}

Dove:

• vettore → il suo {{N}}embedding{{/N}}
• limit → numero massimo di risultati restituiti

È inoltre possibile aggiungere filtri avanzati se necessario:

{
  "vector": [...],
  "limit": 5,
  "filter": {
    "must": [
      { "key": "category", "match": { "value": "news" } }
    ]
  }
}

Note per gli utenti di Trooper.AI

• Sostituisca AUTOMATIC-SECURE-URL.trooper.ai con il Suo endpoint sicuro allocato
• Assicuri che la Sua collection esista prima di effettuare una querying

Esempio: Esecuzione di N8N con Any Docker

In questo esempio, configureremo Any Docker con la Sua configurazione per N8N e archiviazione dati persistente in modo che i riavvii siano possibili con dati integri. Questa configurazione non include webhook. Se Le servono webhook, passi al template preconfigurato dedicato: n8n

Questa guida serve solo a scopo esplicativo. Lei può avviare qualsiasi contenitore Docker che preferisca.

Veda le schermate della configurazione qui sotto:

Il Comando Docker ‘Sotto il cofano’

Questo modello automatizza l’intera configurazione di un contenitore Docker abilitato alla GPU, inclusa l’installazione di tutti i pacchetti e le dipendenze Ubuntu necessari per il supporto alle GPU NVIDIA. Questo semplifica il processo, soprattutto per gli utenti abituati ai deployment Docker per server web, che spesso richiedono configurazioni più complesse.

Seguente docker run Il comando viene generato automaticamente dal template per avviare il Suo GPU container scelto. Contiene tutte le impostazioni necessarie per prestazioni ottimali e compatibilità con il Suo server Trooper.AI.

Questo comando funge da esempio illustrativo per fornire agli sviluppatori una panoramica dei processi sottostanti:

docker run -d \
  --name ${CONTAINER_NAME} \
  --restart always \
  --gpus ${GPUS} \
  --add-host=host.docker.internal:host-gateway \
  -p ${PUBLIC_PORT}:${DOCKER_PORT} \
  -v ${LOCAL_DATA_DIR}:/home/node/.n8n \
  -e N8N_SECURE_COOKIE=false \
  -e N8N_RUNNERS_ENABLED=true \
  -e N8N_HOST=${N8N_HOST} \
  -e WEBHOOK_URL=${WEBHOOK_URL} \
  docker.n8n.io/n8nio/n8n \
  tail -f /dev/null

Non utilizzi questo comando manualmente se non è un esperto di Docker! Si limiti a fidarsi del modello.

Che cosa consente di fare N8N sulla macchina GPU privata?

n8n sblocca il potenziale per eseguire workflow complessi direttamente sulla Sua macchina Trooper.AI con GPU. Ciò significa che può automatizzare compiti che coinvolgono elaborazione di immagini/video, analisi dei dati, interazioni con LLM e molto altro – sfruttando il potere della GPU per prestazioni accelerate.

In particolare, Lei può eseguire workflow per:

• Manipolazione immagini/video: Automatizzare ridimensionamento, aggiunta di watermark, rilevamento oggetti e altre attività visive.
• Elaborazione dati: Estrarre, trasformare e caricare dati da varie fonti.
• Integrazione LLM: Connessione e interazione con Modelli Linguistici di Grande Dimensioni per compiti come la generazione di testo, traduzione e analisi del sentiment.
• Automazione Web: Automatizzare compiti su diversi siti web e API.
• Flussi di lavoro personalizzati: Creare e implementare qualsiasi processo automatizzato su misura per le Sue esigenze.

Tenga presente che dovrà installare strumenti AI come ComfyUI e Ollama per integrarli nei suoi flussi di lavoro N8N sulla macchina localmente. Inoltre, avrà bisogno di sufficiente GPU VRAM per alimentare tutti i modelli. Non assegni quelle GPU al docker in esecuzione con N8N.

Che cos'è Docker in termini di una macchina con GPU?

Su un server GPU di Trooper.AI, Docker consente di imballare applicazioni e le loro dipendenze in unità standardizzate chiamate container. Questo è particolarmente potente per i carichi di lavoro accelerati dalla GPU, poiché garantisce coerenza tra ambienti diversi e semplifica il deployment. Invece di installare le dipendenze direttamente sul sistema operativo host, i container Docker includono tutto ciò che un’applicazione necessita per funzionare – compresi librerie, strumenti di sistema, runtime e impostazioni.

Per le applicazioni GPU, Docker consente di sfruttare efficacemente le risorse GPU del server. Utilizzando il NVIDIA Container Toolkit, i container possono accedere alle GPU dell’host, abilitando il calcolo accelerato per compiti come machine learning, deep learning inference e analisi dei dati. Questa isolamento migliora inoltre la sicurezza e la gestione delle risorse, permettendo a più applicazioni di condividere la GPU senza interferire tra loro. La distribuzione e lo scaling di applicazioni basate su GPU diventa significativamente più semplice con Docker su un server Trooper.AI.