Trigger functions from Pub/Sub using Eventarc

Required roles

You or your administrator must grant the deployer account, the trigger identity, and optionally, the Pub/Sub service agent and the Cloud Storage service agent the following IAM roles.

Create a Pub/Sub topic

In Cloud Run, Pub/Sub topics are not automatically created when you deploy a function. Before deploying your function, publish a message to this Pub/Sub topic to trigger the function:

gcloud  
pubsub  
topics  
create  
 YOUR_TOPIC_NAME 

Prepare the application

1. Clone the sample app repository to your local machine:

   Node.js

    git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git 
   

   Python

    git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git 
   

   Go

    git clone https://github.com/GoogleCloudPlatform/golang-samples.git 
   

   Java

    git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git 
   

   .NET

    git clone https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git 
   

   Ruby

    git clone https://github.com/GoogleCloudPlatform/ruby-docs-samples.git 
   

   PHP

    git clone https://github.com/GoogleCloudPlatform/php-docs-samples.git 
   

2. Change to the directory that contains the sample code for accessing Pub/Sub:

   Node.js

    cd nodejs-docs-samples/functions/v2/helloPubSub/ 
   

   Python

    cd python-docs-samples/functions/v2/pubsub/ 
   

   Go

    cd golang-samples/functions/functionsv2/hellopubsub/ 
   

   Java

    cd java-docs-samples/functions/v2/pubsub/ 
   

   .NET

    cd dotnet-docs-samples/functions/helloworld/HelloPubSub/ 
   

   Ruby

    cd ruby-docs-samples/functions/helloworld/pubsub/ 
   

   PHP

    cd php-docs-samples/functions/helloworld_pubsub/ 
   

