Deploying a function

How an application built with spring_boot_starter_edge gets to Supabase Edge Functions, Cloudflare Workers and AWS Lambda, step by step: by hand first, then from GitHub Actions. For one complete walk through on Supabase, from an empty directory, see A function from an empty directory.

The steps use each platform's own command line tool. They were written against the tools' documented commands and the local runtimes the starter's tests use; a deployed function was not part of those tests, so treat a command that the platform has since changed as the platform's word over this page's.

What is deployed

dart run spring_boot_starter_edge:build writes a directory with:

That directory is the whole function: no Dart SDK, no pubspec.yaml, no packages go to the platform. The platform starts an instance, loads the entry, the application's context starts once (50 to 250 ms), and the instance answers requests until the platform stops it.

JavaScript or WebAssembly. Both are the same application and pass the same tests. JavaScript runs everywhere and is the default. WebAssembly (--target wasm, see Building) needs a runtime with WasmGC and, since Dart 3.14, the WebAssembly exception handling (exnref): Cloudflare Workers and Node.js 22 of AWS Lambda have them; Supabase's Edge Runtime (Deno 2.1) not yet, so WebAssembly for Supabase is compiled by Dart 3.13 (--dart, see Building) until Supabase updates it. It is deployed the same way, with one more file. Measure both for your application before choosing: the starter makes no promise that one is faster.

Before any deploy, in the application's directory:

dart pub get
dart run build_runner build     # the generated code of the application

Supabase Edge Functions

You need the Supabase CLI and a project. The application's directory has (or gets) a supabase/ directory, as supabase init makes it.

1. Sign in and choose the project (once):

supabase login
supabase link --project-ref <ref>      # <ref>.supabase.co

2. Declare the function in supabase/config.toml:

[functions.api]
verify_jwt = false        # the application checks the tokens itself

With verify_jwt = true (the platform's default) the gateway refuses every request without a token of the project before the application sees it, so an endpoint open to everyone would not be. For a WebAssembly build, also list the module:

[functions.api]
verify_jwt = false
static_files = ["./functions/api/*.wasm"]

Warning

WebAssembly on Supabase: compiled by Dart 3.13 only, for now. Supabase's Edge Runtime is Deno 2.1, whose V8 (13.0) lacks the WebAssembly exception handling (exnref) that dart compile wasm uses from Dart 3.14 on (Flutter 3.50). Until Supabase updates it, compile the function with Dart 3.13: --dart <the dart of a Dart 3.13 SDK>. A build by a later Dart is refused and says so. JavaScript works with every Dart, and WebAssembly on every other platform.

dart run spring_boot_starter_edge:build --platform supabase --name api \
  --target wasm --dart ~/sdk/dart-3.13/bin/dart

3. Build into supabase/functions/api/:

dart run spring_boot_starter_edge:build --platform supabase --name api
# or: ... --name api --target wasm

The name is the function's address: /functions/v1/api/.... The application's mappings do not repeat it (@GetMapping('/todos') answers /functions/v1/api/todos).

4. Secrets. The platform gives every function SUPABASE_URL, SUPABASE_ANON_KEY and SUPABASE_SERVICE_ROLE_KEY; the starter makes spring.supabase.* of them. Everything else the application reads from its environment is a secret of the project:

supabase secrets set MAIL_API_KEY=... GREETING=hello

A secret SPRING_MAIL_HOST is the property spring.mail.host; any secret is ${NAME} in application.yml.

5. The database, when the application counts its rate limits there: copy package:spring_boot_starter_supabase/sql/rate_limit.sql into supabase/migrations/ and push it:

supabase db push

6. Deploy:

supabase functions deploy api

The CLI bundles index.ts with what it imports (main.js, prelude.js; the module of a WebAssembly build goes as a static file) and uploads it.

7. Call it:

curl https://<ref>.supabase.co/functions/v1/api/health
curl https://<ref>.supabase.co/functions/v1/api/todos?list=home \
  -H "Authorization: Bearer <a user's access token>"

The function's logs (the application's log lines, its start, the warning list) are on the function's page of the dashboard.

Locally the same directory runs in the CLI's stack: supabase start serves supabase/functions/api at http://127.0.0.1:54321/functions/v1/api. There the functions reach the project at http://kong:8000 while the tokens name http://127.0.0.1:54321, so the local stack needs one more line in config.toml (a hosted project does not):

[edge_runtime.secrets]
SPRING_SUPABASE_AUTH_ISSUER = "http://127.0.0.1:54321/auth/v1"

Cloudflare Workers

You need Node.js (for npx wrangler) and a Cloudflare account.

1. Sign in (once): npx wrangler login.

2. Build:

dart run spring_boot_starter_edge:build --platform cloudflare --name shop
# or: ... --name shop --target wasm

It writes build/cloudflare/ and, the first time, wrangler.toml into the application's directory:

name = "shop"
main = "build/cloudflare/worker.mjs"
compatibility_date = "2026-11-11"

wrangler.toml is yours from then on; commit it. build/ is not committed.

3. Configuration. Plain values go into wrangler.toml, secrets to Cloudflare; both are the application's environment (${NAME}, SPRING_... as properties):

[vars]
GREETING = "hello"
npx wrangler secret put JWT_SECRET

4. Bindings, when the application uses them (CloudflareBindings, the rate limiter in D1):

