
### Create `Index.js` Entry Point file

Create `Index.js` file andd add below code, it'll get the dependency package from `'@google-cloud/functions-framework'`, create the endpoint with `cloudEvent`, and log all the request `event` variable 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 `@google-cloud/functions-framework` for GCP Cloud Function

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

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

### Deploy to GCP Cloud

#### Create Pub/Sub Topic

Before deploy the Node.js cloud to GCP cloud, we'll need to create pub/sub topic. We'll use below command to create topic as `my_topic`.

```
gcloud pubsub topics create my_topic
```

#### Deploy Cloud Function via local environment

Below is the code for deploy Node.js code to GCP Cloud, run this at the same source code directory, make sure `entry-point` is the name written in the `index.js` and `trigger-topic` is the one we just create, `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 verify cloud function deploy successfully at local environment, we can publish message and verify the logs at cloud later.
Run below command at local to send 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 at Cloud Function log tab, the below data field should store the actual message we send earlier and encoded with base64, to read the message either you can either use online tools to decode the text back from base64 or in the actual application you can decode the `message.data` for additional process.
![Test Cloud Function Event Trigger Logs](/images/gcp-cloud-function-event-trigger/img1.png)

### Trigger Event with Cloud Scheduler

We have setup the Node.js App trigger with GCP Pub/Sub, so we can also use the `Cloud Scheduler` to run the Node.js app regularly.
The blow command will setup the GCP Cloud Scheduler run every minutes and send message as `from_scheduler`.
This design can help in case if you have any regular process need to run in a Schedule fashion, run as every minutes or 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"
```


This blog create simple Node.js and deploy to GCP Cloud Function as PubSub Event Trigger.

Deploy GCP Cloud Function with Event Trigger via PubSub


### Create `Index.js` Entry Point file

Create `Index.js` file andd add below code, it'll 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 `@google-cloud/functions-framework` for GCP Cloud Function

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

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

### Run at local

Add this if wish to test the GCP Cloud Function at the local environment, by default will be using the port `8080`, type `http://8080` so you can the the cloud function locally.

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

### Deploy to GCP Cloud

After test the cloud function at local, when ready you can run below command to deploy the code to the GCP Cloud Function.

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

### Test the HTTP end point

If the deploy run well, you should see the new HTTP Cloud Functions as below, and if you copy the URL to run at browser, should be see the `ok` at your page.
![Test Cloud Function Http End Point](/images/gcp-cloud-function-http-trigger/img1.png)


This blog create simple Node.js and deploy to GCP Cloud Function as Http Trigger.

Deploy GCP Cloud Function with Http Trigger

## TypeScript + Node.js + CloudFunction + FireStore

This blog try to demo how to deploy a `Google Cloud Function` that will interact with `fireStore` NOSQL database, and use `TypeScript` for static typing at development, and instead of use CI/CD pipeline will just use `husky` at local to gard and watch the quality of the code and deploy to the Google cloud locally.

## Pre Requirement

Before we start writing the code, there're few pre requirement are not include in this blog but require the application to run.

- GCP Account/Project - make sure has active GCP account and GCP project setup.
- Firebase Account/Project - Your fireBase should connect with GCP, logged on to the Firebase and find the fireStore.
- Run `gcloud config list` - to make sure your local environment are connect to the correct project.

## Setup npm repo

Now, let's get started, first we'll need to initialize the npm repo by run the following command on your local. This will create `package.json` file with default setting.

```
npm init -y
```

## Install dependencies packages

We'll install following dependencies packages since we'll interact with firebase.

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

## Install dev dependencies packages

Install following package during the build time, such as typescript for static typing and eslint for syntax analyzer.

```
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 start file.

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

## Start writing Code `index.ts`

let's create a file `index.ts` under root folder, and add following code. These are import some package we'll use later, the `firebase-functions/v2` will use the Google Cloud Function gen2, which will have 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 use the fireStore, so add following code.

```Javascript
initializeApp();