3. Take a look at the sample code:

   Node.js

     const 
     
    functions 
     
    = 
     
    require 
    ( 
    '@google-cloud/functions-framework' 
    ); 
    // Register a CloudEvent callback with the Functions Framework that will 
    // be executed when the Pub/Sub trigger topic receives a message. 
    functions 
    . 
    cloudEvent 
    ( 
    'helloPubSub' 
    , 
     
    cloudEvent 
     
    = 
   >  
    { 
     
    // The Pub/Sub message is passed as the CloudEvent's data payload. 
     
    const 
     
    base64name 
     
    = 
     
    cloudEvent 
    . 
    data 
    . 
    message 
    . 
    data 
    ; 
     
    const 
     
    name 
     
    = 
     
    base64name 
     
    ? 
     
    Buffer 
    . 
    from 
    ( 
    base64name 
    , 
     
    'base64' 
    ). 
    toString 
    () 
     
    : 
     
    'World' 
    ; 
     
    console 
    . 
    log 
    ( 
    `Hello, 
    ${ 
    name 
    } 
    !` 
    ); 
    }); 
    
   

   Python

     import 
     
    base64 
    from 
     
    cloudevents.http 
     
    import 
    CloudEvent 
    import 
     
    functions_framework 
    # Triggered from a message on a Cloud Pub/Sub topic. 
    @functions_framework 
    . 
    cloud_event 
    def 
     
    subscribe 
    ( 
    cloud_event 
    : 
    CloudEvent 
    ) 
    - 
   > None 
    : 
    # Print out the data from Pub/Sub, to prove that it worked 
    print 
    ( 
    "Hello, " 
    + 
    base64 
    . 
    b64decode 
    ( 
    cloud_event 
    . 
    data 
    [ 
    "message" 
    ][ 
    "data" 
    ]) 
    . 
    decode 
    () 
    + 
    "!" 
    ) 
    
   

   Go

     // Package helloworld provides a set of Cloud Functions samples. 
    package 
     
    helloworld 
    import 
     
    ( 
     
    "context" 
     
    "fmt" 
     
    "log" 
     
    "github.com/GoogleCloudPlatform/functions-framework-go/functions" 
     
    "github.com/cloudevents/sdk-go/v2/event" 
    ) 
    func 
     
    init 
    () 
     
    { 
     
    functions 
    . 
    CloudEvent 
    ( 
    "HelloPubSub" 
    , 
     
    helloPubSub 
    ) 
    } 
    // MessagePublishedData contains the full Pub/Sub message 
    // See the documentation for more details: 
    // https://cloud.google.com/eventarc/docs/cloudevents#pubsub 
    type 
     
    MessagePublishedData 
     
    struct 
     
    { 
     
    Message 
     
    PubSubMessage 
    } 
    // PubSubMessage is the payload of a Pub/Sub event. 
    // See the documentation for more details: 
    // https://cloud.google.com/pubsub/docs/reference/rest/v1/PubsubMessage 
    type 
     
    PubSubMessage 
     
    struct 
     
    { 
     
    Data 
     
    [] 
    byte 
     
    `json:"data"` 
    } 
    // helloPubSub consumes a CloudEvent message and extracts the Pub/Sub message. 
    func 
     
    helloPubSub 
    ( 
    ctx 
     
    context 
    . 
    Context 
    , 
     
    e 
     
    event 
    . 
    Event 
    ) 
     
    error 
     
    { 
     
    var 
     
    msg 
     
    MessagePublishedData 
     
    if 
     
    err 
     
    := 
     
    e 
    . 
    DataAs 
    ( 
   & msg 
    ); 
     
    err 
     
    != 
     
    nil 
     
    { 
     
    return 
     
    fmt 
    . 
    Errorf 
    ( 
    "event.DataAs: %w" 
    , 
     
    err 
    ) 
     
    } 
     
    name 
     
    := 
     
    string 
    ( 
    msg 
    . 
    Message 
    . 
    Data 
    ) 
     
    // Automatically decoded from base64. 
     
    if 
     
    name 
     
    == 
     
    "" 
     
    { 
     
    name 
     
    = 
     
    "World" 
     
    } 
     
    log 
    . 
    Printf 
    ( 
    "Hello, %s!" 
    , 
     
    name 
    ) 
     
    return 
     
    nil 
    } 
    
   

   Java

     import 
     
    com.google.cloud.functions.CloudEventsFunction 
    ; 
    import 
     
    com.google.gson.Gson 
    ; 
    import 
     
    functions.eventpojos.PubSubBody 
    ; 
    import 
     
    io.cloudevents.CloudEvent 
    ; 
    import 
     
    java.nio.charset.StandardCharsets 
    ; 
    import 
     
    java.util.Base64 
    ; 
    import 
     
    java.util.logging.Logger 
    ; 
    public 
     
    class 
    SubscribeToTopic 
     
    implements 
     
    CloudEventsFunction 
     
    { 
     
    private 
     
    static 
     
    final 
     
    Logger 
     
    logger 
     
    = 
     
    Logger 
    . 
    getLogger 
    ( 
    SubscribeToTopic 
    . 
    class 
    . 
    getName 
    ()); 
     
    @Override 
     
    public 
     
    void 
     
    accept 
    ( 
    CloudEvent 
     
    event 
    ) 
     
    { 
     
    // The Pub/Sub message is passed as the CloudEvent's data payload. 
     
    if 
     
    ( 
    event 
    . 
    getData 
    () 
     
    != 
     
    null 
    ) 
     
    { 
     
    // Extract Cloud Event data and convert to PubSubBody 
     
    String 
     
    cloudEventData 
     
    = 
     
    new 
     
    String 
    ( 
    event 
    . 
    getData 
    (). 
    toBytes 
    (), 
     
    StandardCharsets 
    . 
    UTF_8 
    ); 
     
    Gson 
     
    gson 
     
    = 
     
    new 
     
    Gson 
    (); 
     
    PubSubBody 
     
    body 
     
    = 
     
    gson 
    . 
    fromJson 
    ( 
    cloudEventData 
    , 
     
    PubSubBody 
    . 
    class 
    ); 
     
    // Retrieve and decode PubSub message data 
     
    String 
     
    encodedData 
     
    = 
     
    body 
    . 
    getMessage 
    (). 
    getData 
    (); 
     
    String 
     
    decodedData 
     
    = 
     
    new 
     
    String 
    ( 
    Base64 
    . 
    getDecoder 
    (). 
    decode 
    ( 
    encodedData 
    ), 
     
    StandardCharsets 
    . 
    UTF_8 
    ); 
     
    logger 
    . 
    info 
    ( 
    "Hello, " 
     
    + 
     
    decodedData 
     
    + 
     
    "!" 
    ); 
     
    } 
     
    } 
    } 
    
   

   .NET

     using 
     
    CloudNative.CloudEvents 
    ; 
    using 
     
    Google.Cloud.Functions.Framework 
    ; 
    using 
     
    Google.Events.Protobuf.Cloud.PubSub.V1 
    ; 
    using 
     
    Microsoft.Extensions.Logging 
    ; 
    using 
     
    System.Threading 
    ; 
    using 
     
    System.Threading.Tasks 
    ; 
    namespace 
     
    HelloPubSub 
    ; 
    public 
     
    class 
     
    Function 
     
    : 
     
    ICloudEventFunction<MessagePublishedData> 
    { 
     
    private 
     
    readonly 
     
    ILogger 
     
    _logger 
    ; 
     
    public 
     
    Function 
    ( 
    ILogger<Function> 
     
    logger 
    ) 
     
    = 
   >  
    _logger 
     
    = 
     
    logger 
    ; 
     
    public 
     
    Task 
     
    HandleAsync 
    ( 
    CloudEvent 
     
    cloudEvent 
    , 
     
    MessagePublishedData 
     
    data 
    , 
     
    CancellationToken 
     
    cancellationToken 
    ) 
     
    { 
     
    string 
     
    nameFromMessage 
     
    = 
     
    data 
    . 
    Message 
    ?. 
    TextData 
    ; 
     
    string 
     
    name 
     
    = 
     
    string 
    . 
    IsNullOrEmpty 
    ( 
    nameFromMessage 
    ) 
     
    ? 
     
    "world" 
     
    : 
     
    nameFromMessage 
    ; 
     
    _logger 
    . 
    LogInformation 
    ( 
    "Hello {name}" 
    , 
     
    name 
    ); 
     
    return 
     
    Task 
    . 
    CompletedTask 
    ; 
     
    } 
    } 
    
   

   Ruby

     require 
     
    "functions_framework" 
    require 
     
    "base64" 
    FunctionsFramework 
    . 
    cloud_event 
     
    "hello_pubsub" 
     
    do 
     
    | 
    event 
    | 
     
    # The event parameter is a CloudEvents::Event::V1 object. 
     
    # See https://cloudevents.github.io/sdk-ruby/latest/CloudEvents/Event/V1.html 
     
    name 
     
    = 
     
    Base64 
    . 
    decode64 
     
    event 
    . 
    data 
    [ 
    "message" 
    ][ 
    "data" 
    ] 
     
    rescue 
     
    "World" 
     
    # A cloud_event function does not return a response, but you can log messages 
     
    # or cause side effects such as sending additional events. 
     
    logger 
    . 
    info 
     
    "Hello, 
    #{ 
    name 
    } 
    !" 
    end 
    
   

   PHP

     use CloudEvents\V1\CloudEventInterface; 
    use Google\CloudFunctions\FunctionsFramework; 
    // Register the function with Functions Framework. 
    // This enables omitting the `FUNCTIONS_SIGNATURE_TYPE=cloudevent` environment 
    // variable when deploying. The `FUNCTION_TARGET` environment variable should 
    // match the first parameter. 
    FunctionsFramework::cloudEvent('helloworldPubsub', 'helloworldPubsub'); 
    function helloworldPubsub(CloudEventInterface $event): void 
    { 
    $log = fopen(getenv('LOGGER_OUTPUT') ?: 'php://stderr', 'wb'); 
    $cloudEventData = $event->getData(); 
    $pubSubData = base64_decode($cloudEventData['message']['data']); 
    $name = $pubSubData ? htmlspecialchars($pubSubData) : 'World'; 
    fwrite($log, "Hello, $name!" . PHP_EOL); 
    } 
    
   

