Hoppa till huvudinnehållet
CHNEUR AB

Köra OpenShell i WSL2: Docker Desktops nätverk och NAT-läge

CHNEUR AB

Jag har på senare tid utforskat NVIDIA OpenShell. När man bygger Agent-applikationer för företag behöver man alltid hantera filbehörigheter, åtkomst till externa tjänster och API-nycklar. Tidigare har team ofta behövt sätta ihop egna lösningar. OpenShell samlar dessa funktioner i Agentens körmiljö, vilket gör det värt att prova i praktiken.

Jag följde därför den officiella guiden Run Your First Agent: startade OpenCode i en OpenShell-sandlåda och anropade en Nemotron-modell via OpenRouter.

Det officiella flödet är kort: konfigurera en provider → välj en avbildning → skapa en sandlåda och starta OpenCode. Min dator kör Windows, så jag använde WSL2 + Docker Desktop. Det som faktiskt tog tid var nätverksinställningarna och kompatibiliteten vid sandlådans start i den här miljön.

Här är de två viktigaste inställningarna från denna körning, innan vi går igenom vad respektive inställning löste:

Plats Inställning i denna körning Problem som hanterades
Docker Desktop Aktivera Enable host networking Stödja supervisorns Host-nätverksläge i denna körning och verifiera containerns åtkomst till gatewayen
.wslconfig i Windows användarkatalog Ändra networkingMode=mirrored till nat Ett fel vid seccomp-initiering i denna miljö; efter ändringen och en fullständig omstart kunde sandlådan starta

Det här är inställningar på två olika nivåer. Efter att ha aktiverat värdnätverk i Docker Desktop bekräftade vi att anslutningen fungerade, men sandlådan avslutades fortfarande. Först efter att vi fångat seccomp-loggarna och ändrat WSL:s nätverksläge kom vi in i OpenCode.

Testmiljö: WSL2, Docker Desktop 4.46.0 / Engine 28.4.0, OpenShell 0.1.5. Artikeln börjar efter installationen av OpenShell och beskriver resultaten i just denna miljö. NAT var en fungerande lösning här; det betyder inte att alla versioner kräver NAT.

Före start: anslut WSL till Docker Desktop

Gå till Settings → Resources → WSL Integration i Docker Desktop och kontrollera att integrationen är aktiverad för den Linux-distribution du använder. Det gör att Docker-klienten i WSL kan använda Docker Desktops motor. [1]

Kontrollera följande i WSL:

ps -p 1 -o comm=
docker version
openshell status

Kontrollera att PID 1 är systemd, att Docker visar både Client och Server och att OpenShell visar Connected.

Gatewayen kan behöva tio sekunder eller mer för att initieras efter start. Om en omedelbar kontroll ger Connection refused, vänta en kort stund och försök igen. Om felet kvarstår, kontrollera tjänstens loggar.

Konfigurera providern och skapa sandlådan

Följ först det officiella förfarandet. Felen som beskrivs längre fram uppstod alla efter att skapandet av sandlådan hade inletts.

Ange din egen OpenRouter-nyckel i den aktuella WSL-terminalen:

read -rsp "OpenRouter API Key: " OPENROUTER_API_KEY
echo
export OPENROUTER_API_KEY

Importera sedan profilen och skapa providern enligt det officiella exemplet:

openshell profile import \
  --url https://raw.githubusercontent.com/NVIDIA/OpenShell/main/providers/openrouter.yaml

openshell provider create \
  --name openrouter \
  --type openrouter \
  --from-existing

Vi missade också nyckeln i detta steg och fick no existing local credentials/config found. När autentiseringsuppgifterna fanns i den aktuella WSL-miljön kunde providern skapas. Att importera en profil genererar ingen API-nyckel åt dig.

Skapa därefter sandlådan med den OpenCode-avbildning som anges i den officiella guiden:

openshell sandbox create \
  --name my-agent \
  --from ghcr.io/anomalyco/opencode:latest \
  --provider openrouter \
  -- opencode -m openrouter/nvidia/nemotron-3.5-lightning:free

