Ambiente de execução do Go

O ambiente de execução Go do Cloud Functions é baseado na versão 1.11.5 do Go. Para saber como preparar sua máquina local para o desenvolvimento do Go, consulte Como configurar um ambiente de desenvolvimento do Go.

Para começar a usar o Go no Cloud Functions, consulte o Guia de início rápido.

Como selecionar o ambiente de execução

Selecione o ambiente de execução do Go para a função durante a implantação.

gcloud

Se estiver usando a ferramenta de linha de comando gcloud, você poderá especificar o ambiente de execução usando o parâmetro --runtime. Exemplo:

gcloud functions deploy FUNCTION_NAME --runtime go111 FLAGS...

FLAGS... refere-se a argumentos transferidos durante a primeira implantação da sua função. Para mais informações sobre argumentos obrigatórios e opcionais, consulte Implantar usando a ferramenta gcloud (em inglês).

Console

Se estiver usando o console do GCP, você poderá selecionar o ambiente de execução ao criar e implantar uma função.

  1. No Console do GCP, acesse a página Visão geral do Cloud Functions.

    Acessar a página "Visão geral do Cloud Functions"

    Verifique se o projeto para que você ativou o Cloud Functions está selecionado.

  2. Clique em Criar função.

  3. Em Ambiente de execução, selecione Go 1.11.

Ambiente de execução

Isso inclui o ambiente de execução, o sistema operacional, os pacotes e uma biblioteca que invoca sua função.

O ambiente de execução Go usa um ambiente baseado no Ubuntu 18.04 com o Go versão 1.11.5. Consulte Ambiente de execução do Cloud Functions para mais informações.

Estrutura do código-fonte

Para que o Cloud Functions encontre a definição da sua função, cada ambiente de execução possui determinados requisitos de estruturação para o código-fonte. Consulte Gravar funções HTTP (em inglês) para mais informações.

Como especificar dependências

O Cloud Functions no Go deve fornecer todas as suas dependências por meio dos módulos Go com um arquivo go.mod ou um diretório vendor. Para mais informações, consulte Especificando dependências no Go.

Inicialização única

Pode ser necessário realizar uma inicialização única nas suas funções, como criar clientes da API e configurar o acesso ao banco de dados. Há várias maneiras de fazer isso:

  • Use uma função func init() para inicializar os valores quando uma nova instância da função for iniciada. Observe que o código na função func init() é executado antes de sua função receber sua primeira solicitação.

  • Use a função sync..Once.Do() para executar o código uma vez por instância do Cloud Functions. Isso é útil nos casos em que você quer inicializar somente sob demanda, não quando sua instância da função é inicializada pela primeira vez. Por exemplo, é possível inicializar um cliente de banco de dados apenas sob certas circunstâncias.

context.Context

O pacote de context do Go (em inglês) define o tipo de Context, que envia prazos, sinais de cancelamento e outros valores com escopo de solicitação para a API e os processos.

Os clientes de API que persistem a uma determinada invocação de função precisam ser inicializados com um valor context.Context global, como o criado pela função context.Background(). Para otimizar o desempenho, é possível inicializar um cliente no escopo global. Esse cliente e seu contexto podem persistir durante todo o tempo de vida de uma determinada instância da função.

Você deve usar apenas o contexto de invocação da função para objetos ou operações que estão no intervalo de duração de uma invocação da função específica. O contexto de invocação pode ser cancelado a qualquer momento depois de executar a função, o que significa que qualquer cliente inicializado usando esse contexto pode ser fechado. O contexto de invocação da função pode ser acessado por meio dos argumentos da função: geralmente r.Context() para funções HTTP e ctx para funções em segundo plano.

Veja o seguinte código para um exemplo usando um cliente do Cloud Pub/Sub:

// Package contexttip is an example of how to use Pub/Sub and context.Context in
// a Cloud Function.
package contexttip

import (
	"context"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"os"

	"cloud.google.com/go/pubsub"
)

// projectID is set from the GCP_PROJECT environment variable, which is
// automatically set by the Cloud Functions runtime.
var projectID = os.Getenv("GCP_PROJECT")

// client is a global Pub/Sub client, initialized once per instance.
var client *pubsub.Client

func init() {
	// err is pre-declared to avoid shadowing client.
	var err error

	// client is initialized with context.Background() because it should
	// persist between function invocations.
	client, err = pubsub.NewClient(context.Background(), projectID)
	if err != nil {
		log.Fatalf("pubsub.NewClient: %v", err)
	}
}

type publishRequest struct {
	Topic string `json:"topic"`
}

// PublishMessage publishes a message to Pub/Sub. PublishMessage only works
// with topics that already exist.
func PublishMessage(w http.ResponseWriter, r *http.Request) {
	// Read the request body.
	data, err := ioutil.ReadAll(r.Body)
	if err != nil {
		log.Printf("ioutil.ReadAll: %v", err)
		http.Error(w, "Error reading request", http.StatusBadRequest)
		return
	}

	// Parse the request body to get the topic name.
	p := publishRequest{}
	if err := json.Unmarshal(data, &p); err != nil {
		log.Printf("json.Unmarshal: %v", err)
		http.Error(w, "Error parsing request", http.StatusBadRequest)
		return
	}

	m := &pubsub.Message{
		Data: []byte("Test message"),
	}
	// Publish and Get use r.Context() because they are only needed for this
	// function invocation. If this were a background function, they would use
	// the ctx passed as an argument.
	id, err := client.Topic(p.Topic).Publish(r.Context(), m).Get(r.Context())
	if err != nil {
		log.Printf("topic(%s).Publish.Get: %v", p.Topic, err)
		http.Error(w, "Error publishing message", http.StatusInternalServerError)
		return
	}
	fmt.Fprintf(w, "Published msg: %v", id)
}
Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Cloud Functions Documentation