SSD Nodes Learn Hosting plans →
Gidsen Matt ConnorDoor Matt Connor · Bijgewerkt 2026-10-23

Dormice self-hosted agent sandbox installeren

Dormice biedt een E2B-compatibele sandbox voor het veilig uitvoeren van agent-code op uw eigen VPS. Leer hoe u de daemon installeert en code isoleert in een container.

Wat Dormice is, en wat het niet is

Dormice is een self-hosted agent sandbox: één daemon op een Linux VPS in uw beheer, die door uw agent-code via HTTP wordt aangeroepen om niet-vertrouwde code uit te voeren in een geïsoleerde container. Uw programma vraagt om een sandbox op naam, krijgt dezelfde sandbox terug ongeacht de status, voert daarin een commando uit en leest de output. De sandbox is een programmatische resource, geen machine waarop u inlogt.

Dit verschilt van het toewijzen van een volledige computer aan een agent. Een wegwerp-VM voor een coding agent is een omgeving waar u via SSH op inlogt, de agent laat experimenteren en die u vervolgens verwijdert. Dormice bevindt zich een niveau lager: het is de execution API die uw programma aanroept wanneer het al over code beschikt en een veilige plek nodig heeft om deze uit te voeren. Gebruik de wegwerp-VM wanneer een volledige machine de werkeenheid is. Gebruik Dormice wanneer een enkele exec-aanroep de werkeenheid is en u er honderd per dag wilt uitvoeren zonder honderd VM's te beheren.

Het project noemt zichzelf E2B-compatibel. E2B is een gehoste sandbox-dienst waarvan de client library door veel agent-frameworks al wordt geïmporteerd. Dormice bedient hetzelfde protocol onder zijn eigen URL-prefixen, waardoor een applicatie die is geschreven voor het officiële e2b-pakket blijft werken wanneer u deze naar uw eigen server wijst. De applicatiecode verandert niet. Slechts twee URL's en een API-key-prefix worden aangepast.

Wat "de SQLite van agent-sandboxen" in de praktijk betekent

SQLite is een database die u in een applicatie integreert, in plaats van een service die u beheert. Dormice gebruikt die vergelijking rechtstreeks. Er draait één daemon per machine en er is één SQLite-bestand voor de administratie en één TCP-poort. Daarnaast wordt een kleine gateway geïnstalleerd die de webconsole beschikbaar maakt. Kubernetes en een externe databaseserver zijn niet nodig. De daemon verkrijgt een exclusieve lock naast het administratiebestand. Een tweede daemon op dezelfde machine weigert daardoor te starten, in plaats van de status ongemerkt op te splitsen. Elke sandbox blijft op de machine waarop deze is aangemaakt. In de README wordt een fleet nu beschreven als één gateway plus de machines op het privénetwerk daarvan. Er staat echter nog steeds dat u iets anders moet kiezen als u sandboxen nodig hebt die tussen machines kunnen worden verplaatst of een fleet over meerdere regio's wilt beheren. Lees die documentatie aandachtig.

Het tweede deel van het concept gaat over kosten. Bij een gehoste sandbox betaalt u voor elke seconde dat deze bestaat. Gehoste sandboxen zijn daarom standaard tijdelijk. Dormice draait op hardware waarvoor u al betaalt. De sandboxen zijn daardoor permanent en worden goedkoper naarmate ze langer ongebruikt blijven. Een sandbox gaat stapsgewijs naar een lagere status: actief, vervolgens bevroren, daarna gestopt en ten slotte gearchiveerd. Met elke acquire wordt de sandbox weer geactiveerd vanaf de status waarin deze zich bevindt.

Vooral het bevriezen is belangrijk om te begrijpen. Daardoor kunt u de sandbox van elke agent permanent behouden zonder dat dit onbetaalbaar wordt. Dit zijn de door het project gepubliceerde cijfers. Ze zijn gemeten op de hardware van het project en niet op die van u.

GrafiekOne idle sandbox before and after freezing, figures published by the project
De gegevens achter deze grafiek
[
  {
    "label": "Active, holding 1 GiB",
    "resident_memory_mib": 1024,
    "wake_ms": 0
  },
  {
    "label": "Frozen",
    "resident_memory_mib": 5,
    "wake_ms": 50
  }
]

