Running the Node.js Bookshelf app on Compute Engine

This tutorial shows how to run the Node.js Bookshelf sample app on Compute Engine. Follow this tutorial to deploy an existing Node.js web app to Compute Engine. It's recommended to work through the Bookshelf app documentation as part of the tutorial for the App Engine standard environment.


  • Deploy the Bookshelf sample app to a single Compute Engine instance.
  • Scale the app horizontally by using a managed instance group.
  • Serve traffic by using HTTP load balancing.
  • Respond to traffic changes by using autoscaling.


This tutorial uses the following billable components of Google Cloud Platform:

To generate a cost estimate based on your projected usage, use the pricing calculator. New GCP users might be eligible for a free trial.

When you finish this tutorial, you can avoid continued billing by deleting the resources you created. For more information, see Cleaning up.

Before you begin

  1. Sign in to your Google Account.

    If you don't already have one, sign up for a new account.

  2. Select or create a GCP project.

    Go to the project selector page

  3. Make sure that billing is enabled for your Google Cloud Platform project. Learn how to enable billing.

  4. Enable the Cloud Datastore API, Cloud Storage API, and Cloud Pub/Sub API APIs.

    Enable the APIs

  5. Install and initialize the Cloud SDK.
  6. Install Node.js and npm by using the official installer.

Initializing Cloud Datastore

The Bookshelf sample app uses Cloud Datastore to store the books. To initialize Cloud Datastore in your project for the first time:

  1. In the Google Cloud Platform Console, open Cloud Datastore.

    Open Cloud Datastore

  2. Select a region for your datastore, and then click Continue.

    When you reach the Create an Entity page, close the window. The Bookshelf app is ready to create entities on Cloud Datastore.

Creating a Cloud Storage bucket

The following instructions show how to create a Cloud Storage bucket. Buckets are the basic containers that hold your data in Cloud Storage.

  1. In a terminal window, enter the following command:

    gsutil mb gs://[YOUR-BUCKET-NAME]

    [YOUR-BUCKET-NAME] represents the name of your Cloud Storage bucket.

  2. To view uploaded images in the bookshelf app, set the bucket's default access control list (ACL) to public-read.

    gsutil defacl set public-read gs://[YOUR-BUCKET-NAME]

Creating a web app client ID

A web app client ID lets your app authorize users and access Google APIs.

  1. In the Google Cloud Platform Console, go to the Credentials page.

    Go to the Credentials page

  2. Click OAuth consent screen.

  3. For the product name, enter Node.js Bookshelf App.

  4. For Authorized domains, add your App Engine app name as [YOUR_PROJECT_ID]

    Replace [YOUR_PROJECT_ID] with your GCP project ID.

  5. Fill in any other relevant, optional fields, and then click Save.

  6. Click Create credentials > OAuth client ID.

  7. In the Application type drop-down list, click Web Application.

  8. In the Name field, enter Node.js Bookshelf Client.

  9. In the Authorized redirect URIs field, enter the following URLs, one at a time.


  10. Click Create.

  11. Copy the client ID and client secret and save them for later use.

Cloning the sample app

The sample app is available on GitHub at GoogleCloudPlatform/nodejs-getting-started.

  1. Clone the repository.

    git clone
  2. Go to the sample directory.

    cd nodejs-getting-started/7-gce

Configuring the app

In the sample directory, create a config.json file with this content:

  "DATA_BACKEND": "datastore",
  "OAUTH2_CALLBACK": "http://localhost:8080/auth/google/callback"


  • [YOUR_PROJECT_ID] is your project ID.
  • [YOUR_CLOUD_BUCKET] is the name of your Cloud Storage bucket.
  • [YOUR_OAUTH2_CLIENT_ID] is the app's client ID you created previously.
  • [YOUR_OAUTH2_CLIENT_SECRET] is the client secret you created previously.

Running the app on your local computer

  1. Install dependencies.

    npm install
  2. Run the app.

    npm start
  3. In your web browser, enter the following address.


To stop the local web server, press Control+C.