Vi förväntade oss att komma in i OpenCode, men fastnade här:

ControlSupervisorStartFailed:
Docker sandbox exited before supervisor became ready

Avbildningen hade hämtats, men Agenten hade ännu inte startat. Det fanns ingen anledning att ändra modellparametrarna i detta läge; nästa steg var att undersöka Docker Desktop och WSL.

Första problemet: aktivera Docker Desktops värdnätverk separat

Läs gatewayens loggar:

journalctl -b _SYSTEMD_USER_UNIT=openshell-gateway.service \
  -n 150 --no-pager -o cat

Där visas nätverksläget och gatewayadressen som supervisorn använde i denna körning:

network_mode=Host
endpoint=https://127.0.0.1:17670

Det här är lätt att missa: att en WSL-terminal kan nå gatewayen betyder inte att en Docker Desktop-container också kan göra det. WSL Integration låter dig använda Docker, men är en annan inställning än värdnätverk.

Gå till följande i Docker Desktop:

Settings → Resources → Network → markera Enable host networking → Apply and restart.

Docker Desktop har stöd för denna funktion sedan version 4.34, och den måste aktiveras i inställningarna. I denna körning användes 4.46.0. [2]

Testa inifrån en container efter att inställningen har tillämpats:

docker run --rm --network host curlimages/curl:latest \
  --noproxy '*' -vk --connect-timeout 5 --max-time 10 \
  https://127.0.0.1:17670/

Den här gången lyckades TLS-handskakningen och svaret blev:

HTTP/2 404

Ett 404-svar är acceptabelt här: gatewayens rotsökväg har ingen motsvarande resurs, men förfrågan har nått tjänsten. Kommandot använder -k enbart för att felsöka anslutningen; det bekräftar inte att certifikatvalidering eller applikationsautentisering har godkänts.

Nu hade vi bekräftat att vägen från containern till gatewayen fungerade. Men när vi skapade sandlådan igen uppstod samma startfel. Det räckte alltså inte att kontrollera nätverksanslutningen; vi behövde ta reda på varför containern avslutades.

Andra problemet: sandlådans start fastnade vid seccomp i WSL:s mirrored-läge

Vi försökte sedan hitta den misslyckade containern med docker ps -a, men den fanns inte kvar. Den hade rensats bort efter att ha avslutats, så det var för sent att läsa loggarna i efterhand.

Lösningen var att öppna två terminaler och börja fånga loggarna i förväg.

Terminal A: lyssna efter containerstarter och följ loggarna direkt:

docker events --filter type=container --filter event=start \
  --format '{{.Actor.ID}} {{index .Actor.Attributes "name"}}' |
while read -r cid cname; do
  case "$cname" in
    openshell-*)
      (
        printf '\n--- %s ---\n' "$cname"
        docker logs --timestamps --follow "$cid" 2>&1
      ) &
      ;;
  esac
done

Terminal B: kör det tidigare kommandot för att skapa sandlådan igen, men byt namnet till ett oanvänt my-agent-debug.

Den här gången fångade vi det konkreta felet:

seccomp notification probe
Resource busy (os error 16)

Problemet var inte att gatewayen var onåbar. Arbetslasten avslutades redan när sandlådans isolering initierades.

WSL var då konfigurerat med networkingMode=mirrored. Vi hittade OpenShells issue #3842, där ett liknande seccomp-fel och återhämtning efter byte till NAT beskrevs. Vi testade därför den lösningen.

Ändra .wslconfig i Windows

Filen finns här:

C:\Users\<ditt-Windows-användarnamn>\.wslconfig

Behåll befintliga inställningar för minne, CPU och annat. Ändra bara nätverksläget under [wsl2]:

[wsl2]
networkingMode=nat

Det gäller .wslconfig i Windows användarkatalog, inte /etc/wsl.conf i Linux. Om avsnittet [wsl2] redan finns, ändra motsvarande inställning där.