Een inactieve sandbox die 1024 MiB geheugen gebruikt, gebruikt na het bevriezen nog 5 MiB resident geheugen en wordt in ongeveer 50 ms weer actief. Processen worden op hun huidige positie gepauzeerd en hervat. Een langdurig actieve agent behoudt daardoor de shellstatus en onafgemaakte werkzaamheden tijdens het bevriezen. Reproduceer dit eerst op uw eigen host voordat u hierop capaciteitsplannen baseert.

Wat de host nodig heeft voordat u installeert

De host draait Ubuntu of Debian op x86_64 en het installatieprogramma heeft root nodig. De daemon blijft tijdens runtime onder root draaien, omdat deze loop mounts uitvoert en cgroups schrijft.

Sandboxes draaien onder Docker met gVisor (een container runtime die een kernel in userspace tussen de container en de hostkernel plaatst). Deze levert de runsc-runtime die elke sandbox gebruikt. De daemon draait met Node 22 of nieuwer. Als Node op uw systeem al versie 22 of nieuwer is, gebruikt het installatieprogramma die versie opnieuw. Alleen als Node ontbreekt of ouder is, downloadt het installatieprogramma een eigen vastgezette kopie, controleert het de checksum en pakt het deze uit onder /opt.

Er moet swap aanwezig zijn en vm.swappiness moet 100 zijn. Dit is geen advies voor tuning, maar een functionele vereiste. Freezing werkt door het geheugen van een inactieve sandbox naar swap te verplaatsen. gVisor houdt sandboxgeheugen bij als shared memory, en de kernel wisselt shared memory niet naar swap bij de standaardwaarde voor swappiness. Het project mat dat bij de standaardwaarde 0 bytes werd vrijgegeven en bij 100 99.5 procent. Controleer welke waarde de kernel daadwerkelijk gebruikt, omdat sommige cloudimages vm.swappiness = 0 leveren in een bestand dat u waarschijnlijk nooit zou controleren.

sysctl vm.swappiness
swapon --show

sysctl vm.swappiness moet vm.swappiness = 100 afdrukken en swapon --show moet een swapfile tonen. Als swappiness 0 afdrukt, doet elke freeze niets en blijft u voor elke inactieve sandbox het volledige geheugen betalen.

Dormice installeren op Ubuntu

De gedocumenteerde installatie bestaat uit één pipe naar bash:

curl -fsSL https://raw.githubusercontent.com/BitMiracle-AI/Dormice/main/deploy/install.sh | bash

Haal het script op en lees het voordat u het uitvoert. Het script wordt uitgevoerd als root en wijzigt uw host: het installeert Docker als dat ontbreekt, downloadt gVisor en Caddy met checksumverificatie, maakt een swapfile als de host geen swap heeft, schrijft systemd-units voor de daemon, de gateway en een imageregister, en voegt firewallregels toe.

curl -fsSL https://raw.githubusercontent.com/BitMiracle-AI/Dormice/main/deploy/install.sh -o dormice-install.sh
less dormice-install.sh
sudo bash dormice-install.sh --swap-gb 8

Met --swap-gb stelt u de grootte van de swapfile in. De standaardwaarde is 16, wat op een kleine VPS veel schijfruimte inneemt. Met --mirror cn schakelt u de downloads over naar mirrors die vanaf het Chinese vasteland bereikbaar zijn. Als u het installatieprogramma opnieuw uitvoert, worden de code bijgewerkt en afwijkingen hersteld. Uw API-token wordt daarbij nooit vervangen.

De code komt in /opt/dormice, de configuratie in /etc/dormice/env (en de gatewayconfiguratie in /etc/dormice/gateway.env), de sandboxgegevens in /var/lib/dormice en de opdrachten dormice en dor in /usr/local/bin. Het installatieprogramma genereert tijdens de installatie het API-token en schrijft dit met mode 600 naar /etc/dormice/env. Dezelfde waarde wordt naar het bestand van de gateway geschreven.