const db = getFirestore();
```

Finally, we'll hook with firebase's `functions` to listen to the request, no inside the `onRequest` will be add our main logic, which either get data from fireStore or some update or delete operations.

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

 console.info('on request');

 });
```

### Create `tsconfig.json`

Since we have our first code is ready, let's create our first `tfconfig.json` to compile the typescript into javascript. We'll also add following command to the `package.json`'s `scripts` section.

Once run the `npm run build`, so our code will start to compile the `index.ts` and create javascript file under the `dist/index.js`.

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

### Ready to Deploy Code

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

### Deploy from Local

In this blog, we don't have lots developer works on the same repo, when many ppl work on the same repository it'll be better to use CI/CD with git pull request so whenever some one create new pull request to the main branch can start continue integration and deploy the latest code to the correct environment.

So instead we'll add following `gcloud` command to the `scripts` section, when you ready to deploy to the google cloud, we can just run the `npm run deploy`, which will set the gcloud project and deploy 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 with fireStore

That'a all for create typescript for cloud function and interact with fireStore and deploy locally.

### Other choice?

Since we use `fireStore`, which is part of `firebase`, we could use firebase's `firebase-tools` to generate list of files to support typescript, now when use with `firebase` tools, to setup the cloud function, few setting you'll have to follow with firebase's setting.

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, once I don't like is that `exports.main` limit the name can be define, use `glcoud` to define the function name, entry point, or gen2 are much more easlier than the `firebase`'s settings.

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

### Conclusion

Use `firebase`'s `firebase-tools` could simply setup typescript for firebase cloud function, and after tried a while use `gcloud` has maximum flexibility compare with `firebase-tools`, it could be improve but at this point I feel just use the `typescript` is much more easier.

This blog show how to setup TypeScript with CloudFunction and Deploy to Google Cloud locally

Use TypeScript with Google CloudFunction and Deploy locally


## Pre Requirement

This blog will focus on how to use the Google Cloud Function to handler CURD operation with Cloud Firestore. Below is the simple diagram of the process, but before we start you'll need prepare below list to make sure it is ready

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

- have GCP account
- setup GCP project
- setup GCP fireStore collection
- create a service account and add `Cloud Datastore Owner` and download to the local repo folder

## Setup npm repo

Now, let's get started, first we'll need to initialize the npm repo by run the following command on your local. This will create `package.json` file with default setting.

```
npm init -y
```

Next, install the `@google-cloud/functions-framework` so can test the cloud function locally later.

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

To test locally, will need to add following task to the `package.json` as well.

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

Also, will install the following npm package `firebase-admin` so will be able to communicate with `firebase` and `fireStore`.

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

## Adding code to interact with fireStore

Once we have the npm package installed, we can start adding code.
First, let's create a file `index.js`, and will add the following code to start handle CRUD with fireStore.

Here, we'll initialize the fireStore and add service account json, so we can communicate with fireStore from local environment.

```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),
});
```

## Start prepare the CRUD operation

We'll create following operation at this blog, a basic CRUD operation from 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 step, we'll handle the http get for the read operation, here we check http method is `GET`, and has the querystring `docid`.

```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's looks like once we run the `npm run start` to test on my local with postman.
![Cloud Functions to Firestore](/images/crud-firestore-with-cloudfunction-nodejs/img2.png)

## Create Data - [HTTP POST]

For create data, we'll expect the http is `POST` and body has below JSON object structure.

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

Once get the `request.body`, we'll set as showing below, basically using the `fireStore`'s `set` function, which can be using as create or update for the target collection's document.

```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's looks like once we run the `npm run start` to test on my local with postman.
![HTTP Post with fireStore](/images/crud-firestore-with-cloudfunction-nodejs/img3.png)

## Update Data - [HTTP PUT]

Here we'll continue using the `set` function for the update operation.

