Cloud Pub/Sub Tutorial (1st gen)

Preparing the application

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

   Node.js

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

   Alternatively, you can download the sample as a zip file and extract it.

   Python

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

   Alternatively, you can download the sample as a zip file and extract it.

   Go

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

   Alternatively, you can download the sample as a zip file and extract it.

   Java

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

   Alternatively, you can download the sample as a zip file and extract it.

   Ruby

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

   Alternatively, you can download the sample as a zip file and extract it.

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

   Node.js

   cd nodejs-docs-samples/functions/helloworld/

   Python

   cd python-docs-samples/functions/helloworld/

   Go

   cd golang-samples/functions/helloworld/

   Java

   cd java-docs-samples/functions/helloworld/hello-pubsub/

   Ruby

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

3. Take a look at the sample code:

   Node.js

     /** 
    * Background Cloud Function to be triggered by Pub/Sub. 
    * This function is exported by index.js, and executed when 
    * the trigger topic receives a message. 
    * 
    * @param {object} message The Pub/Sub message. 
    * @param {object} context The event metadata. 
    */ 
    exports 
    . 
    helloPubSub 
     
    = 
     
    ( 
    message 
    , 
     
    context 
    ) 
     
    = 
   >  
    { 
     
    const 
     
    name 
     
    = 
     
    message 
    . 
    data 
     
    ? 
     
    Buffer 
    . 
    from 
    ( 
    message 
    . 
    data 
    , 
     
    'base64' 
    ). 
    toString 
    () 
     
    : 
     
    'World' 
    ; 
     
    console 
    . 
    log 
    ( 
    `Hello, 
    ${ 
    name 
    } 
    !` 
    ); 
    }; 
    
   

   Python

     def 
     
    hello_pubsub 
    ( 
    event 
    , 
    context 
    ): 
     
    """Background Cloud Function to be triggered by Pub/Sub. 
    Args: 
    event (dict):  The dictionary with data specific to this type of 
    event. The `@type` field maps to 
    `type.googleapis.com/google.pubsub.v1.PubsubMessage`. 
    The `data` field maps to the PubsubMessage data 
    in a base64-encoded string. The `attributes` field maps 
    to the PubsubMessage attributes if any is present. 
    context (google.cloud.functions.Context): Metadata of triggering event 
    including `event_id` which maps to the PubsubMessage 
    messageId, `timestamp` which maps to the PubsubMessage 
    publishTime, `event_type` which maps to 
    `google.pubsub.topic.publish`, and `resource` which is 
    a dictionary that describes the service API endpoint 
    pubsub.googleapis.com, the triggering topic's name, and 
    the triggering event type 
    `type.googleapis.com/google.pubsub.v1.PubsubMessage`. 
    Returns: 
    None. The output is written to Cloud Logging. 
    """ 
    import 
     
    base64 
    print 
    ( 
     
    """This Function was triggered by messageId {} published at {} to {} 
    """ 
    . 
    format 
    ( 
    context 
    . 
    event_id 
    , 
    context 
    . 
    timestamp 
    , 
    context 
    . 
    resource 
    [ 
    "name" 
    ] 
    ) 
    ) 
    if 
    "data" 
    in 
    event 
    : 
    name 
    = 
    base64 
    . 
    b64decode 
    ( 
    event 
    [ 
    "data" 
    ]) 
    . 
    decode 
    ( 
    "utf-8" 
    ) 
    else 
    : 
    name 
    = 
    "World" 
    print 
    ( 
    f 
    "Hello 
    { 
    name 
    } 
    !" 
    ) 
    
   

   Go

     // Package helloworld provides a set of Cloud Functions samples. 
    package 
     
    helloworld 
    import 
     
    ( 
     
    "context" 
     
    "log" 
    ) 
    // 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 Pub/Sub message. 
    func 
     
    HelloPubSub 
    ( 
    ctx 
     
    context 
    . 
    Context 
    , 
     
    m 
     
    PubSubMessage 
    ) 
     
    error 
     
    { 
     
    name 
     
    := 
     
    string 
    ( 
    m 
    . 
    Data 
    ) 
     
    // Automatically decoded from base64. 
     
    if 
     
    name 
     
    == 
     
    "" 
     
    { 
     
    name 
     
    = 
     
    "World" 
     
    } 
     
    log 
    . 
    Printf 
    ( 
    "Hello, %s!" 
    , 
     
    name 
    ) 
     
    return 
     
    nil 
    } 
    
   

   Java

     import 
     
    com.google.cloud.functions.BackgroundFunction 
    ; 
    import 
     
    com.google.cloud.functions.Context 
    ; 
    import 
     
    functions.eventpojos.PubsubMessage 
    ; 
    import 
     
    java.nio.charset.StandardCharsets 
    ; 
    import 
     
    java.util.Base64 
    ; 
    import 
     
    java.util.logging.Level 
    ; 
    import 
     
    java.util.logging.Logger 
    ; 
    public 
     
    class 
    HelloPubSub 
     
    implements 
     
    BackgroundFunction<PubsubMessage> 
     
    { 
     
    private 
     
    static 
     
    final 
     
    Logger 
     
    logger 
     
    = 
     
    Logger 
    . 
    getLogger 
    ( 
    HelloPubSub 
    . 
    class 
    . 
    getName 
    ()); 
     
    @Override 
     
    public 
     
    void 
     
    accept 
    ( 
    PubsubMessage 
     
    message 
    , 
     
    Context 
     
    context 
    ) 
     
    { 
     
    String 
     
    name 
     
    = 
     
    "world" 
    ; 
     
    if 
     
    ( 
    message 
     
    != 
     
    null 
    && 
    message 
    . 
    getData 
    () 
     
    != 
     
    null 
    ) 
     
    { 
     
    name 
     
    = 
     
    new 
     
    String 
    ( 
     
    Base64 
    . 
    getDecoder 
    (). 
    decode 
    ( 
    message 
    . 
    getData 
    (). 
    getBytes 
    ( 
    StandardCharsets 
    . 
    UTF_8 
    )), 
     
    StandardCharsets 
    . 
    UTF_8 
    ); 
     
    } 
     
    logger 
    . 
    info 
    ( 
    String 
    . 
    format 
    ( 
    "Hello %s!" 
    , 
     
    name 
    )); 
     
    return 
    ; 
     
    } 
    } 
    
   

   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 
    
   