Er is geen getagde release waarop u de installatie kunt vastzetten. Op 12 oktober 2026 bevat de repository geen git-tags en zijn er geen GitHub-releases. Het installatieprogramma clonet daarom main, waardoor u de code krijgt die die ochtend is toegevoegd. Een versie vastzetten betekent daarom dat u de commit noteert die daadwerkelijk is geïnstalleerd.

git -C /opt/dormice rev-parse HEAD

Sla deze hash op bij uw deploynotities. Daarmee kunt u exact bepalen welke code u uitvoert. De hash biedt op zichzelf geen herstelmogelijkheid: de nieuwe processen voeren tijdens het opstarten databasemigraties uit, en volgens de upgradedocumentatie wordt een migratie niet teruggedraaid door een ouder installatieprogramma opnieuw uit te voeren. Voordat er iets wordt herstart, slaat het installatieprogramma snapshots van beide databases op in /var/lib/dormice/backups/ en bewaart het de drie meest recente. Deze snapshots zijn de gedocumenteerde herstelmogelijkheid na een mislukte upgrade. Kopieer daarom de nieuwste snapshot van de host voordat u opnieuw upgradet.

Het installatieprogramma eindigt met dor doctor. Dit is een alleen-lezencontrole van de host die echte gVisor-containers opstart om te controleren of de runtime werkt, in plaats van alleen op een pakketlijst te vertrouwen. Voer deze controle opnieuw uit wanneer de daemon zich afwijkend gedraagt.

sudo dor doctor
systemctl is-active dormice

systemctl is-active dormice moet active afdrukken. Als de uitvoer failed is, staat de reden in journalctl -u dormice -n 50. Een mislukte start wordt meestal veroorzaakt door de swap- of gVisor-vereiste en niet door de daemon zelf.

Het installatieprogramma installeert ook Caddy op de host. Controleer daarom welke services luisteren voordat u ervan uitgaat dat de firewallconfiguratie voltooid is.

sudo ss -lntp

De daemon bindt altijd aan 127.0.0.1. Er is bewust geen instelling om dat adres te wijzigen. Alleen de poort kan veranderen: DORMICE_PORT heeft standaard de waarde 3676. De gateway ernaast volgt dezelfde regel voor 127.0.0.1:3677, met DORMICE_GATEWAY_PORT als poort en bewust zonder hostinstelling. Verbinding maken met een van beide vanaf uw laptop is een bewuste handeling. De eenvoudigste optie is een SSH-tunnel die beide poorten doorstuurt.

ssh -L 3676:127.0.0.1:3676 -L 3677:127.0.0.1:3677 root@your-server

Wanneer de tunnel actief is, is http://127.0.0.1:3677/console op uw laptop de webconsole die door de gateway wordt aangeboden. Bij uw eerste bezoek bewijst u dat u de beheerder bent door het API-token eenmaal te plakken. Daarna stelt u een gebruikersnaam en wachtwoord voor de console in. Bij het aanmelden wordt een httpOnly-sessiecookie ingesteld die 7 dagen geldig is en die niet door JavaScript in de pagina kan worden gelezen. De console toont het token nooit opnieuw. Op de pagina Connect worden clientfragmenten voor kopiëren en plakken weergegeven die al naar uw eigen endpoint verwijzen.

Een sandbox maken en daarin code uitvoeren

Met één bewerking maakt u een sandbox: acquire. Deze bewerking is idempotent. Dezelfde sleutel levert dus altijd dezelfde sandbox op. De sandbox wordt indien nodig gemaakt, gewekt, gestart of hersteld. Elk ander werkwoord retourneert 404 voor een sleutel die het nog niet eerder heeft gezien. De dor CLI heeft geen werkwoord acquire. Uw eerste sandbox maakt u daarom via de console of een clientbibliotheek.

De route via de console is het snelst. Open /console via de tunnel en maak een sandbox met de naam my-agent. Daarna werkt de CLI ermee.

