Como escrever Cloud Functions

O Google Cloud Functions pode ser escrito em Node.js, Python e Go e executado em ambientes de execução específicos de uma linguagem. O ambiente de execução do Cloud Functions varia de acordo com o ambiente de execução escolhido. As páginas de visão geral do ambiente de execução fornecem mais detalhes sobre cada ambiente de ambiente de execução:

Tipos de Cloud Functions

Existem dois tipos diferentes de Cloud Functions: funções HTTP e funções em segundo plano.

Funções HTTP

As funções HTTP são invocadas de solicitações HTTP padrão. Essas solicitações HTTP aguardam a resposta e são compatíveis com o processamento de métodos de solicitação HTTP comuns, como GET, PUT, POST, DELETE e OPTIONS. Quando você usa o Cloud Functions, um certificado TLS é provisionado automaticamente para você, portanto, todas as funções HTTP podem ser invocadas por meio de uma conexão segura.

Para detalhes, consulte Como escrever Funções HTTP.

Exemplo:

Node.js

const escapeHtml = require('escape-html');

/**
 * HTTP Cloud Function.
 *
 * @param {Object} req Cloud Function request context.
 *                     More info: https://expressjs.com/en/api.html#req
 * @param {Object} res Cloud Function response context.
 *                     More info: https://expressjs.com/en/api.html#res
 */
exports.helloHttp = (req, res) => {
  res.send(`Hello ${escapeHtml(req.query.name || req.body.name || 'World')}!`);
};

Python

from flask import escape

def hello_http(request):
    """HTTP Cloud Function.
    Args:
        request (flask.Request): The request object.
        <http://flask.pocoo.org/docs/1.0/api/#flask.Request>
    Returns:
        The response text, or any set of values that can be turned into a
        Response object using `make_response`
        <http://flask.pocoo.org/docs/1.0/api/#flask.Flask.make_response>.
    """
    request_json = request.get_json(silent=True)
    request_args = request.args

    if request_json and 'name' in request_json:
        name = request_json['name']
    elif request_args and 'name' in request_args:
        name = request_args['name']
    else:
        name = 'World'
    return 'Hello {}!'.format(escape(name))

Go


// Package helloworld provides a set of Cloud Functions samples.
package helloworld

import (
	"encoding/json"
	"fmt"
	"html"
	"net/http"
)

// HelloHTTP is an HTTP Cloud Function with a request parameter.
func HelloHTTP(w http.ResponseWriter, r *http.Request) {
	var d struct {
		Name string `json:"name"`
	}
	if err := json.NewDecoder(r.Body).Decode(&d); err != nil {
		fmt.Fprint(w, "Hello, World!")
		return
	}
	if d.Name == "" {
		fmt.Fprint(w, "Hello, World!")
		return
	}
	fmt.Fprintf(w, "Hello, %s!", html.EscapeString(d.Name))
}

Funções de segundo plano

É possível usar funções de segundo plano para processar eventos da infraestrutura do Cloud, como mensagens em um tópico Pub/Sub ou alterações em um intervalo do Cloud Storage.

Para detalhes, consulte Como escrever Funções em segundo plano.

Exemplo:

Node.js 8+

/**
 * Background Cloud Function.
 *
 * @param {object} data The event payload.
 * @param {object} context The event metadata.
 */
exports.helloBackground = (data, context) => {
  return `Hello ${data.name || 'World'}!`;
};

Node.js 6 (obsoleto)

/**
 * Background Cloud Function.
 *
 * @param {object} event The Cloud Functions event.
 * @param {function} callback The callback function.
 */
exports.helloBackground = (event, callback) => {
  callback(null, `Hello ${event.data.name || 'World'}!`);
};

Python

def hello_background(event, context):
    """Background Cloud Function.
    Args:
         event (dict): The dictionary with data specific to the given event.
         context (google.cloud.functions.Context): The Cloud Functions event
         metadata.
    """
    if event and 'name' in event:
        name = event['name']
    else:
        name = 'World'
    return 'Hello {}!'.format(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.
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)
	if name == "" {
		name = "World"
	}
	log.Printf("Hello, %s!", name)
	return nil
}

Como estruturar o código-fonte

Para que o Cloud Functions encontre a definição da sua função, cada ambiente de execução tem requisitos de estruturação para o código-fonte:

Node.js

Para os tempos de execução do Node.js, o código-fonte da função precisa ser exportado de um módulo Node.js, que o Cloud Functions carrega usando uma chamada require(). Para determinar qual módulo carregar, o Cloud Functions usa o campo main no seu arquivo package.json. Se o campo main não for especificado, o Cloud Functions carregará o código de index.js.

Por exemplo, as seguintes configurações do código-fonte são válidas:

  • Um único arquivo index.js na raiz do seu projeto que exporta uma ou mais funções:

    .
    └── index.js
    
  • Um arquivo index.js que importa o código de um arquivo foo.js e, em seguida, exporta uma ou mais funções:

    .
    ├── index.js
    └── foo.js
    
  • Um arquivo app.js que exporta uma ou mais funções, com um arquivo package.json que contém "main": "app.js":

    .
    ├── app.js
    └── package.json
    

Python

Para um ambiente de execução do Python, o ponto de entrada da sua função precisa ser definido em um arquivo de origem do Python na raiz do seu projeto chamado main.py.

Por exemplo, as seguintes configurações do código-fonte são válidas:

  • Um único arquivo main.py na raiz do seu projeto que define uma ou mais funções:

    .
    └── main.py
    
  • Um arquivo main.py com um arquivo requirements.txt que especifica dependências:

    .
    ├── main.py
    └── requirements.txt
    
  • Um arquivo main.py que importa o código de uma dependência local:

    .
    ├── main.py
    └── mylocalpackage/
        ├── __init__.py
        └── myscript.py
    

Go

Para o ambiente de execução do Go, sua função precisa estar em um pacote Go na raiz do projeto. Sua função não pode estar em package main. Subpacotes só são compatíveis quando se usa módulos Go.

Por exemplo, as seguintes configurações do código-fonte são válidas:

  • Um pacote na raiz do projeto que exporta uma ou mais funções:

    .
    └── function.go
    
  • Um pacote na raiz do projeto que importa código de um subpacote e exporta uma ou mais funções:

    .
    ├── function.go
    ├── go.mod
    └── shared/
        └── shared.go
    
  • Um pacote na raiz do projeto com um subdiretório que define um package main:

    .
    ├── cmd/
    |   └── main.go
    └── function.go
    

Como especificar dependências

Você especifica as dependências de sua função de maneira idiomática com base no ambiente de execução usado. Para mais detalhes, consulte a página apropriada:

Como nomear Cloud Functions

O Cloud Functions tem uma propriedade "name" que é definida no momento da implantação e, uma vez definida, não pode ser alterada. O nome de uma função é usado como seu identificador e precisa ser exclusivo em uma região. Por padrão, o nome de uma função também é usado como o ponto de entrada em seu código-fonte. Por exemplo, uma função chamada foo executará, por padrão, a função foo() no código-fonte implantado. Se você quer que uma função diferente seja executada, use a sinalização --entry-point no momento da implementação.

Próximas etapas

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Documentação do Cloud Functions