To create, update, or perform other administrative actions on a function, you must have an account that is a member that has an appropriate role. See Authorizing Access via IAM for more information.
But invoking a function can be a more complex event. Background functions can only be invoked by the event source to which they are subscribed, but HTTP functions can be invoked by different kinds of identities, originating in different places. The invoker might be a developer who is testing the function or another function or service that wishes to use the function. By default, these identities must authenticate themselves (provide proof of their identity) as well as have the appropriate permissions. Unauthenticated access is possible, but must be enabled. See Managing Access via IAM for more information.
Authenticating Developer Testing
As a developer, you need access to create, update, and delete functions, and this is granted using the normal (IAM) process.
But as a developer you are also likely to need to invoke your functions for
testing purposes. To invoke a function using curl
or similar tools, you must:
Have the account you are using to access Cloud Functions assigned a role that contains the
cloudfunctions.functions.invoke
permission. By default, the Cloud Functions Admin and Cloud Functions Developer roles have this permission. See Cloud Functions IAM Roles for the full list of roles and their associated permissions.If you are working from your local machine, set up command line access by initializing the Google Cloud SDK. Make sure you have downloaded the service account key and set your GOOGLE_APPLICATION_CREDENTIALS environment variable.
Provide authentication credentials in your request as a Google-generated ID token stored in an
Authorization
header. For example, you might get a token viagcloud
as follows:curl https://REGION-PROJECT_ID.cloudfunctions.net/FUNCTION_NAME \ -H "Authorization: bearer $(gcloud auth print-identity-token)"
As always, we recommend that you allocate the minimum set of permissions required to develop and use your functions. Make sure that IAM policies on your functions are limited to the minimum number of users and service accounts.
Authenticating function to function calls
When building services that connect multiple functions, it's a good idea to
ensure that each function can only send requests to a specific subset of your other functions.
For instance, if you have a login
function, it should be able to access the
user profiles
function, but it probably shouldn't be able to access the
search
function.
To configure the receiving function to accept requests from a specific calling function,
you need to add the calling function's service account as a member on the
receiving function and grant that member the Cloud Functions Invoker
(roles/cloudfunctions.invoker
) role. The process is the same as adding any
other member to the function.
Console
Go to the Google Cloud Console:
Click the checkbox next to the receiving function.
Click Permissions at the top of the screen. The Permissions panel opens.
Click Add member.
In the New members field, enter the identity of the calling function. This should be a service account email.
Select the role Cloud Functions > Cloud Functions Invoker from the Select a role drop-down menu.
Click Save.
GCloud
Use the gcloud functions add-iam-policy-binding
command:
gcloud functions add-iam-policy-binding RECEIVING_FUNCTION \ --member='serviceAccount:CALLING_FUNCTION_IDENTITY' \ --role='roles/cloudfunctions.invoker'
where RECEIVING_FUNCTION
is the name of the receiving
function and CALLING_FUNCTION_IDENTITY
is the calling function
identity, a service account email.
Because it will be invoking the receiving function, the calling function must also provide a Google-signed ID token to authenticate. This is a two step process:
Create a Google-signed ID token with the audience field (
aud
) set to the URL of the receiving function.Include the ID token in an
Authorization: Bearer ID_TOKEN
header in the request to the function.
By far the easiest and most reliable way to manage this process is to use the authentication libraries, as shown below, to generate and employ this token. This code works anywhere the libraries can authenticate, including using Application Default Credentials locally.
Node.js
Python
Go
Java
Generating tokens manually
If you're invoking a function and for some reason you cannot use the authentication libraries, there are two ways you can get the ID token manually, either using the Compute metadata server or by creating a self-signed JWT and exchanging it for a Google-signed ID token.
Using the metadata server
You can use the Compute metadata server to fetch ID tokens with a specific audience as follows:
curl "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity?audience=[AUDIENCE]" \
-H "Metadata-Flavor: Google"
Where AUDIENCE is the URL of the function you are invoking, such as
https://GCP_REGION-PROJECT_ID.cloudfunctions.net/my-function
.
Exchanging a self-signed JWT for a Google-signed ID token
Assign the calling function's service account the Cloud Functions Invoker (
roles/cloudfunctions.invoker
) role.Add this service account as a member to the receiving function.
Create a service account and a key and download the file with the private key (in JSON format) to the host from which the calling function or service makes its requests.
Create a JWT with the header set to
{"alg":"RS256","typ":"JWT"}
. The payload should include atarget_audience
claim set to the URL of the receiving function andiss
andsub
claims set to the email address of the service account used above. It should also includeexp
, andiat
claims. Theaud
claim should be set tohttps://www.googleapis.com/oauth2/v4/token
.Use the private key downloaded above to sign the JWT.
Using this JWT, send a POST request to https://www.googleapis.com/oauth2/v4/token. Authentication data must be included in the header and the body of the request.
In the header:
Authorization: Bearer $JWT - where $JWT is the JWT you just created Content-Type: application/x-www-form-urlencoded
In the body:
grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer&assertion=$JWT
Replace
$JWT
with the JWT you just createdThis returns another JWT which includes an
id_token
signed by Google.
Send your GET/POST request to the receiving function. Include the Google-signed
ID token in an Authorization: Bearer ID_TOKEN_JWT
header
in the request.