Specifying dependencies in Node.js

A function is allowed to use external Node.js modules as well as local data. Dependencies in Node.js are managed with npm and expressed in a metadata file called package.json. The Cloud Functions Node.js runtimes generally support installing using npm or yarn.

To specify a dependency for your function, add it to your package.json file.

In this example, a dependency is listed in the package.json file:

{
  "dependencies": {
    "uuid": "^3.0.1"
  }
}

The dependency is then imported in the function:

const uuid = require('uuid');

// Return a newly generated UUID in the HTTP response.
exports.getUuid = (req, res) => {
  res.send(uuid.v4());
};

Installing dependencies during deployment

When you deploy your function, Cloud Functions installs dependencies declared in the package.json file using the npm install command:

npm install --production

In the Node.js 8 runtime and higher, if a yarn.lock file exists, Cloud Functions instead uses the yarn install command:

yarn install --production

Executing custom build steps during deployment

During deployment, before starting your application, you can perform a custom build step by adding a gcp-build script in your package.json file.

When this script is executed, the dependencies in the dependencies and devDependencies fields of your package.json file are available. After executing your custom build step, Cloud Functions removes and regenerates the node_modules folder by only installing the production dependencies declared in the dependencies field of your package.json file.

If there is no gcp-build script in package.json, Cloud Functions just installs production dependencies.

Using system packages

The Node.js runtime also includes a number of system packages in the execution environment. If your function uses a dependency that requires a package that is not listed, you can request a package.

Including local Node.js modules as part of your deployment package

You can also include local Node.js modules as part of your function. You can achieve this by declaring your module in package.json using the file: prefix. In the following example, mymodule refers to your module name and mymoduledir is the directory containing your module:

{
  "dependencies": {
    "mymodule": "file:mymoduledir"
  }
}

The code for this local module should not be in your node_modules folder. You can simply store it at the root of your function's directory.

Using npm to install Node.js modules locally

The easiest way to install a Node.js module locally is to use the npm install command in the folder containing your Cloud Function. For instance, the following command adds the uuid module:

npm install uuid

This combines two steps:

  1. It marks the latest version of the module as a dependency in your package.json file. This is very important: Cloud Functions only installs modules that are declared in your package.json file.
  2. It downloads the module into your node_modules directory. This lets you use the module when developing locally.

If you don't have npm installed on your machine, get npm.

Loading Node.js modules

Use the Node.js require() function to load any Node.js module you have installed. You can also use the require() function to import local files you deploy alongside your function.

Using private modules

In order to use a private npm module, you must provide credentials (auth token) for the npm registry in a .npmrc file located in the function's directory. The npm documentation explains how to create custom read-only access tokens. We discourage using the .npmrc file created in the home directory because it contains a read-write token. Write permissions are not required during deployment, and could pose a security risk.

Do not include the .npmrc file if you're not using private repositories, as it can increase the deployment time for your functions.

Was this page helpful? Let us know how we did:

Send feedback about...

Cloud Functions Documentation