jarle/Bun Deploy a Bun application on Google Cloud Run

Deploy a Bun application on Google Cloud Run

Google Cloud Run is a managed platform for deploying and scaling serverless applications. Google handles the infrastructure for you.

In this guide, we will deploy a Bun HTTP server to Google Cloud Run using a Dockerfile.

<Note> Before continuing, make sure you have:

• A Bun application ready for deployment
• A Google Cloud account with billing enabled
• Google Cloud CLI installed and configured </Note>

---

<Steps> <Step title={<span>Initialize <code>gcloud</code> by select/creating a project</span>}> Make sure that you've initialized the Google Cloud CLI. This command logs you in, and prompts you to either select an existing project or create a new one.

For more help with the Google Cloud CLI, see the [official documentation](https://docs.cloud.google.com/sdk/gcloud/reference/init).

```bash terminal icon="terminal" theme={"theme":{"light":"github-light","dark":"dracula"}}
gcloud init
```

```txt  theme={"theme":{"light":"github-light","dark":"dracula"}}
Welcome! This command will take you through the configuration of gcloud.

You must sign in to continue. Would you like to sign in (Y/n)? Y
You are signed in as [[email protected]].

Pick cloud project to use:
 [1] existing-bun-app-1234
 [2] Enter a project ID
 [3] Create a new project
Please enter numeric choice or text value (must exactly match list item): 3

Enter a Project ID. my-bun-app
Your current project has been set to: [my-bun-app]

The Google Cloud CLI is configured and ready to use!
```

</Step> <Step title="(Optional) Store your project info in environment variables"> Set variables for your project ID and number so they're easier to reuse in the following steps.

```bash terminal icon="terminal" theme={"theme":{"light":"github-light","dark":"dracula"}}
PROJECT_ID=$(gcloud projects list --format='value(projectId)' --filter='name="my bun app"')
PROJECT_NUMBER=$(gcloud projects list --format='value(projectNumber)' --filter='name="my bun app"')

echo $PROJECT_ID $PROJECT_NUMBER
```

```txt  theme={"theme":{"light":"github-light","dark":"dracula"}}
my-bun-app-... [PROJECT_NUMBER]
```

</Step> <Step title="Link a billing account"> List your available billing accounts and link one to your project:

```bash terminal icon="terminal" theme={"theme":{"light":"github-light","dark":"dracula"}}
gcloud billing accounts list
```

```txt  theme={"theme":{"light":"github-light","dark":"dracula"}}
ACCOUNT_ID            NAME                OPEN  MASTER_ACCOUNT_ID
[BILLING_ACCOUNT_ID]  My Billing Account  True
```

Link your billing account to your project. Replace `[BILLING_ACCOUNT_ID]` with the ID of your billing account.

```bash terminal icon="terminal" theme={"theme":{"light":"github-light","dark":"dracula"}}
gcloud billing projects link $PROJECT_ID --billing-account=[BILLING_ACCOUNT_ID]
```

```txt  theme={"theme":{"light":"github-light","dark":"dracula"}}
billingAccountName: billingAccounts/[BILLING_ACCOUNT_ID]
billingEnabled: true
name: projects/my-bun-app-.../billingInfo
projectId: my-bun-app-...
```

</Step> <Step title="Enable APIs and configure IAM roles"> Activate the necessary services and grant Cloud Build permissions:

```bash terminal icon="terminal" theme={"theme":{"light":"github-light","dark":"dracula"}}
gcloud services enable run.googleapis.com cloudbuild.googleapis.com
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member=serviceAccount:[email protected] \
  --role=roles/run.builder
```

<Note>
  These commands enable Cloud Run (`run.googleapis.com`) and Cloud Build (`cloudbuild.googleapis.com`), which are required for deploying from source. Cloud Run runs your containerized app, while Cloud Build handles building and packaging it.

  The IAM binding grants the Compute Engine service account (`[email protected]`) permission to build and deploy images on your behalf.
</Note>

</Step> <Step title="Add a Dockerfile"> Create a new `Dockerfile` in the root of your project. This file contains the instructions to initialize the container, copy your local project files into it, install dependencies, and start the application.

```docker Dockerfile icon="docker" theme={"theme":{"light":"github-light","dark":"dracula"}}
# Use the official Bun image to run the application
FROM oven/bun:latest

# Copy the package.json and bun.lock into the container
COPY package.json bun.lock ./

# Install the dependencies
# Install the dependencies
RUN bun install --production --frozen-lockfile

# Copy the rest of the application into the container
COPY . .

# Run the application
CMD ["bun", "index.ts"]
```

<Note>
  Make sure that the start command corresponds to your application's entry point. This can also be `CMD ["bun", "run", "start"]` if you have a start script in your `package.json`.

  This image installs dependencies and runs your app with Bun inside a container. If your app doesn't have dependencies, you can omit the `RUN bun install --production --frozen-lockfile` line.
</Note>

Create a new `.dockerignore` file in the root of your project. This file contains the files and directories that should be *excluded* from the container image, such as `node_modules`. This makes your builds faster and smaller:

```docker .dockerignore icon="Docker" theme={"theme":{"light":"github-light","dark":"dracula"}}
node_modules
Dockerfile*
.dockerignore
.git
.gitignore
README.md
LICENSE
.vscode
.env
# Any other files or directories you want to exclude
```

</Step> <Step title="Deploy your service"> Make sure you're in the directory containing your `Dockerfile`, then deploy directly from your local source:

<Note>
  Update the `--region` flag to your preferred region. You can also omit this flag to get an interactive prompt to
  select a region.
</Note>

```bash terminal icon="terminal" theme={"theme":{"light":"github-light","dark":"dracula"}}
gcloud run deploy my-bun-app --source . --region=us-west1 --allow-unauthenticated
```

```txt  theme={"theme":{"light":"github-light","dark":"dracula"}}
Deploying from source requires an Artifact Registry Docker repository to store built containers. A repository named
[cloud-run-source-deploy] in region [us-west1] will be created.

Do you want to continue (Y/n)? Y

Building using Dockerfile and deploying container to Cloud Run service [my-bun-app] in project [my-bun-app-...] region [us-west1]
✓ Building and deploying... Done.
  ✓ Validating Service...
  ✓ Uploading sources...
  ✓ Building Container... Logs are available at [https://console.cloud.google.com/cloud-build/builds...].
  ✓ Creating Revision...
  ✓ Routing traffic...
  ✓ Setting IAM Policy...
Done.
Service [my-bun-app] revision [my-bun-app-...] has been deployed and is serving 100 percent of traffic.
Service URL: https://my-bun-app-....us-west1.run.app
```

</Step> <Step title="Visit your live application"> 🎉 Your Bun application is now live!

Visit the Service URL (`https://my-bun-app-....us-west1.run.app`) to confirm everything works as expected.

</Step> </Steps>