```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's looks like once we run the `npm run start` to test on my local with postman.
![HTTP Put with fireStore](/images/crud-firestore-with-cloudfunction-nodejs/img4.png)

## Delete Data - [HTTP DELETE]

For the delete we'll just expect the querystring passing the `docid` and use `delete` for remove 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's looks like once we run the `npm run start` to test on my local with postman.
![HTTP Delete with fireStore](/images/crud-firestore-with-cloudfunction-nodejs/img5.png)

## The whole `index.js` file for CRUD operation

This below snippet contains the all the CRUD code we just mentioned earlier.

```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 the `gcloud` to deploy from your local or tight with CI/CD, or deploy from cloud bucket as zip file, but here we'll just deploy from your local folder to the cloud.

below is the sample command that deploy to the google cloud function as name with `my-firestore-function` and other options, once it is done, should be seen a URL from the console or you can find your cloud function, if you browser the URL with the querystring `docid`, now should be seen JSON response from the fireStore database.

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

## Conclusion

Above are few steps that demonstrate how to use cloud function as HTTP(S) request server and communicate with fireStore NoSQL database as back-end server. Both Google cloud function and fireStore are serverless and host in the cloud, so you can focus your business logic and no need to worry about the underneath server.


This blog show how to do CRUD operation with Firestore and Google Cloud Function

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


### About this article

If you have used the Google Cloud Function, you'll notice how easy it can deploy code and without worry the backend managed services by Google, so you can focus on development, at this blog will focus on how to manage traffic and revision once you have to deploy more different version.

### Pre Requirement

At this blog, we'll assume you already have deploy one cloud function on the cloud and everything is working, you are planning to deploy next version, however you don't want current production's version to be replaced, depend on how you configure right now, overtime when you deploy to google cloud, it might become the latest version.

### So, how can you achieve?

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

**Uncheck Serve this revision immediately**
Now, uncheck this one so that every time when deploy new cloud function, it won't serve as latest immediately.

### Manage Traffic

Now, since you check the above checkbox, new version won't serve traffic, but you have to manually click the `Actions` af your new version to manually split the traffic.


If you have used the Google Cloud Function, you'll notice how easy it can deploy code and without worry the backend managed services by Google, so you can focus on development, at this blog will focus on how to manage traffic and revision once you have to deploy more different version.

How to Manage Traffic with Cloud Function and Manage Revision


## About Cloud Functions

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

## GCP Account

First, you'll need GCP account, once you have already should be able to process the below steps.

## Create Node.js function for Cloud Functions

This command will create `package.json` file.

```
npm init -y
```

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

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

Create our first Node.js function `index.js`, in side the `index.js` file we'll add following code, simply just return the message hello.

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

## How to Test Cloud Function in local

Add following section to the `package.json` file's script section and run the `npm run start`.
Now, should be see the `URL: http://localhost:8080`, so that will host the code to our code exist at `index.js`, since we specify the method is `main`, so will run our first `main` function and you should be see the `hello` from the browser

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

## How to Deploy Cloud Function to the Cloud

After tested on your local, you're ready and want to deploy the function to the cloud, this section will show how to run the `gcloud` command at the local environment and deploy to the cloud.

### Config `gcloud`

Now, to run `gcloud` command at local, you'll need to configure first. If you already config before, you can run the `gcloud config list` to verify the `account` and `project` is point to the correct one, cause you don't want to accidentally deploy to the wrong GCP account.

If you have not setup before, you can run the `gcloud init` to authenticate with GCP account.
Once confirmed you have config to the correct environment, you can run below command at the root folder your `index.js`.

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

So, these options are pretty straightforward setting, `gcloud functions deploy` is the command to deploy, `my-first-function` will be the name of the functions shows on the Cloud Functions alter, `trigger-http` mean this will works as HTTP(S) request, `runtime` specify what's the version of the app during the build, `entry-point` is the main function cloud function will run.
Also, `gen2` is next version of the Cloud Functions, provide longer request processing and handler more regions and fast rollback.

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

Also, the url will provide HTTP(S) endpoint, so if you run the URL, it will execute the cloud function we just deployed and return 'hello'.

## glcoud function deploy options

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

## Conclusion

This blog covered how to setup fireStore, and how to use Node.js to interact with fireStore with different operations.


This blog demo how to get start with Cloud Function with 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.

Category CloudFunction