Deploying Functions

Deploying a function registers a handler under a project-scoped name and provisions the runtime shape it will run at. A deploy takes an image (a registry reference or a project image) plus a wire contract and scaling configuration, and produces an immutable version. Every field beyond name and image has a sensible default, so the smallest possible deploy names a function and points it at an image. This page walks an end-to-end example — a tiny handler, its image, the deploy, and a first invocation — then covers versioning.

The handler

A handler is any HTTP server that reads its port from RLP_FN_PORT and answers POST /. Daytona forwards each invocation's body to POST / and returns whatever the handler responds. Here is a complete, correct handler that parses a JSON body and returns a JSON result:

# handler.py
import json
import os
from http.server import BaseHTTPRequestHandler, HTTPServer
 
class Handler(BaseHTTPRequestHandler):
    def do_POST(self):
        raw = self.rfile.read(int(self.headers.get("Content-Length", 0)))
        payload = json.loads(raw or b"{}")
        result = {"greeting": f"hello {payload.get('name', 'world')}"}
        body = json.dumps(result).encode()
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.end_headers()
        self.wfile.write(body)
 
port = int(os.environ.get("RLP_FN_PORT", "8080"))
HTTPServer(("0.0.0.0", port), Handler).serve_forever()

The image

Package the handler into an OCI image. The image's entrypoint should start the server; if it does, you don't need a custom handler argv at deploy time. A minimal Dockerfile for the handler above:

FROM python:3.12-slim
WORKDIR /app
COPY handler.py .
CMD ["python", "handler.py"]

Build and push this image to a registry your project can pull, then deploy by its registry reference. If you'd rather not manage a build, deploy any prebuilt image that serves POST / on its port — the SDKs deploy registry references directly.

Note: The SDKs send registry references. Building from a Dockerfile at deploy time is also available through the REST API's multipart form — see the Functions API reference.

Deploying

Deploy with the SDK or the REST API. deploy is an upsert by name: the first call creates the function, and later calls create new versions.

from rlp import Daytona
 
daytona = Daytona()
 
daytona.fn.deploy(
    "greet",
    image="ghcr.io/acme/greet:latest",
    vcpus=1,
    mem_mib=512,
    timeout_s=30,
    env={"LOG_LEVEL": "info"},
)

import { Daytona } from '@rlp/sdk'
 
const daytona = new Daytona()
 
await daytona.fn.deploy({
  name: 'greet',
  image: 'ghcr.io/acme/greet:latest',
  vcpus: 1,
  memMib: 512,
  timeoutS: 30,
  env: { LOG_LEVEL: 'info' },
})

curl -X POST https://api.rl.trydaytona.com/fns \
  -H "Authorization: Bearer $RLP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "greet",
    "image": { "type": "registry", "ref": "ghcr.io/acme/greet:latest" },
    "vcpus": 1,
    "mem_mib": 512,
    "timeout_s": 30,
    "env": { "LOG_LEVEL": "info" }
  }'

Once deployed, invoke it:

print(daytona.fn.invoke("greet", {"name": "Ada"}))
# {"greeting": "hello Ada"}

Deploy configuration

Every field below except name and image is optional and defaults as shown. Functions are always non-spot, non-persistent, and burstable, homed in the caller's default region — there is no region, spot, persistent, secrets, or mode option.

Versioning

Each deploy creates a new immutable version and points "current" at it. Redeploying the same name is how you roll a change forward — the new version becomes current and subsequent invocations use it. Version history is available via GET /fns/:name/versions.

Changing the image or the handler argv always requires a redeploy, because those are baked into the version. The runtime scaling knobs, however, can be updated on the current version in place — without a rebuild — through PATCH /fns/:name/config. That endpoint accepts max_concurrency, max_instances, timeout_s, and scaledown_window_s, and the change takes effect on the next invocation:

curl -X PATCH https://api.rl.trydaytona.com/fns/greet/config \
  -H "Authorization: Bearer $RLP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "max_concurrency": 8, "scaledown_window_s": 120 }'

To remove a previously set instance cap, send an explicit "max_instances": null. See the Functions API reference for the full request and response shapes.