sudo grep DORMICE_API_TOKEN /etc/dormice/env
export DORMICE_ENDPOINT=http://127.0.0.1:3676
export DORMICE_API_TOKEN=paste-the-value-here
dor sandbox ls
dor sandbox exec my-agent 'python3 --version'

Met dor sandbox ls geeft u elke sandbox met de lifecycle-status weer. Zo kunt u volgen hoe een sandbox van active naar frozen gaat. dor sandbox exec geeft een Python 3.12-versie weer, omdat de standaardimage Ubuntu 24.04 bevat, met Python 3.12, Node 24, git en ripgrep al geïnstalleerd. Een authenticatiefout betekent daarentegen dat de regel met het token ook de naam van de variabele bevatte.

Bestanden verplaatst u met dor sandbox push my-agent ./script.py. Het bestand komt dan terecht op /home/user/script.py. Met dor sandbox pull my-agent notes.txt haalt u een bestand terug. De native bestandsbewerkingen beperken elk bestand tot 16 MiB. De bestandsinterface van E2B streamt bestanden en laat alleen het schijfquotum van de sandbox als limiet gelden.

Vernietigen is de enige bewerking waarbij gegevens verloren gaan. dor sandbox destroy my-agent verwijdert de sandbox en is idempotent. Het hoofdbestand README, de meegeleverde agent skill en het README-bestand van het CLI-pakket documenteren dit allemaal onder die ene naam. Voer toch dor sandbox --help uit op uw eigen build, omdat het installatieprogramma main volgt en de CLI voortdurend wordt uitgebreid.

Richt uw bestaande E2B-code op uw eigen server

Dit is de reden waarom dit relevant is. Het officiële e2b-pakket van npm communiceert in ongewijzigde vorm met Dormice. Voer dit uit vanaf uw laptop terwijl de SSH-tunnel openstaat, zodat er geen nieuwe services op de server luisteren.

npm init -y
npm i e2b tsx
import { Sandbox } from 'e2b';

const sbx = await Sandbox.create({
  apiKey: `e2b_${process.env.DORMICE_API_TOKEN}`,
  apiUrl: 'http://127.0.0.1:3676/e2b/api',
  sandboxUrl: 'http://127.0.0.1:3676/e2b/envd',
});

const result = await sbx.commands.run('python3 -c "print(6 * 7)"');
console.log(result.exitCode, result.stdout);

await sbx.kill();
DORMICE_API_TOKEN=paste-the-value-here npx tsx index.ts

Een geslaagde uitvoering geeft exitcode 0 en 42 terug. De API-sleutel is uw Dormice-token met een e2b_-prefix ervoor; dit is de indeling die de compatibiliteitslaag verwacht.

De compatibiliteit is geen beperkte implementatie. Het streamen van stdout en stderr, achtergrondcommando's, een interactieve PTY, ondertekende upload- en download-URL's, directory-monitoring en een poort-proxy worden allemaal via het officiële pakket getest tegen een echte Docker- en gVisor-daemon door de end-to-end testsuite van het project. Enkele verschillen zijn van belang voordat u productieomgevingen migreert:

  • Template-builds zijn niet geïmplementeerd. Een template is een Docker-image die u zelf bouwt en registreert met dor template add, waarna Sandbox.create('name') deze omzet. Een niet-geregistreerde naam geeft een 404-foutmelding in plaats van een gesimuleerd resultaat.
  • Sandboxes die via het E2B-oppervlak worden aangemaakt, krijgen echte deadlines, omdat de E2B-semantiek dit vereist. Er worden nooit deadlines opgelegd aan sandboxes die via de native API worden aangemaakt.
  • Een bevroren sandbox behoudt zijn processen en hervat deze op het punt waar ze waren gebleven; pauzeren en hervatten is hier dus niet de stop- en koudestart-procedure die u wellicht gewend bent.

Wat de sandbox tegenhoudt en wat niet