Deploying to a single instance

Single-instance deployment

This section walks you through running a single instance of your app on Compute Engine.

Push your code to a repository

You can use Cloud Source Repositories to create a Git repository in your project and upload your app's code there. Your instances can then pull the latest version of your app's code from the repository during startup. Using a Git repository is convenient because updating your app doesn't require configuring new images or instances; just restart an existing instance or create one.

If this is your first time using Git, use git config --global to set up your identity.

  1. In your GCP Console, create a repository:

    Create repository

  2. Push your app's code to your project's repository:

    git commit -am "Updating configuration"
    git config credential.helper
    git remote add cloud[YOUR_PROJECT_ID]/r/[YOUR_REPO]
    git push cloud master

    where [YOUR_PROJECT_ID] is your project ID and [YOUR_REPO] is the name of your repository.

Use a startup script to initialize an instance

Now that Compute Engine instances can access your code, you need a way to instruct your instance to download and run your code. An instance can have a startup script that runs whenever the instance is started or restarted.

Here is the startup script included in the Bookshelf sample app:

set -v

# Talk to the metadata server to get the project id
PROJECTID=$(curl -s "" -H "Metadata-Flavor: Google")

# Install logging monitor. The monitor will automatically pick up logs sent to
# syslog.
curl -s "" | bash
service google-fluentd restart &

# Install dependencies from apt
apt-get update
apt-get install -yq ca-certificates git build-essential supervisor

# Install nodejs
mkdir /opt/nodejs
curl | tar xvzf - -C /opt/nodejs --strip-components=1
ln -s /opt/nodejs/bin/node /usr/bin/node
ln -s /opt/nodejs/bin/npm /usr/bin/npm

# Get the application source code from the Google Cloud Repository.
# git requires $HOME and it's not set during the startup script.
export HOME=/root
git config --global credential.helper
git clone${PROJECTID}/r/${REPOSITORY} /opt/app

# Install app dependencies
cd /opt/app/7-gce
npm install

# Create a nodeapp user. The application will run as this user.
useradd -m -d /home/nodeapp nodeapp
chown -R nodeapp:nodeapp /opt/app

# Configure supervisor to run the node app.
cat >/etc/supervisor/conf.d/node-app.conf << EOF
command=npm start

supervisorctl reread
supervisorctl update

# Application should now be running under supervisor

The startup script performs the following tasks:

  • Installs the Logging agent. The agent automatically collects logs from syslog.

  • Installs Node.js and Supervisor. Supervisor runs the app as a daemon.

  • Clones the app's source code from Cloud Source Repositories and installs dependencies.

  • Configures Supervisor to run the app. Supervisor makes sure the app is restarted if it exits unexpectedly or is stopped by an admin or process. It also sends the app's stdout and stderr to syslog for the Logging agent to collect.

Create and configure a Compute Engine instance

  1. Create a Compute Engine instance.

    The following command creates an instance, allows it to access GCP services, and runs your startup script. The instance name is my-app-instance.


    gcloud compute instances create my-app-instance \
        --image-family=debian-9 \
        --image-project=debian-cloud \
        --machine-type=g1-small \
        --scopes userinfo-email,cloud-platform \
        --metadata app-location=$BOOKSHELF_DEPLOY_LOCATION \
        --metadata-from-file startup-script=gce/ \
        --zone us-central1-f \
        --tags http-server


    gcloud compute instances create my-app-instance ^
        --image-family=debian-9 ^
        --image-project=debian-cloud ^
        --machine-type=g1-small ^
        --scopes userinfo-email,cloud-platform ^
        --metadata-from-file startup-script=gce/ ^
        --zone us-central1-f ^
        --tags http-server

  2. Check the progress of the instance creation.

    gcloud compute instances get-serial-port-output my-app-instance --zone us-central1-f

    If the startup script has completed, Finished running startup script is displayed near the end of the command output.

  3. Create a firewall rule to allow traffic to your instance.


    gcloud compute firewall-rules create default-allow-http-8080 \
        --allow tcp:8080 \
        --source-ranges \
        --target-tags http-server \
        --description "Allow port 8080 access to http-server"


    gcloud compute firewall-rules create default-allow-http-8080 ^
        --allow tcp:8080 ^
        --source-ranges ^
        --target-tags http-server ^
        --description "Allow port 8080 access to http-server"

  4. Get the external IP address of your instance.

    gcloud compute instances list
  5. To see the app running, go to http://[YOUR_INSTANCE_IP]:8080,

    where [YOUR_INSTANCE_IP] is the external IP address of your instance.

