Enhver Docker

Eksempel 1: vLLM OpenAI-kompatibel LLM-server via HF

Dette eksempel forklarer trin for trin hvordan man kører en vLLM OpenAI-kompatibelt API ved hjælp af Trooper.AI any-docker template.
Det er skrevet, så det er forståeligt, selv med minimal viden om Docker eller AI.

Denne opsætning bruger Qwen/Qwen3-4B, som er understøttet og kørbart på alle Trooper.AI GPU-servere.

Hvad denne opsætning gør

• Starter en vLLM server inde i Docker
• Indlæser modellen Qwen/Qwen3-4B fra Hugging Face
• Afslører en HTTP API, der er kompatibel med OpenAI
• Fungerer på moderne NVIDIA-drivere (CUDA 13 / 580+)

Hvorfor denne konfiguration er nødvendig

På nyere NVIDIA-drivere kan ældre vLLM Docker-billeder crashe med CUDA-fejl under opstart.
For at undgå dette, anvend 'any-docker'-skabelonen:

• Bruger vLLM natlig billede
• Tvinger Docker til at indlæse host NVIDIA driverbiblioteker

Du behøver ikke at ændre denne logik – brug blot konfigurationen nedenfor.

Skabelonvariabler

Se her som skærmbillede, hvordan du konfigurerer, og nedenfor den komplette tekst til at kopiere og indsætte.

Vigtig bemærkning om LD_LIBRARY_PATH

Denne indstilling er obligatorisk på CUDA 13 systemer.
Uden den kan vLLM muligvis fejle med at starte på grund af inkompatibilitet med NVIDIA-drivere.

Fjern det ikke.

Sådan kontrolleres det, om det virker

Kør følgende kommando:

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

Hvis du ser Qwen/Qwen3-4B i svaret kører serveren korrekt.

Eksempel på brug med 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?" }
    ]
  }'

Eksempel på brug med Node.js

Simpel forespørgsel

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);

Node.js Concurrent Load Test (16 parallelle forespørgsler)