gVisor onderschept de systeemaanroepen van de container in userspace en handelt deze zelf af. Code in de sandbox praat daardoor niet rechtstreeks met de kernel van uw host. Binnen de sandbox worden opdrachten uitgevoerd als user (uid 1000). Dat account heeft echter wachtwoordloze sudo. Root binnen de sandbox is daardoor beschikbaar voor elke code die daarom vraagt. Beschouw de uid niet als beveiliging. Het project stelt duidelijk dat de beveiligingsgrens bij gVisor ligt, niet bij de uid. Ook een sandbox die zichzelf hogere rechten geeft, kan de kernel van de host niet bereiken. Daarmee is het normale geval afgedekt: een gegenereerd script dat rm -rf / uitvoert, de schijf vult of processen blijft forken totdat er iets uitvalt, beschadigt alleen de eigen sandbox en stopt daar.

Hieronder staat wat het niet tegenhoudt. Daarvoor bent u zelf verantwoordelijk.

  • Een sandbox heeft werkende uitgaande netwerkverbindingen. Gegenereerde code kan alles downloaden en alles wat zij aantreft versturen. De netwerkbeveiliging van het installatieprogramma dekt twee specifieke zaken af: containerverkeer naar de cloudmetadataservice op 169.254.0.0/16 en op 100.100.100.200 wordt geblokkeerd. Dat laatste is het adres dat Alibaba Cloud gebruikt. Via deze adressen verstrekt een cloudprovider instance-credentials aan alles wat erbij kan. Daarnaast schakelt het installatieprogramma container-naar-containerverkeer uit met "icc": false in Docker's daemon.json. Verder wordt niets geblokkeerd. Lees sudo iptables -S DOCKER-USER en voeg uw eigen DROP-regels toe voor de privéadresbereiken die een sandbox niet mag bereiken.
  • Docker plaatst eigen regels vóór uw firewallregels. Daardoor kan een gepubliceerde containerpoort vanaf internet antwoorden terwijl ufw aangeeft dat de poort gesloten is. Lees hoe Docker poorten publiceert buiten ufw om en de basisprincipes van ufw voor een VPS voordat u iets op deze host beschikbaar maakt.
  • gVisor is een kernel in userspace en geen hypervisor. Dat is een bewuste afweging. Bevriezen vereist namelijk dat sandboxes processen zijn. Als KVM vereist zou zijn, zou installatie op veel systemen niet mogelijk zijn. Als uw dreigingsmodel hardwarevirtualisatie vereist, gebruik dan isolatie van de klasse Firecracker en accepteer de operationele kosten die daarbij horen.
  • Het API-token vormt aan de clientzijde de volledige beveiligingsgrens. Alles wat DORMICE_API_TOKEN bevat, kan elke sandbox op de machine maken, lezen en verwijderen. Geef het agentproces een eigen gebruiker met minimale rechten op de VPS en behandel het token zoals u een SSH-sleutel behandelt. De werkwijzen uit Claude Code veilig uitvoeren op een VPS zijn rechtstreeks van toepassing.

De daemon zelf draait als root op uw host. gVisor beschermt de host tegen code in een sandbox. Niets beschermt de host tegen de daemon of tegen iemand die het token bezit. De machine waarop Dormice draait, moet daarom uitsluitend daarvoor worden gebruikt. Als uw agent ook tools via MCP (model context protocol) benadert, houd die MCP-servers op een afzonderlijke VPS om dezelfde reden.

Hoeveel sandboxes passen er in 4 GB en 8 GB?

Twee factoren verbruiken geheugen: de basisbezetting van de host zelf en de actieve werkset van elke sandbox die op dat moment is ingeschakeld. Reserveer ongeveer 1 GB voor Ubuntu, Docker en de daemon, en deel de resterende ruimte door het werkelijke verbruik van één sandbox. Een sandbox die een Python-script uitvoert dat enkele bestanden leest, verbruikt ongeveer 200 tot 300 MiB. Een sandbox die een compiler of een volledige testsuite draait, kan meer dan een gibibyte in beslag nemen.

GrafiekConcurrent sandboxes by host RAM, arithmetic after a 1 GB host reserve
De gegevens achter deze grafiek
[
  {
    "host": "4 GB VPS",
    "active_at_512_mib": 6,
    "active_at_1_gib": 3,
    "frozen_on_16gb_swap": 16
  },
  {
    "host": "8 GB VPS",
    "active_at_512_mib": 14,
    "active_at_1_gib": 7,
    "frozen_on_16gb_swap": 16
  }
]

