---
title: "Run"
description: "Run a container image that serves HTTP at its own HTTPS URL, scaled by requests from zero up to a limit."
---

> Documentation Index
> Fetch the complete documentation index at: https://docs.ezghcloud.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Run

**Run** serves a container image that listens for HTTP on a port. You deploy the image as a
**service** and get an HTTPS URL; Run starts **instances** of it when requests come, sends each
instance up to its concurrency limit at once, and stops them when the requests stop.

- [Quickstart](/run/quickstart) — Deploy an image, call its URL, deploy a new revision, delete it.
- [Concurrency and scaling](/run/concurrency-and-scaling) — Requests per instance, minimum and maximum instances, timeouts and limits.
- [Revisions and traffic](/run/revisions-and-traffic) — Immutable revisions, their statuses, and splitting traffic between them.
- [Access](/run/access) — Public services, and services that only EZGH API keys and Bot keys can call.
- [Outbound network](/run/egress) — Internet, a subnet of a VPC, or no network at all.

## How it works

- A service has a name, a URL (`https://<name>-<6 characters>.run.us-west-1.ezghapps.com`), an
  access mode and a traffic split. Its URL is never given to another service, even after it's
  deleted.
- Each deploy makes a **revision**: the image, its port, size, environment, Bot, outbound network,
  concurrency, scaling and timeouts. Revisions can't be changed. See
  [Revisions and traffic](/run/revisions-and-traffic).
- Each instance is a [sandbox](/sandboxes) in the service's project, running the revision's image
  with the image's own entrypoint and command. Run's sandboxes show in Sandboxes, count against its
  [quotas](/sandboxes/limits#quotas) and are billed as Sandboxes usage.
- Your container gets requests over HTTP/1.1 on its port, with `PORT` set in its environment.
  Responses stream: chunked responses and server-sent events reach the client as they're written.

## How you reach it

| With | Where |
| --- | --- |
| Console | **Run**: the services, a service's revisions, traffic and settings, and create. |
| CLI | `ezgh run`. |
| API | `https://run.ezghcloud.com`. See [create a service](/run-api/CreateService/) and [update a service](/run-api/UpdateService/). |
| Load balancer | A [load balancer](/load-balancers) listener can forward to the service: [Serve a Run service through a load balancer](/run/serve-through-a-load-balancer). |

## Pricing

Run itself isn't billed. Its instances are sandboxes, billed as
[Sandboxes usage](/sandboxes/pricing): vCPUs and memory while an instance runs, and storage while it
exists. A suspended instance isn't billed for vCPUs or memory.

Request logs and your container's output go to the project's logs in
[Observability](/observability), where they're billed as log ingest. Its request metrics are free.

## Permissions

| Action | Access level | Lets you |
| --- | --- | --- |
| `run.services.list` | List | List a project's services |
| `run.services.get` | Read | View a service and its operations |
| `run.services.create` | Write | Create a service |
| `run.services.update` | Write | Deploy revisions and change access, traffic and ingress |
| `run.services.delete` | Write | Delete a service |
| `run.services.invoke` | Write | Call a service whose access is authenticated |
| `run.revisions.list` | List | List a service's revisions |
| `run.revisions.get` | Read | View a revision |
| `run.revisions.delete` | Write | Delete a retired revision |

Managed policies: `RunFullAccess` (everything), `RunReadOnlyAccess` (list and read) and
`RunInvokeAccess` (`run.services.invoke`). `ReadOnlyAccess` includes Run's list and read actions.
Giving a revision a Bot needs `bots.pass` on the Bot; reaching a subnet needs
`network.subnets.get` on it.

## Quotas

| Quota | ID | Scope | Default |
| --- | --- | --- | --- |
| Run services per project | `run.servicesPerProject` | Per project | 20 services |

A service counts from its create until it's deleted. Its instances count against Sandboxes'
quotas: 100 sandboxes a project, suspended ones included, and 16 vCPUs and 32 GiB of memory running
in an organization. These bound how many instances a service can have in practice.

Source: https://docs.ezghcloud.com/run/index.mdx
