Säkerhetsforskare har hittat över 135 000 OpenClaw-instanser som står helt oskyddade på internet. Många av dem var sårbara för fjärrkodexekvering. OpenClaw-säkerhetskrisen är verklig: kritiska CVE:er, skadliga färdigheter och ett grundläggande problem med hur de flesta distributioner hanterar autentisering. Att köra OpenClaw på en VPS med docker run är enkelt. Att köra det säkert är ett annat problem.

Kubernetes löser det problemet. Du får nätverksisolering, resursbegränsningar, automatiska omstarter och säkerhetsstandarder som skulle ta timmar att konfigurera för hand. Och med OpenClaw Kubernetes Operator får du allt det från en enda YAML-fil.

Den här guiden tar dig från noll till en produktionsklar OpenClaw-agent på Kubernetes. Varje YAML-block är redo att kopiera och klistra in.

Varför en operator

Att köra OpenClaw på Kubernetes är mer än en Deployment och en Service. Du behöver nätverksisolering, hemlighetshantering, persistent lagring, hälsoövervakning, konfigurationsutrullning och valfritt webbläsarautomatisering. Att koppla ihop allt det korrekt för hand är tråkigt och felbenäget.

En Kubernetes-operator kodar dessa krav i en enda anpassad resurs. Du deklarerar vad du vill, och operatorn avstämmer det kontinuerligt till rätt uppsättning Kubernetes-objekt. Det ger dig:

  • Säkerhet som standard. Varje agent körs som UID 1000, alla Linux-kapabiliteter borttagna, seccomp aktiverat, skrivskyddat rotfilsystem och en neka-som-standard NetworkPolicy som bara tillåter DNS och HTTPS utgående. Ingen manuell härdning behövs.
  • Automatiska uppdateringar med återställning. Operatorn pollar OCI-registret efter nya versioner, säkerhetskopierar arbetsytan, rullar ut uppdateringen och återställer automatiskt om den nya poden inte klarar hälsokontrollerna.
  • Konfigurationsutrullning. Ändra din spec.config.raw och operatorn detekterar att innehållshash ändrats, utlöser en rullande uppdatering. Samma sak för hemlighetsrotation.
  • Säkerhetskopiering och återställning. Automatisk säkerhetskopiering av arbetsytan till S3-kompatibel lagring vid instansborttagning. Återställ till en ny instans från vilken ögonblicksbild som helst.
  • Gateway-autentisering. Autogenererar en gateway-token per instans. Ingen manuell parkoppling, ingen mDNS (som inte fungerar i Kubernetes ändå).
  • Avvikelsedetektering. Var 5:e minut kontrollerar operatorn att varje hanterad resurs matchar önskat tillstånd. Om någon manuellt redigerar en NetworkPolicy eller tar bort en PDB, avstäms den tillbaka.

Förutsättningar

Du behöver:

  • Ett Kubernetes-kluster (1.28+). Vilken kompatibel distribution som helst fungerar: EKS, GKE, AKS, k3s eller ett lokalt Kind-kluster för testning.
  • kubectl konfigurerat att kommunicera med ditt kluster.
  • helm v3 installerat.
  • En API-nyckel för din AI-leverantör (Anthropic, OpenAI eller vilken OpenAI-kompatibel ändpunkt som helst).

Steg 1: Installera operatorn

Operatorn levereras som ett OCI Helm chart. Ett kommando installerar den:

helm install openclaw-operator \
  oci://ghcr.io/openclaw-rocks/charts/openclaw-operator \
  --namespace openclaw-operator-system \
  --create-namespace

Verifiera att den körs:

kubectl get pods -n openclaw-operator-system

Du bör se operatorpoden i tillståndet Running. Operatorn installerar också en validerings-webhook som förhindrar osäkra konfigurationer (som att köra som root).

Steg 2: Skapa din API-nyckelhemlighet

Lagra din AI-leverantörs API-nyckel i en Kubernetes Secret. Operatorn injicerar den i agentcontainern:

kubectl create namespace openclaw

kubectl create secret generic openclaw-api-keys \
  --namespace openclaw \
  --from-literal=ANTHROPIC_API_KEY=sk-ant-your-key-here