Manage and monitor an instance

You can use the GCP Console to monitor and manage your instance.

  • To view the running instance and connect to it by using ssh, in GCP Console, go to the VM instances page.

    Go to the VM instances page

  • To view all of the logs generated by your Compute Engine resources, in GCP Console, go to the Logs page.

    Go to the Logs page

    Logging is automatically configured to gather logs from various common services, including syslog.

Horizontal scaling with multiple instances

Multiple-instance deployment with managed instances

Compute Engine can scale horizontally. By using a managed instance group and the Compute Engine Autoscaler, Compute Engine can automatically create instances of your app when needed and shut down instances when demand is low. You can set up an HTTP load balancer to distribute traffic to the instances in a managed instance group.

Deployment script

The sample app includes a script that automates the following deployment steps. The script named deploys the resources for a complete, autoscaled, load-balanced app as described in Horizontal scaling with multiple instances.

You can run each of the following steps yourself, or run gce/ from the gce directory.

Create a managed instance group

A managed instance group is a group of homogeneous instances based on the same instance template. An instance template defines the configuration of your instance, including source image, disk size, scopes, and metadata (including startup scripts).

  1. Create a template.

    gcloud compute instance-templates create $TEMPLATE \
      --image-family $IMAGE \
      --image-project=debian-cloud \
      --machine-type $MACHINE_TYPE \
      --scopes $SCOPES \
      --metadata-from-file startup-script=$STARTUP_SCRIPT \
      --tags $TAGS
  2. Create an instance group.

    gcloud compute instance-groups managed \
      create $GROUP \
      --base-instance-name $GROUP \
      --size $MIN_INSTANCES \
      --template $TEMPLATE \
      --zone $ZONE

    The --size parameter specifies the number of instances in the group. When all of the instances finish running their startup scripts, you can access the instances individually by using their external IP addresses and port 8080. To find the external IP addresses of the instances, enter gcloud compute instances list. The managed instances have names that start with the same prefix, my-app, which you specified in the --base-instance-name parameter.

Create a load balancer

An individual instance is fine for testing or debugging, but for serving web traffic it's better to use a load balancer to automatically direct traffic to available instances. To create a load balancer, follow these steps.

  1. Create a health check.

    The load balancer uses a health check to determine which instances are capable of serving traffic.

    gcloud compute http-health-checks create ah-health-check \
      --request-path /_ah/health \
      --port 8080
  2. Create a named port.

    The HTTP load balancer looks for the http service to know which port to direct traffic to. In your existing instance group, give port 8080 the name http.

    gcloud compute instance-groups managed set-named-ports \
        $GROUP \
        --named-ports http:8080 \
        --zone $ZONE
  3. Create a backend service.

    The backend service is the target for load-balanced traffic. It defines which instance group the traffic is directed to and which health check to use.

    gcloud compute backend-services create $SERVICE \
      --http-health-checks ah-health-check \
      --port-name http \
    gcloud compute http-health-checks create ah-health-check \
      --request-path /_ah/health \
      --port 8080
  4. Add the backend service.

    gcloud compute backend-services add-backend $SERVICE \
      --instance-group $GROUP \
      --instance-group-zone $ZONE \
  5. Create a URL map and proxy.

    The URL map defines which URLs are directed to which backend services. In this sample, all traffic is served by one backend service. If you want to load balance requests between multiple regions or groups, you can create multiple backend services. A proxy receives traffic and forwards it to backend services by using URL maps.

    1. Create the URL map.

      gcloud compute url-maps create $SERVICE-map \
        --default-service $SERVICE
    2. Create the proxy.

      gcloud compute target-http-proxies create $SERVICE-proxy \
        --url-map $SERVICE-map
  6. Create a global forwarding rule. The global forwarding rule ties a public IP address and port to a proxy.

    gcloud compute forwarding-rules create $SERVICE-http-rule \
      --global \
      --target-http-proxy $SERVICE-proxy \
      --ports 80