Deploy an event-driven function

To deploy the function, run the following command in the directory that contains the sample code:

 gcloud run deploy FUNCTION 
\
        --source . \
        --function helloPubSub \
        --base-image BASE_IMAGE 
\ 

 gcloud run deploy FUNCTION 
\
        --source . \
        --function subscribe \
        --base-image BASE_IMAGE 
\ 

 gcloud run deploy FUNCTION 
\
        --source . \
        --function HelloPubSub \
        --base-image BASE_IMAGE 
\ 

 gcloud run deploy FUNCTION 
\
        --source . \
        --function functions.SubscribeToTopic \
        --base-image BASE_IMAGE 
\ 

 gcloud run deploy FUNCTION 
\
        --source . \
        --function HelloPubSub.Function \
        --base-image BASE_IMAGE 
\ 

 gcloud run deploy FUNCTION 
\
        --source . \
        --function hello_pubsub \
        --base-image BASE_IMAGE 
\ 

 gcloud run deploy FUNCTION 
\
        --source . \
        --function helloworldPubsub \
        --base-image BASE_IMAGE 
\ 

If you are prompted to create a repository in the specified region, respond by pressing y . When the deployment is complete, the Google Cloud CLI displays a URL where the service is running.

Create an Eventarc trigger

To deploy the function with a Pub/Sub trigger, run the following command in the directory that contains the sample code:

1. Create an Eventarc Pub/Sub trigger:

   gcloud  
   eventarc  
   triggers  
   create  
    TRIGGER_NAME 
     
    \ 
     
   --location = 
    ${ 
    REGION 
    } 
     
    \ 
     
   --destination-run-service = 
    FUNCTION 
     
    \ 
     
   --destination-run-region = 
    ${ 
    REGION 
    } 
     
    \ 
     
   --event-filters = 
    "type=google.cloud.pubsub.topic.v1.messagePublished" 
     
    \ 
     
   --service-account = 
    PROJECT_NUMBER 
   -compute@developer.gserviceaccount.com

   Replace:

   • TRIGGER_NAME with the name for your trigger.
   • FUNCTION with the name of your function.
   • PROJECT_NUMBER with your Google Cloud project number.

   Note that when creating an Eventarc trigger for the first time in a Google Cloud project, there might be a delay in provisioning the Eventarc service agent. This issue can usually be resolved by attempting to create the trigger again. For more information, see Permission denied errors .

2. Confirm that the trigger was successfully created. Note that although your trigger is created immediately, it can take up to two minutes for a trigger to be fully functional.

   gcloud  
   eventarc  
   triggers  
   list  
   --location = 
    ${ 
    REGION 
    } 
   

   The output should be similar to the following:

    NAME: helloworld-events
   TYPE: google.cloud.pubsub.topic.v1.messagePublished
   DESTINATION: Cloud Run service: helloworld-events
   ACTIVE: Yes
   LOCATION: us-central1 
   

Trigger the function

To test the Pub/Sub function:

1. Assign the topic to a variable:

    TOPIC_ID=$(gcloud eventarc triggers describe TRIGGER_NAME 
   --location $REGION --format='value(transport.pubsub.topic)') 
   

2. Publish a message to the topic:

    gcloud pubsub topics publish $TOPIC_ID --message="Hello World" 
   

The Cloud Run service logs the body of the incoming message. You can view this in the Logs section of your Cloud Run instance:

1. Navigate to the Google Cloud console .
2. Click the function.

3. Select the Logstab.

   Logs might take a few moments to appear. If you don't see them immediately, check again after a few moments.

4. Look for the "Hello World!" message.