För OpenAI eller andra leverantörer, använd lämpligt miljövariabelnamn (OPENAI_API_KEY, OPENROUTER_API_KEY osv.). Du kan inkludera flera leverantörer i samma Secret.

Tips: För produktion, överväg att använda External Secrets Operator för att synkronisera nycklar från AWS Secrets Manager, HashiCorp Vault, GCP Secret Manager eller Azure Key Vault. Operatorns dokumentation har detaljerade exempel.

Steg 3: Distribuera din första agent

Skapa en fil som heter my-agent.yaml:

apiVersion: openclaw.rocks/v1alpha1
kind: OpenClawInstance
metadata:
  name: my-agent
  namespace: openclaw
spec:
  envFrom:
    - secretRef:
        name: openclaw-api-keys
  config:
    raw:
      agents:
        defaults:
          model:
            primary: "anthropic/claude-sonnet-4-20250514"
  storage:
    persistence:
      enabled: true
      size: 10Gi

Applicera den:

kubectl apply -f my-agent.yaml

Den enda resursen skapar en StatefulSet, Service, ServiceAccount, Role, RoleBinding, ConfigMap, PVC, PDB, NetworkPolicy och en gateway-token Secret. Operatorn avstämmer allt.

Steg 4: Verifiera att den körs

Observera instansen som startar:

kubectl get openclawinstances -n openclaw -w

NAME       PHASE        READY   AGE
my-agent   Provisioning False   10s
my-agent   Running      True    45s

När fasen visar Running och Ready är True är din agent live. Kontrollera loggarna:

kubectl logs -n openclaw statefulset/my-agent -f

För att interagera med din agent, port-forward gatewayen:

kubectl port-forward -n openclaw svc/my-agent 18789:18789

Öppna sedan http://localhost:18789 i din webbläsare.

Steg 5: Anslut en kanal

OpenClaw stöder Telegram, Discord, WhatsApp, Signal och andra meddelandekanaler. Varje kanal konfigureras genom miljövariabler. Lägg till relevant token i din Secret:

kubectl create secret generic openclaw-channel-keys \
  --namespace openclaw \
  --from-literal=TELEGRAM_BOT_TOKEN=your-bot-token-here

Referera sedan till den i din instans:

spec:
  envFrom:
    - secretRef:
        name: openclaw-api-keys
    - secretRef:
        name: openclaw-channel-keys

OpenClaw auto-detekterar token och aktiverar kanalen. Ingen ytterligare konfiguration behövs.

Det täcker grunderna. Din agent körs, är säkrad och nåbar. Resten av guiden täcker valfria funktioner du kan aktivera när du är redo.

Webbläsarautomatisering

OpenClaw kan surfa på webben, ta skärmbilder och interagera med sidor. Operatorn gör detta till ett tillägg på en rad. Den kör en härdad Chromium-sidvagn i samma pod, ansluten via localhost:

spec:
  chromium:
    enabled: true
    resources:
      requests:
        cpu: 500m
        memory: 1Gi
      limits:
        cpu: 1000m
        memory: 2Gi

Operatorn injicerar automatiskt en CHROMIUM_URL-miljövariabel i huvudcontainern. Sidvagnscontainern körs som UID 1001 med ett skrivskyddat rotfilsystem och sin egen säkerhetskontext.

Färdigheter och körtidsberoenden

OpenClaw-färdigheter från ClawHub kan installeras deklarativt. Operatorn kör en init-container som hämtar varje färdighet innan agenten startar:

spec:
  skills:
    - "@anthropic/mcp-server-fetch"
    - "@anthropic/mcp-server-filesystem"

Om dina färdigheter eller MCP-servrar behöver pnpm eller Python, aktivera de inbyggda körtidsberoendecontainrarna:

spec:
  runtimeDeps:
    pnpm: true    # Installs pnpm via corepack
    python: true  # Installs Python 3.12 + uv

Init-containrarna installerar dessa verktyg på data-PVC:n, så de persisterar mellan omstarter utan att göra containeravbilden större.

Automatiska uppdateringar

