Gravar funções do Cloud Run

O Cloud Functions oferece suporte à escrita de código-fonte em várias linguagens de programação. O ambiente de execução da linguagem que você escolhe e o tipo de função que você quer escrever determinam como estruturar seu código e implementar sua função. Nesta página, você terá uma visão geral dos tipos de Cloud Functions e as expectativas para o código-fonte.

Tipos de funções do Cloud Run

Há dois tipos de funções do Cloud Run:

Use uma função HTTP quando precisar que a função tenha um endpoint de URL e responda a solicitações HTTP, como para webhooks. Use uma função baseada em eventos quando ela precisar ser acionada diretamente em resposta a eventos no seu projeto do Google Cloud, como mensagens em um tópico do Pub/Sub ou alterações em um bucket do Cloud Storage.

Estrutura do diretório de origem

Para que as funções do Cloud Run localizem a definição da função, cada ambiente de execução da linguagem tem requisitos para estruturar o código-fonte. Veja abaixo a estrutura básica de diretório para uma função em cada ambiente de execução.

Node.js

A estrutura de diretórios básica para funções Node.js é a seguinte:

.
├── index.js
└── package.json

Por padrão, as funções do Cloud Run tentam carregar o código-fonte de um arquivo chamado index.js na raiz do diretório da função. Para especificar um arquivo principal diferente, use o campo main no seu arquivo package.json.

Seu arquivo package.json também precisa incluir o Functions Framework para Node.js como uma dependência:

{
  "main": "index.js",
  "dependencies": {
    "@google-cloud/functions-framework": "^3.0.0"
  }
}

O código no arquivo principal precisa definir o ponto de entrada de função e importar outros códigos e módulos do Node.js normalmente. O arquivo principal também pode definir vários pontos de entrada de função que podem ser implantados separadamente.

Python

A estrutura de diretórios básica para funções Python é a seguinte:

.
├── main.py
└── requirements.txt

As funções do Cloud Run carregam o código-fonte de um arquivo chamado main.py na raiz do diretório de funções. O arquivo principal precisa ter o nome main.py.

O arquivo requirements.txt precisa incluir o Functions Framework para Python como uma dependência:

functions-framework==3.*

O código no arquivo main.py precisa definir seu ponto de entrada de função e pode importar outras dependências de código e externas normalmente. O arquivo main.py também pode definir vários pontos de entrada de função que podem ser implantados separadamente.

Go

A estrutura de diretórios básica para funções Go é a seguinte:

.
├── myfunction.go
└── go.mod

Sua função deve estar em um pacote Go na raiz do projeto. O pacote e os arquivos de origem dele podem ter qualquer nome, exceto se a função não puder estar em package main. Se você precisar de um pacote main, por exemplo, para testes locais, crie um em um subdiretório:

.
├── myfunction.go
├── go.mod
└── cmd/
    └── main.go

Seu arquivo go.mod precisa incluir o Functions Framework para Go como uma dependência:

module example.com/my-module

require (
  github.com/GoogleCloudPlatform/functions-framework-go v1.5.2
)

O código no pacote raiz precisa definir o ponto de entrada de função e importar outros códigos de subpacotes e dependências normalmente. Seu pacote também pode definir vários pontos de entrada de função que podem ser implantados separadamente.

Java

A estrutura de diretórios básica para funções Java é a seguinte:

.
├── pom.xml
└── src/
    └── main/
        └── java/
            └── MyFunction.java

Os arquivos de origem Java precisam estar no diretório src/main/java/ e podem ter qualquer nome. Se os arquivos de origem declararem um pacote, adicione um diretório extra em src/main/java com o nome do pacote:

.
├── pom.xml
└── src/
    └── main/
        └── java/
            └── mypackage/
                └── MyFunction.java

Recomendamos colocar os testes associados em um subdiretório src/test/java/.

O arquivo pom.xml precisa incluir o Functions Framework para Java como dependência:

...
    <dependency>
      <groupId>com.google.cloud.functions</groupId>
      <artifactId>functions-framework-api</artifactId>
      <version>1.0.4</version>
    </dependency>
...

O código nos arquivos de origem precisa definir o ponto de entrada de função e importar outros códigos e dependências externas normalmente. Seus arquivos de origem também podem definir vários pontos de entrada de função que podem ser implantados separadamente.

C#

A estrutura de diretórios básica para funções .NET é a seguinte:

.
├── MyFunction.cs
└── MyProject.csproj

Você pode estruturar seus projetos como faria com qualquer outro código-fonte .NET. Seus arquivos de origem podem ter qualquer nome.

O arquivo do projeto precisa incluir o Functions Framework para .NET como uma dependência:

...
    <PackageReference Include="Google.Cloud.Functions.Hosting" Version="1.0.0" />
...

O código nos arquivos de origem precisa definir o ponto de entrada de função e importar outros códigos e dependências externas normalmente. Seus arquivos de origem também podem definir vários pontos de entrada de função que podem ser implantados separadamente.

Também é possível usar o pacote de modelos das funções do Cloud Run para .NET para gerar os arquivos necessários.

Ruby

A estrutura de diretórios básica para funções do Ruby é a seguinte:

.
├── app.rb
├── Gemfile
└── Gemfile.lock

As funções do Cloud Run carregam o código-fonte de um arquivo chamado app.rb na raiz do diretório de funções. O arquivo principal precisa ter o nome app.rb.

O arquivo Gemfile precisa incluir o Functions Framework para Ruby como uma dependência:

source "https://rubygems.org"
gem "functions_framework", "~> 1.0"

O código no arquivo app.rb precisa definir seu ponto de entrada de função e pode importar outras dependências de código e externas normalmente. O arquivo app.rb também pode definir vários pontos de entrada de função que podem ser implantados separadamente.

PHP

A estrutura de diretórios básica para funções PHP é a seguinte:

.
├── index.php
└── composer.json

As funções do Cloud Run carregam o código-fonte de um arquivo chamado index.php na raiz do diretório de funções. O arquivo principal precisa ter o nome index.php.

O arquivo composer.json precisa incluir o Functions Framework para PHP como uma dependência:

{
  "require": {
    "google/cloud-functions-framework": "^1.1"
  }
}

O código no arquivo index.php precisa definir seu ponto de entrada de função e pode importar outras dependências de código e externas normalmente. O arquivo index.php também pode definir vários pontos de entrada de função que podem ser implantados separadamente.

Se você estiver pensando em agrupar várias funções em um único projeto, esteja ciente de que cada função pode acabar compartilhando o mesmo conjunto de dependências. No entanto, algumas das funções podem não precisar de todas as dependências.

Sempre que possível, recomendamos dividir grandes bases de código multifuncionais e colocar cada função no próprio diretório de nível superior, conforme mostrado acima, com os próprios arquivos de configuração de origem e projeto. Essa abordagem minimiza o número de dependências necessárias para uma função específica, o que reduz a quantidade de memória necessária para a função.

Ponto de entrada da função

O código-fonte precisa definir um ponto de entrada para a função, que é o código específico que é executado quando a função do Cloud Run é invocada. Especifique esse ponto de entrada ao implantar a função.

A definição do ponto de entrada depende do ambiente de execução da linguagem usada. Para algumas linguagens, o ponto de entrada é uma função, enquanto em outras, o ponto de entrada é uma classe. Para saber mais sobre como definir pontos de entrada e implementar funções do Cloud Run em diferentes linguagens, consulte Escrever funções HTTP e Como escrever funções orientadas a eventos

Dependências

Você pode gerenciar dependências usando ferramentas padrão para cada ambiente de execução. Para mais informações, consulte a página adequada:

Próximas etapas