# Serverless Functions Serverless functions let you deploy small pieces of business logic without managing servers or runtimes. They're ideal for event-driven pipelines, API backends, and dynamic code execution—but traditional function-as-a-service platforms often suffer from cold-start penalties and opaque sandboxing. With **Unikraft Cloud**, you can run serverless functions inside microVMs: instant availability, VM-level isolation, and true scale-to-zero economics. The ROM (Read-Only Memory) model goes one step further—package your function code independently of the runtime image, and swap it in at instance creation time. ## Why run serverless functions on Unikraft Cloud ### ⚡ Millisecond cold starts with instance templates Unikraft Cloud's [instance templates](/platform/instances#instance-templates) pre-initialize a runtime once, then stamp out new instances from that snapshot. Combined with stateful scale-to-zero, instances resume from a warm snapshot rather than booting from scratch: * Single-digit-millisecond wake-ups, even under burst traffic. * No re-execution of startup logic between requests. ### 🔒 Strong isolation per function Every function instance runs in its own microVM. No shared kernel, no noisy-neighbour risk, and no container escape surface. Sensitive business logic stays protected even when other tenants share the same platform. ### 💸 Pay only for execution Functions are inherently bursty. Scale-to-zero means an idle function costs nothing. The ROM model makes this even leaner: you package the base runtime image once, and only the lightweight function ROM changes per deployment. ### 🔄 Decouple runtime from function code ROMs separate the runtime image (Node.js, Python, etc.) from the function payload: * Update function code by pushing a new ROM—no runtime rebuild required. * Run many specialised functions from a single base image. * Instant rollback by pointing an instance at a previous ROM version. ## Getting started This guide uses the [`node-code-execution`](https://github.com/unikraft-cloud/examples/tree/main/node-code-execution) example. It deploys a Node.js runtime as the base image, then attaches JavaScript or TypeScript function ROMs to instances of that runtime. ### Prerequisites 1. Install the CLI: Use the [unikraft CLI](/docs/cli/unikraft) or the legacy [kraft CLI](https://unikraft.org/docs/cli/install). You need a [BuildKit](https://github.com/moby/buildkit) builder—the easiest way is via [Docker](https://docs.docker.com/engine/install/). 1. Clone the [`examples` repository](https://github.com/unikraft-cloud/examples) and `cd` into the `examples/node-code-execution` directory: ```bash git clone https://github.com/unikraft-cloud/examples cd examples/node-code-execution/ ``` Make sure to log into Unikraft Cloud and pick a [metro](/platform/metros) close to you. This guide uses `fra` (Frankfurt, 🇩🇪): ```bash title="unikraft" unikraft login ``` ```bash title="kraft" # Set Unikraft Cloud access token export UKC_TOKEN=token # Set metro to Frankfurt, DE export UKC_METRO=fra ``` ### Step 1: Package and push the base runtime image The base image contains a Node.js server (`server.ts`) that loads a function from the attached ROM and executes it on each HTTP request. Right before starting the server, it writes `1` to `/uk/libukp/template_instance`, which triggers Unikraft Cloud to convert the running instance into a [template](/platform/instances#instance-templates). ```bash title="unikraft" unikraft build . --output /node-code-exec:latest ``` ```bash title="kraft" kraft pkg \ --name index.unikraft.io//node-code-exec:latest \ --plat kraftcloud \ --arch x86_64 \ --rootfs-type erofs \ --push \ . ``` ### Step 2: Create a template from the base image Boot a short-lived instance from the base image without any ROM attached. The instance self-converts into a template and exits: ```bash title="unikraft" unikraft run --metro fra \ --name node-exec \ -m 512M \ --image /node-code-exec:latest ``` ```bash title="kraft" kraft cloud instance create \ --start \ --name node-exec \ -M 512Mi \ /node-code-exec:latest ``` The output shows the instance details: ```ansi title="unikraft" metro: fra name: node-exec uuid: 96608ed2-45e0-4c8f-8269-5d8cd3e4b41a state: starting image: /node-code-exec resources: memory: 512MiB vcpus: 1 networks: - uuid: 6f7a8b9c-0d1e-2f3a-4b5c-f6a7b8c9d0e1 private-ip: 10.0.5.4 mac: 12:b0:6c:3e:ab:95 timestamps: created: just now ``` ```ansi title="kraft" [●] Deployed successfully! │ ├───────── name: node-exec ├───────── uuid: 96608ed2-45e0-4c8f-8269-5d8cd3e4b41a ├──────── metro: https://api.fra.unikraft.cloud/v1 ├──────── state: starting ├──────── image: oci://unikraft.io//node-code-exec@sha256:71487fd6196987cf65fb89eb84405cb796677aba177dabacf391f09618313328 ├─────── memory: 512 MiB ├─ private fqdn: node-exec.internal └─── private ip: 10.0.5.4 ``` This instance is short-lived, since right before the server starts, it triggers a conversion into a template. To confirm the template is ready: ```bash title="unikraft" unikraft instances templates list ``` ```bash title="kraft" kraft cloud instance template list ```
```ansi title="unikraft" METRO NAME STATE IMAGE ARGS MEMORY VCPUS CREATED fra node-exec template /node-code-exec 512MiB 1 just now ``` ```ansi title="kraft" NAME IMAGE ARGS CREATED AT node-exec oci://unikraft.io//node-code-exec@sha256:71487fd6196987cf65fb89eb84405cb796677aba177dabacf391f09618313328 20 seconds ago ``` ### Step 3: Package and push the function ROMs ROMs package only the function source files—no runtime needed. Package both example functions: ```bash title="unikraft" unikraft build rom1/ --output /node-rom1:latest unikraft build rom2/ --output /node-rom2:latest ``` ```bash title="kraft" kraft pkg \ --rom ./fs \ --rom-type erofs \ --plat kraftcloud \ --arch x86_64 \ --name index.unikraft.io//node-rom1:latest \ --push \ rom1/ kraft pkg \ --rom ./fs \ --rom-type erofs \ --plat kraftcloud \ --arch x86_64 \ --name index.unikraft.io//node-rom2:latest \ --push \ rom2/ ``` ### Step 4: Create instances from the template with ROMs attached Stamp out instances from the template, each with a different ROM. New instances skip the cold-start initialization phase because they restore from the template snapshot. Create the first instance with the JavaScript ROM attached: ```bash title="unikraft" unikraft run --metro fra \ --name node-exec-rom1 \ -p 443:8080/tls+http \ --scale-to-zero policy=on,cooldown-time=1000,stateful=true \ --rom image=/node-rom1:latest,at=/rom \ --template node-exec ``` ```bash title="kraft" # kraft does not support creating instances with attached ROMs, but you can use the API directly curl -X POST "$UKC_METRO/instances" \ -H "Accept: application/json" \ -H "Authorization: Bearer $UKC_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "name": "node-exec-rom1", "template": { "name": "node-exec" }, "autostart": true, "service_group": { "services": [ { "port": 443, "destination_port": 8080, "handlers": ["tls", "http"] } ] }, "scale_to_zero": { "policy": "on", "stateful": true, "cooldown_time_ms": 1000 }, "roms": [ { "name": "js_function", "image": "index.unikraft.io//node-rom1:latest", "at": "/rom" } ] }' ``` Create the second instance with the TypeScript ROM attached: ```bash title="unikraft" unikraft run --metro fra \ --name node-exec-rom2 \ -p 443:8080/tls+http \ --scale-to-zero policy=on,cooldown-time=1000,stateful=true \ --rom image=/node-rom2:latest,at=/rom \ --template node-exec ``` ```bash title="kraft" # kraft does not support creating instances with attached ROMs, but you can use the API directly curl -X POST "$UKC_METRO/instances" \ -H "Accept: application/json" \ -H "Authorization: Bearer $UKC_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "name": "node-exec-rom2", "template": { "name": "node-exec" }, "autostart": true, "service_group": { "services": [ { "port": 443, "destination_port": 8080, "handlers": ["tls", "http"] } ] }, "scale_to_zero": { "policy": "on", "stateful": true, "cooldown_time_ms": 1000 }, "roms": [ { "name": "ts_function", "image": "index.unikraft.io//node-rom2:latest", "at": "/rom" } ] }' ``` Both instances run the same base Node.js runtime but execute different function code—without any rebuild of the runtime image. List the instances and note their FQDN values: ```bash title="unikraft" unikraft instances list ``` ```bash title="kraft" kraft cloud instance list ```
```ansi title="unikraft" METRO NAME STATE IMAGE ARGS MEMORY VCPUS FQDN CREATED fra node-exec-rom2 standby /node-code-exec 512MiB 1 nameless-wood-gw7pbnls.fra.unikraft.app 2 minutes ago fra node-exec-rom1 standby /node-code-exec 512MiB 1 sparkling-dawn-syowlbtj.fra.unikraft.app 3 minutes ago ``` ```ansi title="kraft" NAME FQDN STATE STATUS IMAGE MEMORY VCPUS ARGS BOOT TIME node-exec-rom2 nameless-wood-gw7pbnls.fra.unikraft.app standby standby oci://unikraft.io//node-code-exec@sha256:71487f... 512 MiB 1 6.98 ms node-exec-rom1 sparkling-dawn-syowlbtj.fra.unikraft.app standby standby oci://unikraft.io//node-code-exec@sha256:71487f... 512 MiB 1 7.86 ms ``` Test both instances using the FQDNs from the listing: ```bash curl https://sparkling-dawn-syowlbtj.fra.unikraft.app curl https://nameless-wood-gw7pbnls.fra.unikraft.app ``` ```text Bye, World! Auf Wiedersehen! ``` ## How it works The ROM deployment model has three layers: 1. **Base runtime image**: A generic Node.js server that loads and executes code from a well-known path (`/rom/rom.js` or `/rom/rom.ts`). Push it once; it changes infrequently. 1. **Function ROM**: A read-only filesystem image containing only the function source file. Lightweight, fast to build and push. Attached to an instance at creation time and mounted at `/rom`. 1. **Instance template**: A pre-initialized snapshot of the runtime, created automatically when the base image boots without a ROM. New instances boot from this snapshot, skipping initialization and reducing cold-start latency to milliseconds. ## Cleanup ```bash title="unikraft" unikraft instances delete node-exec-rom1 node-exec-rom2 unikraft instances template delete node-exec ``` ```bash title="kraft" kraft cloud instance remove node-exec-rom1 node-exec-rom2 kraft cloud instance template remove node-exec ``` ## Learn more Use the `--help` option for detailed information on using Unikraft Cloud: ```bash title="unikraft" unikraft --help ``` ```bash title="kraft" kraft cloud --help ``` Or visit the [CLI Reference](/docs/cli/unikraft) or the [legacy CLI reference](/docs/cli/kraft/overview). For more on the ROM and template features: * [Instance templates](/platform/instances#instance-templates) * [ROMs](/platform/instances#roms) * [`node-code-execution` example](https://github.com/unikraft-cloud/examples/tree/main/node-code-execution)