OpenClaw släpper nya versioner frekvent. Operatorn kan följa dessa automatiskt, säkerhetskopiera före uppdatering och återställa om något går fel:

spec:
  autoUpdate:
    enabled: true
    checkInterval: "12h"
    backupBeforeUpdate: true
    rollbackOnFailure: true
    healthCheckTimeout: "10m"

När en ny version dyker upp i registret:

  1. Skapar operatorn en säkerhetskopia av arbetsytans PVC till S3-kompatibel lagring
  2. Uppdaterar avbildningstaggen på StatefulSet
  3. Väntar upp till healthCheckTimeout på att poden ska klara beredskapskontrollerna
  4. Om poden inte blir redo, återställer den föregående avbildningstaggen och säkerhetskopian

Efter 3 på varandra följande misslyckade återställningar pausar operatorn automatisk uppdatering och sätter ett villkor så du kan undersöka.

Notering: Automatisk uppdatering gör ingenting för digest-fästa avbildningar (spec.image.digest). Om du fäster med digest kontrollerar du uppdateringar manuellt.

Produktionshärdning

Operatorn levereras säker som standard. Här är ytterligare inställningar för produktionsdistributioner.

Övervakning med Prometheus

Aktivera ServiceMonitor för att skrapa operator- och instansmetriker:

spec:
  observability:
    metrics:
      enabled: true
      serviceMonitor:
        enabled: true
        interval: "30s"

Operatorn exponerar openclaw_reconcile_total, openclaw_reconcile_duration_seconds, openclaw_instance_phase och räknare för automatiska uppdateringar.

Schemalägg på dedikerade noder

Om du kör ett blandat kluster, använd nodeSelector och tolerations för att fästa agenter på dedikerade noder:

spec:
  availability:
    nodeSelector:
      openclaw.rocks/nodepool: openclaw
    tolerations:
      - key: openclaw.rocks/dedicated
        value: openclaw
        effect: NoSchedule

Lägg till anpassade utgående regler

Standard-NetworkPolicy tillåter bara DNS (port 53) och HTTPS (port 443). Om din agent behöver nå andra tjänster (en databas, en meddelandekö, ett internt API), lägg till utgående regler:

spec:
  security:
    networkPolicy:
      additionalEgress:
        - to:
            - ipBlock:
                cidr: 10.0.0.0/8
          ports:
            - port: 5432
              protocol: TCP

Molnleverantörsidentitet

För AWS IRSA eller GCP Workload Identity, annotera det hanterade ServiceAccount:

spec:
  security:
    rbac:
      serviceAccountAnnotations:
        eks.amazonaws.com/role-arn: "arn:aws:iam::123456789:role/openclaw"

Företagsproxyer och privata CA:er

Om ditt kluster använder en TLS-avlyssnande proxy, injicera ett CA-paket:

spec:
  security:
    caBundle:
      configMapName: corporate-ca-bundle
      key: ca-bundle.crt

Operatorn monterar CA-paketet i alla containrar och sätter NODE_EXTRA_CA_CERTS automatiskt.

GitOps

OpenClawInstance CRD är en vanlig YAML-fil. Det innebär att den passar direkt in i ett GitOps-arbetsflöde. Lagra dina agentmanifest i ett git-repo och låt ArgoCD eller Flux synkronisera dem till ditt kluster.

En typisk repostruktur:

gitops/
└── agents/
    ├── kustomization.yaml
    ├── namespace.yaml
    ├── agent-a.yaml
    └── agent-b.yaml

Varje ändring går genom en pull request. Ditt team granskar diffen. Merga till main och ArgoCD applicerar den. Inga kubectl apply från laptops, ingen konfigurationsavvikelse, fullständig revisionskedja.

Operatorns konfigurationshashning gör detta extra smidigt. När ArgoCD synkroniserar en ändrad spec.config.raw detekterar operatorn att innehållshash ändrats och utlöser en rullande uppdatering automatiskt. Samma sak för hemlighetsrotation: operatorn bevakar refererade hemligheter och startar om pods när de ändras.

Säkerhetskopiering och återställning