Spara ditt arbete och avsluta Docker Desktop. Kör sedan följande i Windows PowerShell:

wsl --shutdown

Detta stoppar de WSL-instanser som körs. Starta Docker Desktop igen, öppna WSL och kontrollera att openshell status åter visar Connected.

Skapa sandlådan igen och starta OpenCode

Kör kommandot för att skapa sandlådan igen med det nya namnet my-agent-nat och behåll övriga argument:

openshell sandbox create \
  --name my-agent-nat \
  --from ghcr.io/anomalyco/opencode:latest \
  --provider openrouter \
  -- opencode -m openrouter/nvidia/nemotron-3.5-lightning:free

Den här gången visades OpenCodes gränssnitt som förväntat. Hindret vid sandlådans start var till slut undanröjt.

Det överraskande var att en inställning som heter ”nätverksläge” löste felet vid seccomp-initiering i denna körning. Den tidigare curl-kontrollen hade redan bekräftat att gatewayen var nåbar, så båda åtgärderna bör inte förenklas till att ”nätverket inte fungerade”.

Om du också använder mirrored-läge och ser samma seccomp-fel i loggarna kan denna lösning vara värd att prova. Efter bytet till NAT bör du även kontrollera att din befintliga Windows-proxy eller andra åtkomstsätt som är beroende av mirrored-läget fortfarande fungerar.

Efter starten: kontrollera modellautentiseringen separat

När vi kommit in i OpenCode gav vårt första meddelande, ”你好” (”Hej”), ett nytt fel:

Missing Authentication header

Detta var nu ett problem med modellautentisering och behövde felsökas separat från det tidigare startfelet i WSL.

Med openshell provider list -o yaml kan du kontrollera att fält för autentiseringsuppgifter finns, men inte att den sparade nyckeln är giltig. Det är också normalt att se en platshållarnyckel i sandlådan: med denna mekanism slår OpenShell upp och ersätter autentiseringsuppgifter i HTTP-förfrågningar som uppfyller policyn. [3]

Efter att vi kontrollerat och konfigurerat rätt OpenRouter-nyckel svarade modellen normalt på kinesiska. Om du behöver uppdatera en befintlig provider kan du ange den nya nyckeln i WSL och köra:

openshell provider update openrouter --from-existing

Starta därefter en ny Agent-klientprocess så att den hämtar den uppdaterade referensen till autentiseringsuppgifterna. Att bara ändra miljövariablerna i det aktuella skalet uppdaterar inte automatiskt den sparade providern.

Kontrollpunkter efter denna körning

Till slut fungerade både sandlådans start och en modellkonversation i det officiella exemplet. När vi ser tillbaka är det framför allt tre inställningar som behöver hållas isär i denna WSL + Docker Desktop-miljö:

Inställning Syfte
WSL Integration Låta den aktuella WSL-distributionen använda Docker Desktop
Enable host networking Stödja den Host-nätverksanslutning som supervisorn använde i denna körning
WSL networkingMode=nat Hantera seccomp-startfelet som uppstod i mirrored-läge i denna körning

Efter att vi aktiverat värdnätverk och verifierat att gatewayen var nåbar kunde sandlådan fortfarande inte starta. Först efter bytet till NAT och en fullständig omstart kom vi in i OpenCode. Den ordningsföljden är mer användbar än att bara komma ihåg att ”slå på en inställning”.

Vi har ännu inte slutfört tester av verktygskörning, behörighetskontroller eller start och stopp över längre tid. Nästa steg är att ta in våra egna Agent-arbetsflöden för att verifiera åtkomst till interna tjänster och behörighetskonfiguration.

Om ditt team också håller på att driftsätta Agent-prototyper i verkliga miljöer är ni välkomna att diskutera ert konkreta scenario med CHNEUR AB.


Referenser

Boka en kostnadsfri konsultation

Diskutera era behov inom infrastruktur, cybersäkerhet, AI-agentutveckling, programvara eller data med CHNEUR. Tillsammans kan vi hitta ett konkret nästa steg.