Een VPS met 4 GB RAM kan ongeveer 6 sandboxes tegelijkertijd actief houden als elke sandbox 512 MiB verbruikt, of 3 als elke sandbox een volledige gibibyte verbruikt. Een VPS met 8 GB RAM verhoogt dit aantal naar 14 en 7. Dit zijn bovengrenzen voor gelijktijdig werk en het betreft een rekenkundige benadering in plaats van een benchmark; houd daarom free -m in de gaten terwijl uw eigen belasting draait.

Bevroren sandboxes worden beperkt door swap in plaats van RAM, wat het kernpunt van dit ontwerp is. Een bevroren sandbox die een gibibyte in gebruik had, houdt ongeveer die hoeveelheid in de swap vast en verbruikt vrijwel geen residentieel geheugen. Het standaard swapbestand van 16 GB van het installatieprogramma biedt daarom ruimte aan ongeveer 16 van deze sandboxes. Zodra dit limiet is bereikt, moeten ze naar de gestopte status worden verplaatst, waar ze enkel nog schijfruimte in beslag nemen. Schijfruimte is op de lange termijn de werkelijke beperkende factor: elke sandbox behoudt zijn eigen bestandssysteem, en enkele tientallen agents die elk een node_modules-directory bevatten, zullen een klein volume vullen lang voordat het geheugengebruik relevant wordt.

Bevriezen, stoppen, archiveren: de levenscyclusinstellingen

De standaardwaarden zijn: bevriezen na 10 minuten inactiviteit, stoppen na 3 dagen en archiveren na 7 dagen als archivering is geconfigureerd. Als u stopAfterSeconds instelt op null, krijgt u een permanente agent: deze kan bij inactiviteit worden bevroren, maar wordt nooit koud gestart.

Archivering is optioneel en de daemon maakt dit duidelijk. Configureer een S3-compatibele opslaglocatie op de instellingenpagina van de console (de vier DORMICE_S3_*-variabelen bestaan nog steeds, maar dienen alleen als basiswaarden voor de eerste start van de gateway). De schijf van een gestopte sandbox wordt vervolgens met tar en zstd verpakt, naar de bucket verzonden en lokaal vrijgegeven. Die bucket kan een MinIO-bucket zijn die u zelf op een andere machine beheert. Als u de opslaglocatie niet configureert, blijven sandboxen voor altijd gestopt en wordt een beleid dat om archivering vraagt geweigerd in plaats van stilzwijgend genegeerd. Herstelbewerkingen blijven zichtbaar in plaats van stil te verlopen: de volgende acquire geeft onmiddellijk een status voor herstel en een voortgangswaarde terug. Zodra de schijf is teruggezet, verandert de status in ready.

Is het al verantwoord om erop te vertrouwen?

Het korte antwoord: niet voor iets dat u niet opnieuw kunt opbouwen. De repository is aangemaakt op 8 July 2026. Op 12 October 2026 heeft deze 1,509 stars, 109 forks, een Apache-2.0-licentie en helemaal geen getagede release. De statusregel in de README vermeldt zelf dat niets daar klaar is voor productie.

Die combinatie brengt een specifiek risicoprofiel met zich mee. De code kan onverwacht veranderen, omdat het installatieprogramma main volgt. De interface is nog in ontwikkeling: in de documentatie staat nu een gateway vóór de daemon, met een eigen poort, een eigen configuratiebestand en een eigen database. Een project dat ongeveer drie maanden oud is, kan bovendien eenvoudig stoppen, omdat geen enkele licentiebepaling iemand verplicht om ermee door te gaan.

De E2B-compatibiliteit maakt het risico beheersbaar. Uw applicatie praat met een protocol waarvoor een gehoste implementatie beschikbaar is. Als Dormice niet verder wordt ontwikkeld, hoeft u slechts twee URL's te wijzigen om door te kunnen werken. Bouw uw agent tegen de E2B-interface in plaats van tegen de native API. Dan behoudt u die uitwijkmogelijkheid. Het native @dormice/sdk-pakket staat bovendien nog niet op npm. Als u dat wilt gebruiken, moet u het vanuit de repository bouwen. Dat is een tweede reden om met de compatibele route te beginnen.