Operatorn stöder S3-kompatibla säkerhetskopior. När du tar bort en instans skapar operatorn automatiskt en säkerhetskopia av arbetsytans PVC innan den tas ned.

För att återställa en agent från en säkerhetskopia till en ny instans:

apiVersion: openclaw.rocks/v1alpha1
kind: OpenClawInstance
metadata:
  name: my-agent-restored
  namespace: openclaw
spec:
  restoreFrom: "s3://bucket/path/to/backup.tar.gz"
  envFrom:
    - secretRef:
        name: openclaw-api-keys
  storage:
    persistence:
      enabled: true
      size: 10Gi

Operatorn laddar ner ögonblicksbilden, packar upp den i PVC:n och startar agenten med all tidigare arbetsytedata, färdigheter och konversationshistorik intakt.

Lokal inferens med Ollama

Om du vill att agenter ska använda lokala modeller (för integritet, latens eller kostnad) har operatorn förstklassigt Ollama-stöd. Ingen sidvagn att koppla för hand. spec.ollama hanterar containern, modell-förhämtning, lagring och GPU-allokering:

spec:
  ollama:
    enabled: true
    models:
      - "llama3.2"
      - "nomic-embed-text"
    gpu: 1
    resources:
      requests:
        cpu: "2"
        memory: 4Gi
      limits:
        cpu: "4"
        memory: 8Gi
    storage:
      sizeLimit: 30Gi

När aktiverat:

  1. Lägger operatorn till en Ollama-sidvagnscontainer i poden
  2. Kör en init-container som förhämtar de listade modellerna innan agenten startar
  3. Injicerar OLLAMA_HOST=http://localhost:11434 i huvudcontainern
  4. Allokerar den begärda NVIDIA GPU:n via nvidia.com/gpu resursbegränsningar

Som standard lagras modeller i en emptyDir-volym med en konfigurerbar storleksgräns. För persistent modelllagring mellan omstarter (så modeller inte hämtas om varje gång), använd en befintlig PVC:

spec:
  ollama:
    enabled: true
    models: ["llama3.2"]
    storage:
      existingClaim: ollama-models-pvc

Tailscale-integration

Exponera din agent för ditt tailnet utan Ingress, lastbalanserare eller publika IP-adresser. Operatorns spec.tailscale-fält hanterar autentiseringsnyckelsinjicering, konfigurationsberikande och NetworkPolicy-regler:

spec:
  tailscale:
    enabled: true
    mode: serve       # or "funnel" for public internet access
    authKeySecretRef:
      name: tailscale-authkey
    hostname: my-agent

Skapa autentiseringsnyckelhemligheten med en efemär, återanvändbar nyckel från Tailscale-administratörskonsolen:

kubectl create secret generic tailscale-authkey \
  --namespace openclaw \
  --from-literal=authkey=tskey-auth-...

I serve-läge (standard) kan bara medlemmar i ditt tailnet nå agenten. I funnel-läge exponerar Tailscale den för det publika internet med automatisk HTTPS.

Operatorn:

  • Injicerar miljövariablerna TS_AUTHKEY och TS_HOSTNAME
  • Slår ihop gateway.tailscale.mode och gateway.tailscale.resetOnExit i OpenClaw-konfigurationen
  • Lägger till STUN- och WireGuard-utgående regler i NetworkPolicy

För lösenordsfri SSO-inloggning för tailnet-medlemmar, aktivera authSSO:

spec:
  tailscale:
    enabled: true
    mode: serve
    authKeySecretRef:
      name: tailscale-authkey
    authSSO: true

Detta sätter gateway.auth.allowTailscale=true i OpenClaw-konfigurationen, så tailnet-medlemmar kan komma åt agenten utan en separat gateway-token.

Anpassade sidvagnar och init-containrar

För användningsfall bortom det inbyggda Ollama- och Tailscale-stödet accepterar operatorn godtyckliga sidvagnar och init-containrar. Kör en Cloud SQL Proxy för databasåtkomst, en logg-vidarebefordrare eller vilken annan hjälpare som helst bredvid din agent:

spec:
  sidecars:
    - name: cloudsql-proxy
      image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:2
      args: ["--structured-logs", "project:region:instance"]
      resources:
        requests:
          cpu: 100m
          memory: 128Mi

