> ## Documentation Index > Fetch the complete documentation index at: https://docs.sevalla.com/llms.txt > Use this file to discover all available pages before exploring further. > ## Agent Instructions > These are the docs for Sevalla, a platform for deploying applications, databases, static sites, object storage and load balancers. The dashboard is at https://app.sevalla.com. > Bold text in steps is an exact dashboard label. > To act on a Sevalla account, prefer the Sevalla MCP server (https://mcp.sevalla.com/mcp, see https://docs.sevalla.com/ai-agents/overview.md), then the Sevalla CLI (https://docs.sevalla.com/developer-tools/cli.md), then the REST API (https://api-docs.sevalla.com, OpenAPI spec at https://api.sevalla.com/v3/openapi.json). > Every page index is at https://docs.sevalla.com/llms.txt. # Deploy a Fresh application > Deploy a Fresh 2 application on Deno to Sevalla from a Git repository: pin Deno in .dvmrc, and build it with Ingot or a Dockerfile that serves _fresh/server.js. A Fresh application runs on Sevalla as a Deno application: Ingot, Sevalla's builder, detects `deno.json` in your Git repository, installs the dependencies from `deno.lock`, runs the `build` task, which writes the production build to `_fresh/`, and the web process runs the `start` task, `deno serve -A _fresh/server.js`, on the port that Sevalla sets in the `PORT` environment variable. ## At a glance | | | | - | - | | Source | A Git repository | | Build | [Ingot](https://docs.sevalla.com/applications/builds/ingot.md) (Deno 2.9), or the [Dockerfile](#deploy-with-a-dockerfile) | | Start command | `deno serve -A _fresh/server.js`, from `tasks.start` in `deno.json` | | Port | The `PORT` environment variable, `8080` by default, which Ingot passes to `deno serve` in `DENO_SERVE_ADDRESS` | | Processes | Web process | | Services | None | | Disk | None | | Size | **H1** for the web process | ### Environment variables The application needs no environment variables of its own. Sevalla sets `PORT` for the web process. ## Before you begin * A Sevalla company with a payment method, and a GitHub, GitLab or Bitbucket account for the repository. See [Git providers](https://docs.sevalla.com/git/overview.md). * Deno 2.9 or later on your computer. ## Create the project Create a Fresh 2 project. The flags answer the questions the script would ask: no Tailwind CSS and no VS Code settings. ```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}} deno run -Ar jsr:@fresh/init storefront --tailwind=false --vscode=false cd storefront ``` The script writes a Fresh 2.3 project that builds with Vite, installs its dependencies into `node_modules/` and writes `deno.lock`. Its `deno.json` has the tasks Sevalla uses: | Task | Command | What it does | | - | - | - | | `build` | `vite build` | Writes the server and the browser assets to `_fresh/` | | `start` | `deno serve -A _fresh/server.js` | Serves the build | | `dev` | `vite` | Runs the development server with hot reload | The template's `.gitignore` already keeps `_fresh/` and `node_modules/` out of the repository. ## Prepare the project for Sevalla Pin the Deno version: ```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}} echo "2" > .dvmrc ``` | File | Why Sevalla needs it | | - | - | | `.dvmrc` | [Ingot](https://docs.sevalla.com/applications/builds/ingot.md), the default build strategy, builds on the newest Deno 2 line it knows: Deno 2.9 in Ingot 0.4.1. Without a version, Ingot uses its default line, which a new Ingot release can move. | | `deno.lock` | Ingot installs the exact versions in it with `deno install --frozen`, which fails instead of changing them. Commit it. | | `deno.json` | Ingot detects Deno from it, runs the `build` task during the build, and starts the web process with `deno task start`. | Ingot needs no other configuration. Before the server starts, Ingot sets `DENO_SERVE_ADDRESS` from [`PORT`](https://docs.sevalla.com/guides/javascript/overview#listen-on-the-port-environment-variable), which Sevalla sets to the web process's port (`8080` by default), so `deno serve` listens on that port on all network interfaces. When Sevalla stops an instance, `deno serve` gets `SIGTERM`, finishes the requests in progress, then exits. See [How processes run](https://docs.sevalla.com/applications/processes.md#how-processes-run). Run `deno task dev` and open the address it prints to check the project locally. Then commit everything and push it to your Git provider: ```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}} git init git add . git commit -m "Prepare for Sevalla" git branch -M main git remote add origin https://github.com/acme/storefront.git git push -u origin main ``` ## Deploy to Sevalla These steps build with [Ingot](https://docs.sevalla.com/applications/builds/ingot.md). To build from your own Dockerfile instead, see [Deploy with a Dockerfile](#deploy-with-a-dockerfile). **1. Create the application** In the sidebar, click **Applications**, then click **Create** > **Application**. Under **Source**, click **Private repository**, then choose the **Git provider**, the **Repository** and the **Branch**. Under **Location**, choose a **Data center**. Keep the **Size** at **H1** or choose a larger one, then click **Create application**. The application opens on its **Overview** tab with the status **Not deployed yet**: creating an application doesn't deploy it. **2. Deploy** Click the **Overview** tab, then click **Deploy now** under **Recent deployments**. Check the **Branch** and click **Deploy**. **3. Turn on auto-deploy** To deploy every push to the branch automatically, click the **Settings** tab, then click **Update auto-deploy** in the **Auto-deploy** section. Turn on **Auto-deploy** and click **Update auto-deploy**. See [Deployments](https://docs.sevalla.com/applications/deployments.md#deploy-automatically-on-push). ## Verify the deployment 1. On the **Deployments** tab, click the deployment. Its **Build log** shows Ingot's [build plan](https://docs.sevalla.com/applications/builds/ingot.md#read-the-build-plan): Deno 2.9 for the `2` in `.dvmrc`, and the `start` and `build` tasks from `deno.json`. ```text Build log theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}} ╭─ ■ Deno 2.9 application ───────────────────────────────────────╮ │ Deno 2.9 .dvmrc "2" │ │ Start deno serve -A _fresh/server.js deno.json tasks.start │ │ Build vite build deno.json tasks.build │ ├─ Image ────────────────────────────────────────────────────────┤ │ Build denoland/deno:debian-2.9.8 │ │ Runtime denoland/deno:debian-2.9.8 │ │ User 1000:1000 │ │ Init tini │ │ Port $PORT, default 8080 │ ╰───────────────────────────────────────────────── Ingot v0.4.1 ─╯ ``` 2. Wait for the deployment's status to change to **Deployed**. The application's status next to its name changes to **Running**. 3. Click the domain under the application's name, for example `storefront-x7k2m.sevalla.app`. The page shows `Welcome to Fresh`. Add `/api/joe` to the address: it returns `Hello, Joe!`. ![The application header with its name, Running status, repository, branch and the domain that opens the application](https://assets.sevalla.com/screenshots/light/app-overview-address.png) To check from a terminal, read the deployment's status with [Get deployment](https://api-docs.sevalla.com/v3/applications/get-deployment) and its build log with [Get application deployment logs](https://api-docs.sevalla.com/v3/applications/get-application-deployment-logs), as the last steps of [Deploy with the API](#deploy-with-the-api) do, then request the domain: ```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}} curl -s https://storefront-x7k2m.sevalla.app/ | grep -o 'Welcome to Fresh' curl -s https://storefront-x7k2m.sevalla.app/api/joe ``` ```text theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}} Welcome to Fresh Hello, Joe! ``` If the deployment fails, read its build log, then see [Troubleshoot Ingot builds](https://docs.sevalla.com/applications/builds/ingot.md#troubleshoot-ingot-builds). For a server that runs `Deno.serve()` without Fresh, see [Deploy a Deno application](https://docs.sevalla.com/guides/javascript/deno.md). ## Deploy with a Dockerfile Ingot needs no Dockerfile. Write your own when you want full control of the image: the base image, the system packages and every layer. Add a `Dockerfile` and a `.dockerignore` to the root of the repository: ```dockerfile Dockerfile theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}} FROM denoland/deno:debian-2.9.8 AS build WORKDIR /app COPY deno.json deno.lock ./ RUN deno install --frozen COPY . . RUN deno task build FROM denoland/deno:debian-2.9.8 WORKDIR /app ENV DENO_NO_UPDATE_CHECK=1 COPY --from=build /app/_fresh ./_fresh USER 1993:1993 EXPOSE 8080 CMD ["sh", "-c", "exec deno serve --allow-net --allow-env --allow-read --port ${PORT:-8080} _fresh/server.js"] ``` | Line or choice | Why | | - | - | | `denoland/deno:debian-2.9.8` | Deno's official image on Debian 13, the image Ingot builds Deno 2.9 on. Deno publishes images per release, with no tag that follows a line, so update the tag when you move to a new Deno release. | | Two stages | The `build` stage installs the dependencies, including Vite, and runs `vite build`. `_fresh/server.js` bundles the server code it needs, so the final stage copies only `_fresh/`, without `node_modules` or the source. | | `deno.json` and `deno.lock` copied before the source | A change to your code reuses the cached `deno install` layer. | | `--allow-net --allow-env --allow-read` | Grants `deno serve` only what the server uses, instead of the `-A` of the `start` task. Add a permission if your code needs one, such as `--allow-write`. | | `${PORT:-8080}` | The shell reads `PORT`, which Sevalla sets, and `exec` replaces the shell with Deno. The image's own entrypoint runs `tini`, which passes `SIGTERM` on to Deno. | | `USER 1993:1993` | The image's `deno` user, not root. The copied files stay owned by root, so the server can read its code but not change it. | | `DENO_NO_UPDATE_CHECK=1` | Stops Deno from checking for a newer release when it starts. | ```text .dockerignore theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}} .git node_modules _fresh .env* *.log Dockerfile .dockerignore ``` Commit and push both files. Ingot doesn't use the `Dockerfile`, so you can keep it in a repository that builds with Ingot, but it adds the `.dockerignore` patterns to its own: its build plan then shows `Ignored 7 patterns from .dockerignore`, and the Ingot build still passes because none of these patterns removes a file it needs. Then switch the application to the Dockerfile build strategy: **1. Choose the Dockerfile build strategy** On the application's **Settings** tab, in the **Build strategy** section, click **Update build strategy**. Click **Dockerfile**, keep the **Dockerfile path** `Dockerfile` and the **Docker context** `.`, then click **Update build strategy**. **2. Deploy** Click the **Overview** tab, then click **Deploy now** under **Recent deployments**. Check the **Branch** and click **Deploy**. The deployment's build log shows `📦 Building and pushing docker image using Dockerfile...` instead of Ingot's build plan, and its **Dockerfile** tab shows your file. When the deployment's status is **Deployed**, the domain shows `Welcome to Fresh` again. See [Dockerfile](https://docs.sevalla.com/applications/builds/dockerfile.md). ## Deploy changes With **Auto-deploy** on, every push to the branch starts a deployment; otherwise, click **Deploy now** for each change. Each deployment builds the image, then replaces the web process's instances. See [Deployments](https://docs.sevalla.com/applications/deployments.md). ## Use environment variables Add configuration on the application's **Environment variables** tab and read it in server code with `Deno.env.get()`. Variables marked **Available during buildtime** also reach `deno install` and `vite build` with Ingot; with a Dockerfile, they arrive as build arguments, which a stage reads only after an `ARG` line for each one. Variables apply at the next deployment. See [Environment variables](https://docs.sevalla.com/applications/environment-variables.md). ## Add a custom domain To serve the application from your own domain, such as `shop.example.com`, add the domain on the application's **Domains** tab and create the DNS records that Sevalla shows. Custom domains need a web process larger than **H1**, so [scale](https://docs.sevalla.com/applications/scaling.md) the web process first. See [Custom domains](https://docs.sevalla.com/domains/overview.md). ## Deploy with the API The [Sevalla API](https://docs.sevalla.com/developer-tools/api.md) makes the same deployment as [Deploy to Sevalla](#deploy-to-sevalla) without the dashboard. Run the steps in order in one shell: each step is one API call, and saves the IDs that later steps need in shell variables. Each step also names the [CLI](https://docs.sevalla.com/developer-tools/cli.md) command and the [MCP server](https://docs.sevalla.com/ai-agents/overview.md) tool that do the same. A variable that holds `null` means the call failed: run the `curl` command without its `jq` part to read the error. You need: * An [API key](https://docs.sevalla.com/developer-tools/api-keys.md) with the **Company developer** role, or the `APP:CREATE`, `APP:READ` and `APP:UPDATE` permissions, in the `SEVALLA_API_KEY` environment variable. The CLI reads the key from `SEVALLA_API_TOKEN`. * The repository on GitHub, GitLab or Bitbucket, and a Git account that can read it connected to your Sevalla user, which only the dashboard can do. See [Git providers](https://docs.sevalla.com/git/overview.md). Creating the application checks the access: if Sevalla can't read the repository, the call returns `400` with `Cannot access repository https://github.com/acme/storefront: Repository not found or you don't have access.`, followed by where to grant the access. * `curl` and `jq`. **1. Find the location** [List clusters](https://api-docs.sevalla.com/v3/resources/list-clusters) (`listClustersV3`) returns every location with its `id`, its name in `display_name` and its region ID in `location`. Pick one by its region ID, here `eu-frankfurt-1` for Frankfurt, Germany. [Locations](https://docs.sevalla.com/platform/locations.md) lists them all. ```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}} CLUSTER_ID=$(curl -s https://api.sevalla.com/v3/resources/clusters \ -H "Authorization: Bearer $SEVALLA_API_KEY" \ | jq -r '.[] | select(.location == "eu-frankfurt-1") | .id') ``` CLI: `sevalla resources clusters`. MCP: `get_platform_options`. **2. Create the application** [Create application](https://api-docs.sevalla.com/v3/applications/create-application) (`createApplicationV3`) creates the application with the Ingot build strategy and a web process, and doesn't deploy it. ```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}} APP_ID=$(curl -s -X POST https://api.sevalla.com/v3/applications \ -H "Authorization: Bearer $SEVALLA_API_KEY" \ -H "Content-Type: application/json" \ -d @- <