Dette eksempel sender 16 samtidige forespørgsler til API'et og udskriver en simpel gennemløbssammendrag.

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`
);

Denne test er nyttig til:

• verificering af samtidighed
• estimering af gennemstrømning
• hurtige ydeevnetest

Hvordan får man support til vLLM GPU Server?

Ved problemer med vLLM bedes du kontakte support, vi har stor erfaring med vLLM-brug: Kontakt Support

Se vores Benchmark-sektionen for at sammenligne din vLLM-installation med vores præstationstest, med fokus på multi-konkurrence-resultater.

Bonus vedrørende vLLM-godkendelse: Sådan konfigureres og bruges API-nøgle

vLLM kører en OpenAI-kompatibelt APImen kræver som standard ikke en rigtig API-nøgle.

Du har to muligheder:

Mulighed 1: Brug en dummy-nøgle (standard, nemmest)

Hvis godkendelse er ikke håndhævet, du kan bruge enhver streng som API-nøglen.

curl

-H "Authorization: Bearer dummy-key"

Node.js

apiKey: "dummy-key"

Dette er tilstrækkeligt for de fleste interne, private eller sikrede netværksimplementeringer.

Mulighed 2: Angiv en ægte API-nøgle (anbefales til offentlige slutpunkter)

Du kan håndhæve en API-nøgle ved at indstille den som en miljøvariabel, når du starter containeren.

I enhver docker-skabelon (start_args):

--env OPENAI_API_KEY=your-secret-key

vLLM vil derefter kræver denne nøgle i enhver anmodning.

Eksempel på curl-anmodning:

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

Eksempel Node.js:

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

Sådan roterer eller ændrer du nøglen

• Opdater OPENAI_API_KEY i skabelonen
• Klik på “opdater skabelon”
• Gamle nøgler holder øjeblikkeligt op med at fungere

Opsummering

• Ingen nøgle nødvendig → brug dummy-key
• Offentligt endepunkt → indstil OPENAI_API_KEY
• Nøglen er genereres aldrig automatisk; du definerer det

Dette holder godkendelsen simpel og eksplicit.

Eksempel 2: Kørsel af Qdrant på en GPU-server

Qdrant er en højtydende vektordatabase, der understøtter lighedssøgning, semantisk søgning og embeddings i stor skala.
Når Qdrant er implementeret på en GPU-drevet Trooper.AI server, kan den indeksere og søge i millioner af vektorer ekstremt hurtigt – perfekt til RAG-systemer, LLM-hukommelse, personaliseringsmotorer og anbefalingssystemer.

Denne guide viser hvordan man kører Qdrant via Docker, hvordan det ser ud i dashboardet, og hvordan man korrekt forespørger det ved hjælp af Node.js.

Kørsel af Qdrant Docker Container

Du kan nemt køre den officielle qdrant/qdrant Docker-container med de viste indstillinger.
Disse skærmbilleder viser en typisk konfiguration, der bruges på Trooper.AI GPU-servere, inklusive:

• Eksponeret REST API port
• Adgang til dashboard
• Datapersistens
• Valgfri GPU-acceleration (hvis aktiveret i dit miljø)

Når den er startet, har du øjeblikkelig adgang til både Qdrant Dashboard og REST API REST API.

Qdrant Dashboard Forhåndsvisning

Dashboardet giver dig mulighed for at inspicere collections, vektorer, payloads og indekser.
Et typisk dashboard-setup ser således ud:

Herfra kan du:

• Opret samlinger
• Tilføj vektorer
• Kør eksempel søgninger
• Inspicer metadata
• Overvåg ydeevne

Forespørgsel af Qdrant fra Node.js

Herunder er et fungerende og rettet Node.js eksempel med Qdrant REST API.

Vigtige rettelser i forhold til det oprindelige eksempel:

• Qdrant kræver, at der kaldes et endpoint som:
  /collections/<collection_name>/points/search
• vector skal være en array, ikke (a, b, c)
• Moderne Node.js har indbygget fetch, så der er ikke behov for node-fetch

NODEJS EKSEMPEL

// 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();

Gyldig Qdrant Søgepayload

Qdrant forventer en JSON-brødtekst som denne:

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

Hvor:

• vektor → din embedding
• begrænsning → maksimalt antal returnerede resultater

Du kan også tilføje avancerede filtre om nødvendigt:

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

Bemærkninger til Trooper.AI-brugere

• Erstat AUTOMATIC-SECURE-URL.trooper.ai med dit tildelte sikre endepunkt
• Sørg for, at din samling eksisterer, før du forespørger.

Eksempel: Kørsel af N8N med Any Docker

I dette eksempel konfigurerer vi Any Docker med din konfiguration for N8N og persistent datalagring, så genstarter er mulige med intakte data. Denne konfiguration inkluderer ikke webhooks. Hvis du har brug for webhooks, skal du gå til den dedikerede forudkonfigurerede skabelon: n8n

Denne guide er kun til forklaring. Du kan starte enhver docker-container, du ønsker.

Se skærmbilleder af konfigurationen nedenfor:

Docker-kommandoen 'Under Motorhjelmen'

Denne skabelon automatiserer den komplette opsætning af en GPU-aktiveret Docker-container, inklusive installationen af alle nødvendige Ubuntu-pakker og afhængigheder for NVIDIA GPU-understøttelse. Dette forenkler processen, især for brugere, der er vant til Docker-implementeringer til webservere, hvilket ofte kræver mere kompleks konfiguration.

Følgende docker run Kommandoet genereres automatisk af skabelonen for at starte din valgte GPU-container. Det indkapsler alle de nødvendige indstillinger for optimal ydeevne og kompatibilitet med din Trooper.AI-server.

Denne kommando fungerer som et illustrativt eksempel for at give udviklere indsigt i de underliggende processer:

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

Brug ikke denne kommando manuelt, hvis du ikke er Docker-ekspert! Stol blot på skabelonen.

Hvad gør N8N muligt på den private GPU-server?

n8n oplåser potentialet til at køre komplekse workflows direkte på din Trooper.AI GPU-server. Det betyder, at du kan automatisere opgaver, der involverer billed-/videobehandling, dataanalyse, LLM-interaktioner og mere – ved at udnytte GPU'ens kraft til accelereret ydeevne.

Konkret kan du køre workflows til:

• Billed-/Videomanipulation: Automatiser ændring af størrelse, vandmærkning, objektgenkendelse og andre visuelle opgaver.
• Databehandling: Udtræk, transformer og indlæs data fra forskellige kilder.
• LLM-integration: Opret forbindelse til og interager med store sprogmodeller til opgaver som tekstgenerering, oversættelse og sentimentanalyse.
• Webautomatisering: Automatiser opgaver på tværs af forskellige hjemmesider og API'er.
• Brugerdefinerede workflows: Byg og implementer enhver automatiseret proces, der er skræddersyet til dine behov.

Husk, du skal installere AI-værktøjer som ComfyUI og Ollama for at integrere dem i dine N8N-workflows lokalt på serveren. Du skal også have tilstrækkelig GPU VRAM til at drive alle modeller. Giv ikke disse GPU'er til docker, der kører N8N.

Hvad er Docker i forhold til en GPU-server?

På en Trooper.AI GPU-server giver Docker dig mulighed for at pakke applikationer med deres afhængigheder ind i standardiserede enheder kaldet containere. Dette er særligt kraftfuldt for GPU-accelererede workloads, da det sikrer konsistens på tværs af forskellige miljøer og forenkler implementeringen. I stedet for at installere afhængigheder direkte på host-operativsystemet, inkluderer Docker-containere alt, hvad en applikation har brug for for at køre – herunder biblioteker, systemværktøjer, runtime og indstillinger.

For GPU-applikationer giver Docker dig mulighed for effektivt at udnytte serverens GPU-ressourcer. Ved at bruge NVIDIA Container Toolkit kan containere få adgang til værtsmaskinens GPU'er, hvilket muliggør accelereret computing til opgaver som machine learning, deep learning inference og dataanalyse. Denne isolation forbedrer også sikkerheden og ressourcestyringen, så flere applikationer kan dele GPU'en uden at forstyrre hinanden. Implementering og skalering af GPU-baserede applikationer bliver betydeligt lettere med Docker på en Trooper.AI-server.