npx wrangler d1 create shop                 # prints the database_id
npx wrangler kv namespace create SETTINGS   # prints the id
[[d1_databases]]
binding = "DB"
database_name = "shop"
database_id = "<printed>"

[[kv_namespaces]]
binding = "SETTINGS"
id = "<printed>"

[vars]
# The rate limiter's counters in that database, shared by every instance.
SPRING_EDGE_CLOUDFLARE_RATE_LIMIT_DATABASE = "DB"

5. Deploy:

npx wrangler deploy

wrangler bundles worker.mjs with main.js (and uploads app.wasm as a module of a WebAssembly build: Cloudflare compiles it at deploy, a Worker may not at run time) and prints the address, https://shop.<your-subdomain>.workers.dev.

6. Your own domain and schedules, in wrangler.toml:

routes = [{ pattern = "api.example.com", custom_domain = true }]

[triggers]
crons = ["0 3 * * *"]     # runs the EdgeScheduledHandler beans

Locally: npx wrangler dev runs the same Worker in Cloudflare's runtime with local stand-ins for D1 and KV.

Limits to know. A Worker's script may be 3 MB gzipped on the free plan and 10 MB on the paid one; a function with the web and security starters is 0.6 MB. The free plan also limits the CPU time of a request to 10 ms, which the start of the application's context on an instance's first request can exceed; the paid plan's limit is far above it.

AWS Lambda

You need the AWS CLI, signed in to an account.

1. Build and zip:

dart run spring_boot_starter_edge:build --platform aws --name api
(cd build/aws && zip -q -r ../function.zip .)

2. A role for the function (once): it lets Lambda run the function and write its logs.

aws iam create-role --role-name api-function \
  --assume-role-policy-document '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"Service":"lambda.amazonaws.com"},"Action":"sts:AssumeRole"}]}'
aws iam attach-role-policy --role-name api-function \
  --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole

3. Create the function (once):

aws lambda create-function --function-name api \
  --runtime nodejs22.x --handler index.handler \
  --architectures arm64 --memory-size 512 --timeout 30 \
  --role arn:aws:iam::<account>:role/api-function \
  --zip-file fileb://build/function.zip

The handler is always index.handler. More memory also means more CPU, and so a shorter start.

4. An address. The simplest is a function URL:

aws lambda create-function-url-config --function-name api --auth-type NONE
aws lambda add-permission --function-name api --statement-id url \
  --action lambda:InvokeFunctionUrl --principal "*" \
  --function-url-auth-type NONE

--auth-type NONE means AWS lets every request through and the application decides (Spring Security), as on a server. The same function also answers an API Gateway HTTP API, an API Gateway REST API and an Application Load Balancer, without another build: the entry tells the events apart.

5. Configuration: the function's environment variables are the application's environment.

aws lambda update-function-configuration --function-name api \
  --environment "Variables={GREETING=hello,JWT_SECRET=...}"

6. Deploy a new version:

dart run spring_boot_starter_edge:build --platform aws --name api
(cd build/aws && zip -q -r ../function.zip .)
aws lambda update-function-code --function-name api \
  --zip-file fileb://build/function.zip

Streaming. A response is buffered by default: server-sent events arrive when the stream ended. For a body sent while it is written, build with --streaming and switch the function URL to streaming:

dart run spring_boot_starter_edge:build --platform aws --name api --streaming
aws lambda update-function-url-config --function-name api \
  --invoke-mode RESPONSE_STREAM

A streaming build answers function URLs only.

Schedules. An EventBridge rule with the function as its target runs the application's EdgeScheduledHandler beans:

aws events put-rule --name nightly --schedule-expression "cron(0 3 * * ? *)"
aws lambda add-permission --function-name api --statement-id nightly \
  --action lambda:InvokeFunction --principal events.amazonaws.com \
  --source-arn arn:aws:events:<region>:<account>:rule/nightly
aws events put-targets --rule nightly \
  --targets "Id=api,Arn=arn:aws:lambda:<region>:<account>:function:api"

The rate limiter. The starter has no shared store for AWS: declare a RateLimitStore bean over what the application has (a table in DynamoDB, a database), or the limits are counted per instance, which the function says when it starts.

From GitHub Actions

dart run spring_boot_starter_edge:workflow --platform supabase --name api
dart run spring_boot_starter_edge:workflow --platform cloudflare --name shop
dart run spring_boot_starter_edge:workflow --platform aws --name api

Each writes .github/workflows/deploy-<name>.yml into the repository: on every push to main (--branch) it installs the dependencies, runs the generator, builds the function (--target wasm for a WebAssembly build) and deploys it with the steps above. It writes no secret; set what it names in the repository's settings:

Platform Secrets and variables
Supabase secrets.SUPABASE_ACCESS_TOKEN (an access token of the account), secrets.SUPABASE_PROJECT_REF
Cloudflare secrets.CLOUDFLARE_API_TOKEN (a token that may edit Workers), secrets.CLOUDFLARE_ACCOUNT_ID
AWS secrets.AWS_ROLE_ARN (a role GitHub may assume through OIDC, allowed lambda:UpdateFunctionCode), vars.AWS_REGION, vars.AWS_LAMBDA_FUNCTION

The workflow deploys the code. What is set once stays outside it: the function's secrets (supabase secrets set, wrangler secret put, the Lambda function's environment), the Supabase migrations, and creating the Lambda function with its role and address.

Checking a deployed function

See also