Sandboxes, Runtimes and Packages: Where Your Code Runs

Intro

0:00 Your code runs in eight languages : each in an image built with the packages it needs, apart from the server and from other accounts. In this video, sandboxes, runtimes and packages.

Runtimes, the usual way

0:13 A runtime per language usually means a Dockerfile per service, written and patched by hand, packages installed on one machine and missing on the next, and code which downloads what it wants while it runs. With API Maker, one page sets the runtime and the packages of each language, every server builds the same image, named by what it holds, and only the listed packages exist where the code runs.

0:40 In this video : Sandbox Settings, a package of PyPI in a Python API, a Dockerfile of your own and its guard rails, where code runs, and the sandboxes of a server.

Sandbox Settings

0:51 From the dashboard, Sandbox Settings. Eight languages, each with the image it runs in, ready on this server. JavaScript has two runtimes : Bun, and Node.js, the default. A piece of code can name its runtime. The list holds the released versions of its image, from the oldest API Maker runs. None picked : the default. Python : its slim image, and no package : the standard library. The Dockerfile : API Maker fills in the image, the packages and the runner.

1:24 This is what is built. Then the image on every server, ready.

A package of PyPI

1:31 API Testing : Sales Summary, a Python API which imports humanize. Send : five hundred, no module named humanize, at line one. Nothing is downloaded while code runs. Operations, Sandbox Settings, Python. humanize : the exact name, as PyPI knows it, and its versions, from PyPI. The latest, Add, and Save. The image of Python is built on every server, and ready. The menu, and API Testing, Custom APIs, Sales Summary.

2:07 Send : a hundred and eighty orders, and their total in words. The code imports humanize like any package of Python. The orders come from MySQL, and humanize writes the total for a person. Every language has its registry : npm, PyPI, Packagist, NuGet, Go modules, crates.io and Maven Central.

A Dockerfile of your own

2:29 A Dockerfile of your own : Customize shows the default one, with its three markers. A line ENTRYPOINT of our own, and Final Dockerfile refuses it, with the reason : the entrypoint belongs to API Maker, it starts the program which runs your code. It refuses a second marker too, or a file without FROM. Reset to default, Customize off, Refresh : nothing was saved.

Where code runs

2:55 Code runs in one of three places. TypeScript which only reads runs inside the server itself, in a few milliseconds. Everything else runs in a Docker sandbox of its account and language : a container, with an agent inside which answers g.sys. Code marked runOnNativeProcess runs in a runner of the server machine, shared by every account, for tools the machine has. And one API can have a sandbox group of its own, with its own runtime and packages.

The sandboxes of a server

3:27 Python, and its sandbox on this server : its port and its runners. The sandbox count : the most sandboxes each language has on each server. A second starts while the first is busy. One more : three, not saved here. The menu of the account : Restart All Sandbox, Yes. Ask again : no sandbox. The next call starts one again, on a new port. Refresh : the count stays two.

3:56 With x-am-meta, the answer says where it ran : the server video1, the sandbox and its port, the one of the page, and the runtime python.

Good to know

4:07 A package can be switched off : kept in the list, not installed. Accounts with the same settings share one image, and images nothing asks for are removed every hour. The Vulnerabilities page checks exactly these packages.

Built on standards

4:22 One list of packages per language, and nothing downloaded while code runs. The same image on every server, named by what it holds. So code an AI assistant writes with a package not in the list fails at its line, at once, instead of pulling it.

Recap

4:39 To sum up. Eight languages, their runtimes and versions, on one page. Packages from the registry of each language. A Dockerfile of your own, with guard rails. Lean code, sandboxes and native runners. Sandboxes restarted in one click. Next : deploying a new version of API Maker. API Maker. Build faster, spend smarter, deliver better.