
## Table of Contents

- [Introduction](#introduction)
- [Create Index.js Entry Point File](#create-indexjs-entry-point-file)
- [Include Dependency Package for GCP Cloud Function](#include-dependency-package-for-gcp-cloud-function)
- [Deploy to GCP Cloud](#deploy-to-gcp-cloud)
  - [Create Pub/Sub Topic](#create-pubsub-topic)
  - [Deploy Cloud Function via Local Environment](#deploy-cloud-function-via-local-environment)
- [Send Pub/Sub Message](#send-pubsub-message)
- [Verify the Logs](#verify-the-logs)
- [Trigger Event with Cloud Scheduler](#trigger-event-with-cloud-scheduler)
- [Conclusion](#conclusion)

## Introduction

This blog shows how to create a simple Node.js application and deploy it to GCP Cloud Functions as a Pub/Sub Event Trigger.

## Create Index.js Entry Point File

Create an `Index.js` file and add the below code. It will get the dependency package from `'@google-cloud/functions-framework'`, create the endpoint with `cloudEvent`, and log all the request `event` variables to the log so we can verify later on.

```Javascript
const functions = require('@google-cloud/functions-framework');

functions.cloudEvent('myEvent', event => {

    console.info('test_data', event);

});
```

## Include Dependency Package for GCP Cloud Function

Since we'll use the package for GCP Cloud Functions, we need to add this dependency package in the `package.json` file.

```Javascript
"dependencies": {
    "@google-cloud/functions-framework": "^3.3.0"
}
```

## Deploy to GCP Cloud

### Create Pub/Sub Topic

Before deploying the Node.js code to GCP Cloud, we'll need to create a Pub/Sub topic. We'll use the below command to create a topic called `my_topic`.

```
gcloud pubsub topics create my_topic
```

### Deploy Cloud Function via Local Environment

Below is the command for deploying Node.js code to GCP Cloud. Run this in the same source code directory. Make sure `entry-point` is the name written in `index.js` and `trigger-topic` is the one we just created, `my_topic`.

```bash
gcloud functions deploy myEventTriggerFunction --gen2 --region=us-central1 --runtime=nodejs18 --entry-point=myEvent --trigger-topic=my_topic --allow-unauthenticated
```

## Send Pub/Sub Message

After verifying the cloud function deployed successfully, we can publish a message and verify the logs in the cloud later. Run the below command locally to send a test message to our topic.

```bash
gcloud pubsub topics publish my_topic --message="my first message"
```

## Verify the Logs

Now, if everything works as expected, we should see the logs in the Cloud Function log tab. The data field below should store the actual message we sent earlier, encoded with Base64. To read the message, you can either use online tools to decode the text from Base64, or in the actual application you can decode `message.data` for additional processing.

![Test Cloud Function Event Trigger Logs](/images/gcp-cloud-function-event-trigger/img1.png)

## Trigger Event with Cloud Scheduler

We have set up the Node.js app to trigger with GCP Pub/Sub, so we can also use Cloud Scheduler to run the Node.js app regularly. The below command will set up GCP Cloud Scheduler to run every minute and send a message as `from_scheduler`. This design can help in case you have any regular process that needs to run on a schedule — every minute, every hour, or maybe once a day.

```
gcloud scheduler jobs create pubsub my_job --location=us-central1 --schedule="* * * * *" --topic="my_topic" --message-body="from_scheduler"
```

## Conclusion

By following these steps, you can deploy a GCP Cloud Function with a Pub/Sub event trigger and optionally automate it with Cloud Scheduler. This pattern is useful for building event-driven architectures where functions respond to messages published to a topic.


This blog shows how to create a simple Node.js app and deploy it to GCP Cloud Functions as a Pub/Sub event trigger.

Deploy GCP Cloud Function with Event Trigger via PubSub


## Table of Contents

- [Introduction](#introduction)
- [Create Index.js Entry Point File](#create-indexjs-entry-point-file)
- [Include Dependency Package for GCP Cloud Function](#include-dependency-package-for-gcp-cloud-function)
- [Run at Local](#run-at-local)
- [Deploy to GCP Cloud](#deploy-to-gcp-cloud)
- [Test the HTTP Endpoint](#test-the-http-endpoint)
- [Conclusion](#conclusion)

## Introduction

This blog shows how to create a simple Node.js application and deploy it to GCP Cloud Functions as an HTTP trigger.

## Create Index.js Entry Point File

Create an `Index.js` file and add the below code. It will get the dependency package from `'@google-cloud/functions-framework'`, create the endpoint, and return the response as `'ok'`.

```Javascript
const functions = require('@google-cloud/functions-framework');

functions.http('myHttpFunctionName', (req, res) => {
    res.send('ok');
});
```

## Include Dependency Package for GCP Cloud Function

Since we'll use the package for GCP HTTP Cloud Functions, we need to add this dependency package in the `package.json` file.

```Javascript
"dependencies": {
    "@google-cloud/functions-framework": "^3.3.0"
}
```

## Run at Local

Add this if you wish to test the GCP Cloud Function in the local environment. By default it will use port `8080`. Type `http://localhost:8080` so you can test the cloud function locally.

```Javascript
"scripts": {
    "start": "npx functions-framework --target=myHttpFunctionName [--signature-type=http]",
}
```

## Deploy to GCP Cloud

After testing the cloud function locally, when you're ready you can run the below command to deploy the code to GCP Cloud Functions.

```bash
gcloud functions deploy myHttpCloudFunctionName --gen2 --region=us-central1 --runtime=nodejs18 --entry-point=myHttpFunctionName --trigger-http --allow-unauthenticated
```

## Test the HTTP Endpoint

If the deployment runs successfully, you should see the new HTTP Cloud Function as shown below. If you copy the URL and run it in a browser, you should see `ok` on the page.

![Test Cloud Function Http End Point](/images/gcp-cloud-function-http-trigger/img1.png)

## Conclusion

Deploying a GCP Cloud Function with an HTTP trigger is straightforward. By setting up the entry point, adding the required dependency, and running the deploy command, you can quickly have a serverless HTTP endpoint running in the cloud.


This blog shows how to create a simple Node.js app and deploy it to GCP Cloud Functions as an HTTP trigger.

Deploy GCP Cloud Function with Http Trigger


## Table of Contents

1. [Introduction](#introduction)
2. [Prerequisites](#prerequisites)
3. [Setup npm Repository](#setup-npm-repository)
4. [Adding Code to Interact with Firestore](#adding-code-to-interact-with-firestore)
5. [Prepare the CRUD Operations](#prepare-the-crud-operations)
6. [Read Data - HTTP GET](#read-data---http-get)
7. [Create Data - HTTP POST](#create-data---http-post)
8. [Update Data - HTTP PUT](#update-data---http-put)
9. [Delete Data - HTTP DELETE](#delete-data---http-delete)
10. [Complete index.js File](#the-complete-indexjs-file-for-crud-operations)
11. [Deploy to the Cloud](#deploy-nodejs-code-to-the-cloud)
12. [Conclusion](#conclusion)

## Introduction

This blog focuses on how to use Google Cloud Functions to handle CRUD operations with Cloud Firestore. Cloud Functions act as the HTTP server, while Firestore serves as the NoSQL database backend. Both services are serverless and hosted in the cloud, so you can focus on your business logic without worrying about server management.

## Prerequisites

Before we start, you will need to prepare the following:

![Cloud Functions to Firestore](/images/crud-firestore-with-cloudfunction-nodejs/img1.png)

- A GCP (Google Cloud Platform) account
- A GCP project set up
- A Firestore collection configured in your GCP project
- A service account with the `Cloud Datastore Owner` role, with the key file downloaded to your local repository folder

## Setup npm Repository

First, initialize the npm repository by running the following command. This will create a `package.json` file with default settings.

```
npm init -y
```

Next, install `@google-cloud/functions-framework` so you can test the Cloud Function locally.

```
npm install --save-dev @google-cloud/functions-framework
```

To test locally, add the following script to your `package.json`:

```
"start": "npx functions-framework --target=main [--signature-type=http]"
```

Also, install the `firebase-admin` package so you can communicate with Firebase and Firestore.

```
npm install --save firebase-admin
```

## Adding Code to Interact with Firestore

Once the npm packages are installed, we can start adding code. Create a file called `index.js` and add the following code to initialize Firestore with the service account credentials.

```javascript
const { initializeApp, cert } = require("firebase-admin/app");
const { getFirestore } = require("firebase-admin/firestore");

const serviceAccount = require("./service-account-has-fireStore-role.json");
initializeApp({
  credential: cert(serviceAccount),
});
```

## Prepare the CRUD Operations

We will create the following basic CRUD operations from the Cloud Function to the Firestore database:

- **Read Data** - [HTTP GET] - `http://localhost:8080/?docid=800`
- **Create Data** - [HTTP POST] - `http://localhost:8080/`

```json
{
  "docid": "2000",
  "id": "test_10",
  "list": [1, 2, 3]
}
```

- **Update Data** - [HTTP PUT] - `http://localhost:8080/?docid=800`

```json
{
  "id": "test_10",
  "list": [1, 2, 3]
}
```

- **Delete Data** - [HTTP DELETE] - `http://localhost:8080/?docid=800`

## Read Data - HTTP GET

First, we handle the HTTP GET request for the read operation. Here we check that the HTTP method is `GET` and that the `docid` query string parameter is provided.

```javascript
exports.main = (req, res) => {

if (req.method === 'GET') {
    if (!req.query.docid) {
        return res.status(404).send('');
    }

    db.collection('my_collection').doc(req.query.docid.toString()).get()
    .then(doc => {
        return res.status(200).send(doc.data());
    });
}
```

Below is how it looks when we run `npm run start` and test with Postman.
![Cloud Functions to Firestore](/images/crud-firestore-with-cloudfunction-nodejs/img2.png)

## Create Data - HTTP POST

For creating data, we expect the HTTP method to be `POST` and the request body to contain the following JSON structure:

```json
{
  "docid": "200",
  "id": "test_10",
  "list": [10, 20, 30, 40]
}
```

Once we receive the `request.body`, we use Firestore's `set` function to create or update the document in the target collection.

```javascript
exports.main = (req, res) => {

    else if (req.method === 'POST') {

        db.collection('my_collection')
        .doc(req.body.docid)
        .set({
            id: req.body.id,
            list: req.body.list
        })
        .then((doc) => {
            return res.status(200).send(doc);
        });
    }
```

Below is how it looks when we run `npm run start` and test with Postman.
![HTTP Post with Firestore](/images/crud-firestore-with-cloudfunction-nodejs/img3.png)

## Update Data - HTTP PUT

For the update operation, we continue using the `set` function with the document ID passed as a query string parameter.

```javascript
exports.main = (req, res) => {

    else if (req.method === 'PUT') {
        db.collection('my_collection')
        .doc(req.query.docid)
        .set({
            id: req.body.id,
            list: req.body.list
        })
        .then((result) => {
            return res.status(200).send(result);
        });
    }
```

Below is how it looks when we run `npm run start` and test with Postman.
![HTTP Put with Firestore](/images/crud-firestore-with-cloudfunction-nodejs/img4.png)

## Delete Data - HTTP DELETE

For the delete operation, we expect the `docid` to be passed as a query string parameter and use the `delete` method to remove the document from the Firestore database.

```javascript
exports.main = (req, res) => {

    else if (req.method === 'DELETE') {
        db.collection('my_collection')
        .doc(req.query.docid).delete()
        .then((result) => {
            return res.status(200).send(result);
        });
    }
```

Below is how it looks when we run `npm run start` and test with Postman.
![HTTP Delete with Firestore](/images/crud-firestore-with-cloudfunction-nodejs/img5.png)

## The Complete `index.js` File for CRUD Operations

The following snippet contains all the CRUD code mentioned earlier in a single file.

```javascript
const {
  initializeApp,
  applicationDefault,
  cert,
} = require("firebase-admin/app");
const {
  getFirestore,
  Timestamp,
  FieldValue,
} = require("firebase-admin/firestore");

const serviceAccount = require("./none-firebase-admin-firm-champion-365105-f0d88d6192e2.json");

initializeApp({
  credential: cert(serviceAccount),
});

const db = getFirestore();

exports.main = (req, res) => {
  if (req.method === "GET") {
    if (!req.query.docid) {
      return res.status(404).send("");
    }

    db.collection("my_collection")
      .doc(req.query.docid.toString())
      .get()
      .then((doc) => {
        return res.status(200).send(doc.data());
      });
  } else if (req.method === "POST") {
    db.collection("my_collection")
      .doc(req.body.docid)
      .set({
        id: req.body.id,
        list: req.body.list,
      })
      .then((doc) => {
        return res.status(200).send(doc);
      });
  } else if (req.method === "PUT") {
    db.collection("my_collection")
      .doc(req.query.docid)
      .set({
        id: req.body.id,
        list: req.body.list,
      })
      .then((result) => {
        return res.status(200).send(result);
      });
  } else if (req.method === "DELETE") {
    db.collection("my_collection")
      .doc(req.query.docid)
      .delete()
      .then((result) => {
        return res.status(200).send(result);
      });
  }
};
```

## Deploy Node.js Code to the Cloud

For deployment, you can use `gcloud` to deploy from your local machine, integrate with CI/CD, or deploy from a cloud bucket as a zip file. In this example, we will deploy directly from your local folder to the cloud.

Below is the sample command that deploys the function named `my-firestore-function` to Google Cloud Functions:

```
gcloud functions deploy my-firestore-function --trigger-http --region=us-central1 --runtime=nodejs16 --gen2 --allow-unauthenticated --entry-point=main
```

Once the deployment is complete, you should see a URL in the console output. You can also find your Cloud Function URL in the GCP Console. If you browse to the URL with the `docid` query string parameter, you should see a JSON response from the Firestore database.

## Conclusion

This guide demonstrated how to use Google Cloud Functions as an HTTP server to perform CRUD operations with Cloud Firestore as the backend database. Key takeaways:

1. **Cloud Functions** handle HTTP requests (GET, POST, PUT, DELETE) for each CRUD operation
2. **Firestore's `set` method** can be used for both creating and updating documents
3. **Local testing** is possible using the `functions-framework` before deploying to the cloud
4. Both Cloud Functions and Firestore are **serverless**, so you can focus on your business logic without managing servers


This blog shows how to perform CRUD operations with Cloud Firestore using Google Cloud Functions and Node.js.

CRUD with Cloud Firestore and Node.js by Google Cloud Function


## Table of Contents

1. [Introduction](#introduction)
2. [About Cloud Functions](#about-cloud-functions)
3. [GCP Account](#gcp-account)
4. [Create Node.js Function for Cloud Functions](#create-nodejs-function-for-cloud-functions)
5. [How to Test Cloud Function Locally](#how-to-test-cloud-function-locally)
6. [How to Deploy Cloud Function to the Cloud](#how-to-deploy-cloud-function-to-the-cloud)
7. [gcloud Function Deploy Options](#gcloud-function-deploy-options)
8. [Conclusion](#conclusion)

## Introduction

Google's Cloud Functions let you run code and deploy to the cloud with no servers or containers to maintain. In this blog, we'll write our first cloud function and deploy it to the cloud.

## About Cloud Functions

Google's `Cloud Functions` let you run code and deploy to GCP with no servers or containers you need to maintain. This makes it ideal for lightweight, event-driven workloads.

## GCP Account

First, you'll need a GCP account. Once you have one, you should be able to proceed with the steps below.

## Create Node.js Function for Cloud Functions

This command will create a `package.json` file.

```
npm init -y
```

Then run this command to install the package `@google-cloud/functions-framework` for testing cloud functions locally.

```
npm install --save-dev @google-cloud/functions-framework
```

Create our first Node.js function `index.js`. Inside the `index.js` file, we'll add the following code, which simply returns the message "hello".

```
exports.main = (req, res) => {
    res
    .status(200)
    .send('hello');
}
```

## How to Test Cloud Function Locally

Add the following section to the `package.json` file's script section and run `npm run start`.
You should see `URL: http://localhost:8080`, which will host the code from `index.js`. Since we specified the method as `main`, it will run our `main` function, and you should see "hello" in the browser.

```
"scripts": {
    "start": "npx functions-framework --target=main [--signature-type=http]"
},
```

## How to Deploy Cloud Function to the Cloud

After testing locally, you're ready to deploy the function to the cloud. This section will show how to run the `gcloud` command from the local environment and deploy to the cloud.

### Config gcloud

To run `gcloud` commands locally, you'll need to configure it first. If you've already configured it before, you can run `gcloud config list` to verify that the `account` and `project` point to the correct ones, because you don't want to accidentally deploy to the wrong GCP account.

If you have not set it up before, you can run `gcloud init` to authenticate with your GCP account.
Once you've confirmed the configuration points to the correct environment, you can run the following command at the root folder containing your `index.js`.

```
gcloud functions deploy my-first-function --trigger-http --region=us-central1 --runtime=nodejs16 --gen2 --allow-unauthenticated --entry-point=main
```

These options are pretty straightforward: `gcloud functions deploy` is the command to deploy, `my-first-function` will be the name of the function shown on the Cloud Functions console, `trigger-http` means this will work as an HTTP(S) request, `runtime` specifies the version of the app during the build, and `entry-point` is the main function Cloud Functions will run.
Also, `gen2` is the next version of Cloud Functions, providing longer request processing, support for more regions, and faster rollback.

At this point, if the above `gcloud functions deploy` command runs successfully, you should see a "done" message on your console along with other information, such as build, label, or the options you specified.

Also, the URL will provide an HTTP(S) endpoint. If you visit the URL, it will execute the cloud function we just deployed and return "hello".

## gcloud Function Deploy Options

For all other options for deploying cloud functions, you can reference the official documentation here: [gcloud functions deploy](https://cloud.google.com/sdk/gcloud/reference/functions/deploy).

## Conclusion

This blog covered how to create a Cloud Function with Node.js, test it locally using the functions framework, and deploy it to Google Cloud using the `gcloud` CLI. With Cloud Functions, you can quickly deploy serverless code without managing infrastructure.


This blog demonstrates how to get started with Cloud Functions using Node.js and how to deploy to the cloud.

How to Deploy Cloud Functions with Node.js


## About .gcloudignore file

When you deploy Node.js code to the google cloud functions, you can run the code from your local environment by run below command.

So this command will deploy the current folder's entire source code to the cloud function, by default will also create a `.gcloudignore` file and you'll notice the file itself and `node_modules` are also in the file, so that way these files won't be deploy to the cloud.

```
gcloud functions deploy my-first-function --trigger-http --region=us-central1 --runtime=nodejs16 --gen2 --allow-unauthenticated --entry-point=main
```

So if you want to ignore other files, you can add these to the `.gcloudignore` as well, for instance, `readme.md` file if you have any.


THis blog show couple example code/command that how to interact with google cloud functions.

Use .gcloudignore to Ignore files deploy to the Cloud Functions

## Table of Contents

1. [Introduction](#introduction)
2. [Prerequisites](#prerequisites)
3. [Setup npm Repo](#setup-npm-repo)
4. [Install Dependencies Packages](#install-dependencies-packages)
5. [Install Dev Dependencies Packages](#install-dev-dependencies-packages)
6. [Update Main Field at package.json](#update-main-field-at-packagejson)
7. [Start Writing Code index.ts](#start-writing-code-indexts)
8. [Create tsconfig.json](#create-tsconfigjson)
9. [Ready to Deploy Code](#ready-to-deploy-code)
10. [Deploy from Local](#deploy-from-local)
11. [TypeScript Deployment with Cloud Function and Firestore](#typescript-deployment-with-cloud-function-and-firestore)
12. [Other Choices](#other-choices)
13. [Conclusion](#conclusion)

## Introduction

This blog tries to demonstrate how to deploy a `Google Cloud Function` that will interact with `Firestore` NoSQL database, using `TypeScript` for static typing at development. Instead of using a CI/CD pipeline, we will use `husky` locally to guard and watch the quality of the code and deploy to Google Cloud locally.

## Prerequisites

Before we start writing the code, there are a few prerequisites not included in this blog but required for the application to run.

- GCP Account/Project - make sure you have an active GCP account and GCP project set up.
- Firebase Account/Project - Your Firebase should connect with GCP. Log on to Firebase and find the Firestore.
- Run `gcloud config list` - to make sure your local environment is connected to the correct project.

## Setup npm Repo

Now, let's get started. First we'll need to initialize the npm repo by running the following command on your local machine. This will create a `package.json` file with default settings.

```
npm init -y
```

## Install Dependencies Packages

We'll install the following dependency packages since we'll interact with Firebase.

```
npm install --save firebase-admin firebase-functions
```

## Install Dev Dependencies Packages

Install the following packages during build time, such as TypeScript for static typing and ESLint for syntax analysis.

```
npm install --save-dev typescript @typescript-eslint/eslint-plugin @typescript-eslint/parser eslint eslint-config-google eslint-plugin-import firebase-functions-test
```

## Update `main` Field at `package.json`

Update the `package.json` for the start file.

```
"main": "dist/index.js",
```

## Start Writing Code `index.ts`

Let's create a file `index.ts` under the root folder and add the following code. These imports bring in packages we'll use later. The `firebase-functions/v2` will use Google Cloud Functions gen2, which has better performance.

```Javascript
import * as functions from "firebase-functions/v2";
import {initializeApp} from "firebase-admin/app";
import {getFirestore} from "firebase-admin/firestore";
```

Next, we'll initialize the app and start using Firestore, so add the following code.

```Javascript
initializeApp();

const db = getFirestore();
```

Finally, we'll hook into Firebase's `functions` to listen to the request. Now inside the `onRequest` we will add our main logic, which can either get data from Firestore or perform update or delete operations.

```Javascript
exports.main = functions
 .https.onRequest(async (request, response) => {

 console.info('on request');

 });
```

## Create `tsconfig.json`

Since our first code is ready, let's create our `tsconfig.json` to compile the TypeScript into JavaScript. We'll also add the following command to the `package.json`'s `scripts` section.

Once you run `npm run build`, the code will start to compile `index.ts` and create a JavaScript file under `dist/index.js`.

```
"scripts": {
 "build": "tsc"
}
```

## Ready to Deploy Code

So that's all we need for now. We should be able to continue adding code to the TypeScript file `index.ts` and use the simple TypeScript build by running `npm run build` to compile the TypeScript into JavaScript, ready to deploy to production.

## Deploy from Local

In this blog, we don't have many developers working on the same repo. When many people work on the same repository, it's better to use CI/CD with git pull requests so that whenever someone creates a new pull request to the main branch, continuous integration can start and deploy the latest code to the correct environment.

So instead, we'll add the following `gcloud` command to the `scripts` section. When you are ready to deploy to Google Cloud, we can just run `npm run deploy`, which will set the gcloud project and deploy the Cloud Function.

```JSON
"scripts": {
 "deploy": "npm run deploy:project && npm run deploy:run",
 "deploy:project": "gcloud config set project set-to-the-correct-project-id",
 "deploy:run": "gcloud functions deploy your-cloud-function-name --trigger-http --region=us-central1 --runtime=nodejs16 --gen2 --allow-unauthenticated --entry-point=main --run-service-account=service-account-can-run-the-cloud-function"
}
```

## TypeScript Deployment with Cloud Function and Firestore

That's all for creating a TypeScript Cloud Function that interacts with Firestore and deploying locally.

## Other Choices

Since we use `Firestore`, which is part of `Firebase`, we could use Firebase's `firebase-tools` to generate a list of files to support TypeScript. When using `firebase-tools` to set up the Cloud Function, there are a few settings you'll have to follow with Firebase's configuration.

set node.js version

```Json
"engines": {
 "node": "16"
}
```

set region

```Javascript
functions.setGlobalOptions({
 region: 'us-west1-a'
});
```

set gen2

```Javascript
import * as functions from "firebase-functions/v2";
```

set function name

Now, following is how you set the function name. One thing I don't like is that `exports.main` limits the name that can be defined. Using `gcloud` to define the function name, entry point, or gen2 is much easier than Firebase's settings.

```Javascript
exports.main = functions
```

## Conclusion

Using Firebase's `firebase-tools` can simplify setting up TypeScript for Firebase Cloud Functions. After trying both approaches, using `gcloud` has maximum flexibility compared with `firebase-tools`. It could improve, but at this point I feel just using `TypeScript` directly with `gcloud` is much easier.

This blog shows how to set up TypeScript with Cloud Functions and deploy to Google Cloud locally.

Use TypeScript with Google CloudFunction and Deploy locally


## Table of Contents

1. [Introduction](#introduction)
2. [Prerequisites](#prerequisites)
3. [How to Achieve This](#how-to-achieve-this)
4. [Manage Traffic](#manage-traffic)
5. [Conclusion](#conclusion)

## Introduction

If you have used Google Cloud Functions, you'll notice how easy it is to deploy code without worrying about backend managed services, since Google handles that for you so you can focus on development. This blog will focus on how to manage traffic and revisions once you need to deploy different versions.

## Prerequisites

In this blog, we'll assume you already have a cloud function deployed on the cloud and everything is working. You are planning to deploy the next version; however, you don't want the current production version to be replaced. Depending on how you have configured things, every time you deploy to Google Cloud, the new deployment might become the latest version automatically.

## How to Achieve This

**Go to Cloud Run**
Go to the cloud function, then click `Powered by Cloud Run` to navigate to Cloud Run, and click `EDIT & DEPLOY NEW REVISION`.

**Uncheck Serve this revision immediately**
Uncheck this option so that every time you deploy a new cloud function, it won't serve as the latest version immediately.

## Manage Traffic

Since you unchecked the above checkbox, the new version won't serve traffic automatically. You have to manually click the `Actions` on your new version to manually split the traffic.

## Conclusion

By unchecking the "Serve this revision immediately" option in Cloud Run, you can deploy new versions of your Cloud Function without automatically replacing the current production version. This gives you full control over traffic splitting between revisions, enabling safer deployments and gradual rollouts.


This blog focuses on how to manage traffic and revisions for Google Cloud Functions, so you can deploy new versions without replacing the current production version.