Deploying the function

To deploy the function with a Pub/Sub trigger, run the following command in the directory that contains the sample code (or in the case of Java, the pom.xml file):

gcloud functions deploy helloPubSub \
--runtime nodejs20 \
--trigger-topic YOUR_TOPIC_NAME 

gcloud functions deploy hello_pubsub \
--runtime python312 \
--trigger-topic YOUR_TOPIC_NAME 

gcloud functions deploy HelloPubSub \
--runtime go121 \
--trigger-topic YOUR_TOPIC_NAME 

gcloud functions deploy java-pubsub-function \
--entry-point functions.HelloPubSub \
--runtime java17 \
--memory 512MB \
--trigger-topic YOUR_TOPIC_NAME 

gcloud  
functions  
deploy  
hello_pubsub  
--runtime  
ruby33  
 \
- 
-trigger-topic  
 YOUR_TOPIC_NAME 

where YOUR_TOPIC_NAME is the name of the Pub/Sub topic to which the function will be subscribed.

If YOUR_TOPIC_NAME doesn't already exist, this command creates it for you. You can also create a topic before you run the deploy command, using either the Google Cloud console or the following gcloud command:

gcloud  
pubsub  
topics  
create  
  YOUR_TOPIC_NAME 
 

Triggering the function

1. Publish a message to your Pub/Sub topic. In this example, the message is a name that the function will include in a greeting:

   gcloud  
   pubsub  
   topics  
   publish  
     YOUR_TOPIC_NAME 
    
     
   --message  
     YOUR_NAME 
    
   

   Replace YOUR_TOPIC_NAME with the name of your Pub/Sub topic, and YOUR_NAME with an arbitrary string.

2. Check the logs to be sure the executions have completed:

   gcloud  
   functions  
   logs  
    read 
     
   --limit  
    50 
   

You can also publish a message to a Pub/Sub topic from within a function .