Escribe funciones de Cloud Functions

Las funciones de Google Cloud Functions se pueden escribir en Node.js, Python y Go, y se ejecutan en entornos de ejecución de lenguaje específico. El entorno de ejecución de Cloud Functions varía según el tipo de entorno de ejecución que elijas. Las páginas de descripción general del entorno de ejecución proporcionan más detalles sobre cada uno:

Tipos de Cloud Functions

Existen dos tipos de funciones de Cloud Functions: funciones de HTTP y funciones en segundo plano.

Funciones de HTTP

Invocas funciones de HTTP a partir de solicitudes HTTP estándar. Estas solicitudes HTTP esperan la respuesta y admiten el manejo de métodos de solicitud HTTP comunes, como GET, PUT, POST, DELETE y OPTIONS. Cuando usas Cloud Functions, se aprovisiona automáticamente un certificado TLS, por lo que todas las funciones de HTTP pueden invocarse a través de una conexión segura.

Para obtener detalles, consulta Escribe funciones de HTTP.

Ejemplo:

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))
}

Funciones en segundo plano

Puedes usar funciones en segundo plano para manejar eventos desde tu infraestructura de nube, como mensajes en un tema de Cloud Pub/Sub o cambios en el depósito de Cloud Storage.

Para obtener detalles, consulta Escribe funciones en segundo plano.

Ejemplo:

Node.js 8/10

/**
 * 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(data, context):
    """Background Cloud Function.
    Args:
         data (dict): The dictionary with data specific to the given event.
         context (google.cloud.functions.Context): The Cloud Functions event
         metadata.
    """
    if data and 'name' in data:
        name = data['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
}

Estructura código fuente

Con el fin de que Cloud Functions encuentre la definición de tu función, cada entorno de ejecución tiene requisitos de estructuración para tu código fuente:

Node.js

Para los entornos de ejecución de Node.js, el código fuente de tu función debe exportarse desde un módulo de Node.js, que Cloud Functions carga mediante una llamada require(). Para determinar qué módulo cargar, Cloud Functions usa el campo main en tu archivo package.json. Si no se especifica el campo main, Cloud Functions carga el código desde index.js.

Por ejemplo, las siguientes configuraciones de código fuente son válidas:

  • Un solo archivo index.js en la raíz de tu proyecto que exporta una o más funciones:

    .
    └── index.js
    
  • Un archivo index.js que importa código desde un archivo foo.js y, luego, exporta una o más funciones:

    .
    ├── index.js
    └── foo.js
    
  • Un archivo app.js que exporta una o más funciones, con un archivo package.json que contiene "main": "app.js":

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

Python

Para el entorno de ejecución de Python, el punto de entrada de tu función debe estar definido en un archivo de código fuente de Python en la raíz de tu proyecto denominado main.py.

Por ejemplo, las siguientes configuraciones de código fuente son válidas:

  • Un solo archivo main.py en la raíz de tu proyecto que define una o más funciones:

    .
    └── main.py
    
  • Un archivo main.py con un archivo requirements.txt que especifica dependencias:

    .
    ├── main.py
    └── requirements.txt
    
  • Un archivo main.py que importa código desde una dependencia local:

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

Go

Para el entorno de ejecución de Go, tu función debe estar en un paquete de Go en la raíz de tu proyecto. Tu función no puede estar en package main. Los subpaquetes solo se admiten cuando se usan módulos de Go.

Por ejemplo, las siguientes configuraciones de código fuente son válidas:

  • Un paquete en la raíz de tu proyecto que exporta una o más funciones:

    .
    └── function.go
    
  • Un paquete en la raíz de tu proyecto que importa código desde un subpaquete y exporta una o más funciones:

    .
    ├── function.go
    ├── go.mod
    └── shared/
        └── shared.go
    
  • Un paquete en la raíz de tu proyecto con un subdirectorio que define un package main:

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

Especifica dependencias

Especificarás las dependencias de tu función de manera idiomática según el entorno de ejecución que usas. Para más detalles, consulta la página que corresponda entre las siguientes opciones:

Nombra Cloud Functions

Cloud Functions tiene una propiedad “name” que se configura en el momento de la implementación, y una vez configurada, no se puede cambiar. El nombre de una función se usa como su identificador y debe ser único dentro de una región. Según la configuración predeterminada, el nombre de una función también se usa como el punto de entrada a tu código fuente. Por ejemplo, una función denominada foo ejecutará, de forma predeterminada, la función foo() en el código fuente que implementes. Si deseas que se ejecute una función diferente, puedes usar el marcador --entry-point en el momento de la implementación. Para obtener detalles, consulta la documentación de Implementa Cloud Functions.

Próximos pasos

¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…

Documentación de Cloud Functions