Configure the autoscaler

The load balancer ensures that traffic is distributed across all of your healthy instances. But what happens if there is too much traffic for your instances to handle? You could manually add more instances. But a better solution is to configure a Compute Engine autoscaler to automatically create and delete instances in response to traffic demands.

  1. Create an autoscaler.

    gcloud compute instance-groups managed set-autoscaling \
      $GROUP \
      --max-num-replicas $MAX_INSTANCES \
      --target-load-balancing-utilization $TARGET_UTILIZATION \
      --zone $ZONE

    The preceding command creates an autoscaler on the managed instance group that automatically scales up to 10 instances. Instances are added when the load balancer is above 50% utilization and are removed when utilization falls below 50%.

  2. Create a firewall rule.

    gcloud compute firewall-rules create default-allow-http-8080 \
        --allow tcp:8080 \
        --source-ranges \
        --target-tags http-server \
        --description "Allow port 8080 access to http-server"

  3. Check progress until at least one of your instances reports HEALTHY.

    gcloud compute backend-services get-health frontend-web-service --global

View your app

  1. Get the forwarding IP address for the load balancer.

    gcloud compute forwarding-rules list --global

    Your forwarding-rules IP address is in the IP_ADDRESS column.

  2. In a browser, enter the IP address from the list.

    Your load-balanced and autoscaled app is now running on Compute Engine.

Manage and monitor your deployment

You can use the GCP Console to monitor load balancing, autoscaling, and your managed instance group.

  • You can monitor and manage your instance group and autoscaling configuration on the Instance groups page of the GCP Console.

    Go to the Instance groups page

  • You can monitor and manage your load balancing configuration, including URL maps and backend services, on the Load balancing page of the GCP Console.

    Go to the Load balancing page

Cleaning up

To avoid incurring charges to your Google Cloud Platform account for the resources used in this tutorial:

Run the teardown script

If you ran the script, run the script to remove all resources created by the script. This returns your project to the state before running the script and helps to avoid further billing. To remove the single instance and the storage bucket created at the beginning of the tutorial, follow the instructions in the next section.

Delete resources manually

If you followed the steps in this tutorial manually, you can manually delete the cloud resources that you created.

Delete your load balancer

  1. In the GCP Console, go to the Load Balancing page.

    Go to the Load Balancing page

  2. Select the checkbox next to the load balancer that you want to delete, and then click Deletedelete.

  3. In the Delete load balancer dialog, select the associated backend service and health check resources, and then click Deletedelete. The load balancer and its associated resources are deleted.

Delete your Compute Engine managed instance group

To delete a Compute Engine instance group:

  1. In the GCP Console, go to the Instance groups page.

    Go to the Instance groups page

  2. Click the checkbox for the instance group you want to delete.
  3. Click Delete to delete the instance group.

Delete your single Compute Engine instance

To delete a Compute Engine instance:

  1. In the GCP Console, go to the VM Instances page.

    Go to the VM Instances page

  2. Click the checkbox for the instance you want to delete.
  3. Click Delete to delete the instance.

Delete your Cloud Storage bucket

To delete a Cloud Storage bucket:

  1. In the GCP Console, go to the Cloud Storage Browser page.

    Go to the Cloud Storage Browser page

  2. Click the checkbox for the bucket you want to delete.
  3. Click Delete to delete the bucket.

What's next

क्या यह पेज उपयोगी था? हमारे काम के बारे में अपनी राय दें:

निम्न के बारे में फ़ीडबैक भेजें...