Voer het uit op een plek waar u het verlies kunt accepteren. Bouw de host opnieuw op vanuit een script, houd het token buiten elke prompt en elke commit en haal alles wat u wilt behouden volgens uw eigen back-upschema uit de sandboxen.

FAQ

Is Dormice klaar voor productie?

Nee, en het project zegt dat zelf. In de statusregel van de README staat dat momenteel niets daarvan klaar is voor productie. Op 12 October 2026 is de repository bovendien ongeveer drie maanden oud, zonder git-tags en releases. Er is dus geen versienummer dat u kunt vastleggen. Het installatieprogramma clonet de main-branch. Elke uitvoering levert daarom de nieuwste commit op. Leg git -C /opt/dormice rev-parse HEAD na elke installatie vast. Bewaar een kopie van de databasesnapshots die het installatieprogramma naar /var/lib/dormice/backups/ schrijft. Bewaar waardevolle gegevens buiten de sandboxomgevingen.

Waarin verschilt Dormice van het geven van een tijdelijke VM aan mijn agent?

Een tijdelijke VM is een machine met SSH die u voor een sessie aanmaakt en daarna verwijdert. Dormice is een execution API: uw programma roept acquire en daarna exec aan en ontvangt stdout en een exitcode terug. Er is geen shellsessie tussen deze stappen. Een VM is geschikt voor een gebruiker of agent die tijdelijk een volledige computer nodig heeft. Dormice is geschikt voor een applicatie die meerdere keren per dag gegenereerde code uitvoert en niet bij elke uitvoering een volledige machine hoeft in te stellen en weer af te breken.

Werkt de officiële E2B SDK echt zonder codewijzigingen?

Ja, met configuratiewijzigingen. Laat apiUrl en sandboxUrl verwijzen naar /e2b/api en /e2b/envd op uw daemon. Geef uw Dormice-token mee met een e2b_-prefix als API-sleutel. Commando-uitvoering, PTY-sessies, bestandsoverdracht, ondertekende URL's en de poortproxy worden allemaal gedekt door de end-to-end-suite van het project, die via het officiële pakket draait. Templatebouw is de belangrijkste ontbrekende functie: e2b template build is niet geïmplementeerd. Een template is daarom een Docker-image die u bouwt en met dor template add registreert.

Hoeveel sandboxomgevingen passen op een VPS van 4 GB?

Ongeveer 6 kunnen tegelijkertijd actief zijn als elke sandbox 512 MiB gebruikt. Bij 1 gibibyte per sandbox zijn dat er 3, nadat u ongeveer 1 GB hebt gereserveerd voor het besturingssysteem, Docker en de daemon. Bevroren sandboxomgevingen worden in plaats daarvan beperkt door swap. Het standaard swapbestand van 16 GB in het installatieprogramma kan ongeveer 16 sandboxomgevingen bevatten die elk 1 gibibyte gebruikten. Meet uw eigen situatie met free -m onder realistische belasting. Een sandbox die een testsuite uitvoert, gebruikt namelijk meerdere keren zoveel geheugen als een sandbox die een klein script uitvoert.

Waarom moet Dormice vm.swappiness op 100 instellen?

Een sandbox bevriezen betekent dat het inactieve geheugen ervan naar swap wordt verplaatst. gVisor houdt sandboxgeheugen bij als shared memory. De Linux-kernel wisselt shared memory niet naar swap bij de standaardwaarde voor swappiness. Bij die standaardwaarde levert bevriezen dus geen geheugenvrijgave op en blijft de sandbox de volledige hoeveelheid geheugen gebruiken. Het project mat 0 bytes vrijgemaakt geheugen bij de standaardwaarde en 99.5 procent bij 100. Controleer de effectieve waarde met sysctl vm.swappiness in plaats van configuratiebestanden te lezen. Sommige cloud-images leveren namelijk een waarde van 0.

Was dit artikel nuttig?