Anpassade init-containrar körs efter operatorns egna init-pipeline (konfigurationssådd, pnpm, Python, färdigheter):

spec:
  initContainers:
    - name: fetch-data
      image: curlimages/curl:8.5.0
      command: ["sh", "-c", "curl -o /data/dataset.json https://..."]
      volumeMounts:
        - name: data
          mountPath: /data

Konfigurationssammanfogningsläge

Som standard skriver operatorn över konfigurationsfilen vid varje podomstart. Om din agent modifierar sin egen konfiguration vid körning (genom färdigheter eller själv-modifiering), sätt mergeMode: merge för djup sammanfogning av operatorkonfiguration med befintlig PVC-konfiguration:

spec:
  config:
    mergeMode: merge
    raw:
      agents:
        defaults:
          model:
            primary: "anthropic/claude-sonnet-4-20250514"

I sammanfogningsläge vinner operator-specificerade nycklar, men nycklar agenten lade till på egen hand överlever omstarter.

Det kompletta exemplet

Här är ett produktionsklart manifest som kombinerar allt från denna guide:

apiVersion: openclaw.rocks/v1alpha1
kind: OpenClawInstance
metadata:
  name: production-agent
  namespace: openclaw
spec:
  envFrom:
    - secretRef:
        name: openclaw-api-keys

  config:
    mergeMode: merge
    raw:
      agents:
        defaults:
          model:
            primary: "anthropic/claude-sonnet-4-20250514"

  skills:
    - "@anthropic/mcp-server-fetch"

  runtimeDeps:
    pnpm: true

  chromium:
    enabled: true
    resources:
      requests:
        cpu: 500m
        memory: 1Gi
      limits:
        cpu: 1000m
        memory: 2Gi

  ollama:
    enabled: true
    models: ["llama3.2"]
    gpu: 1
    resources:
      requests:
        cpu: "2"
        memory: 4Gi

  tailscale:
    enabled: true
    mode: serve
    authKeySecretRef:
      name: tailscale-authkey
    authSSO: true

  resources:
    requests:
      cpu: 500m
      memory: 1Gi
    limits:
      cpu: 2000m
      memory: 4Gi

  storage:
    persistence:
      enabled: true
      size: 10Gi

  autoUpdate:
    enabled: true
    checkInterval: "24h"
    backupBeforeUpdate: true
    rollbackOnFailure: true

  observability:
    metrics:
      enabled: true
      serviceMonitor:
        enabled: true

  # Remove or adjust these if you don't use dedicated nodes
  availability:
    nodeSelector:
      openclaw.rocks/nodepool: openclaw
    tolerations:
      - key: openclaw.rocks/dedicated
        value: openclaw
        effect: NoSchedule

Applicera det och du har en härdad, automatiskt uppdaterande, webbläsarkapabel AI-agent med lokal inferens, tailnet-åtkomst, övervakning, säkerhetskopior och nätverksisolering. Ett kubectl apply.

Vad du får direkt

Utan att röra en enda säkerhetsinställning levereras varje agent som distribuerats av operatorn med:

  • Icke-root-exekvering (UID 1000)
  • Skrivskyddat rotfilsystem
  • Alla Linux-kapabiliteter borttagna
  • Seccomp RuntimeDefault-profil
  • Neka-som-standard NetworkPolicy (bara DNS + HTTPS utgående)
  • Instansspecifikt ServiceAccount utan automatisk token-montering
  • PodDisruptionBudget
  • Levnads-, beredskaps- och startprober
  • Automatiskt genererad gateway-autentiseringstoken
  • 5 minuters avvikelseavstämning

En validerings-webhook blockerar försök att köra som root och varnar om inaktiverade NetworkPolicies, saknad TLS på Ingress och oupptäckta AI-leverantörsnycklar.

Nästa steg

Om du stöter på problem eller har feedback, öppna ett ärende på GitHub. Pull requests är också välkomna.

Om du inte vill hantera Kubernetes själv hanterar OpenClaw.rocks allt detta åt dig. Välj en plan, anslut en kanal och din agent är live på sekunder.