Sugerencias y trucos

En este documento, se describen las prácticas recomendadas para diseñar, implementar y probarCloud Functions.

Precisión

En esta sección, se describen las prácticas recomendadas generales para diseñar e implementar Cloud Functions.

Escribe funciones idempotentes

Tus funciones deben producir el mismo resultado, incluso si se llaman varias veces. Esto te permite volver a intentar una invocación si la anterior falla a mitad de camino en el código. Para obtener más información, consulta Reintenta las funciones controladas por eventos.

No inicies actividades en segundo plano

Las actividades en segundo plano son todas las acciones que ocurren después de que finaliza la ejecución de tu función. La invocación de una función termina cuando la función muestra o indica que se completó su ejecución, por ejemplo, si llama al argumento callback en las funciones de Node.js controladas por eventos. El código que se ejecute después de esto no podrá acceder a la CPU y no llevará a cabo ningún progreso.

Además, cuando se ejecutan las invocaciones siguientes en el mismo entorno, se reanuda tu actividad en segundo plano, lo que provoca interferencias en la invocación nueva. Es posible que se generen errores y comportamientos inesperados difíciles de diagnosticar. Acceder a una red después de que una función termina suele generar el restablecimiento de las conexiones (código de error ECONNRESET).

A menudo, la actividad en segundo plano se puede detectar en los registros de las invocaciones individuales, ya que aparece en las líneas posteriores a la que indica que la invocación finalizó. En otras ocasiones, este tipo de actividad puede estar mucho más oculta en el código, especialmente cuando existen operaciones asíncronas, como devoluciones de llamadas o cronómetros. Revisa tu código para asegurarte de que todas las operaciones asíncronas finalicen antes de que completes la función.

Borra los archivos temporales siempre

El almacenamiento en el directorio temporal del disco local es un sistema de archivos en la memoria. Los archivos que escribes consumen memoria disponible en tu función y a veces persisten entre invocaciones. No borrar estos archivos explícitamente podría generar un error por falta de memoria y un posterior inicio en frío.

Para ver la memoria que usa una función específica, selecciónala en la lista de funciones de la consola de Google Cloud y elige el trazado Uso de memoria.

No intentes escribir fuera del directorio temporal y asegúrate de usar métodos independientes de SO/plataforma para construir rutas de acceso.

Puedes reducir los requisitos de memoria si procesas archivos más grandes mediante canalizaciones. Por ejemplo, para procesar un archivo alojado en Cloud Storage, puedes crear un flujo de lectura, pasarlo por un proceso basado en flujos y escribir el flujo de salida directamente en Cloud Storage.

Functions Framework

Cuando implementas una función, Functions Framework se agrega automáticamente como una dependencia, con su versión actual. Para asegurarte de que las mismas dependencias se instalen de manera coherente en diferentes entornos, te recomendamos que fijes la función a una versión específica de Functions Framework.

Para ello, incluye tu versión preferida en el archivo de bloqueo relevante (por ejemplo, package-lock.json para Node.js o requirements.txt para Python).

Herramientas

En esta sección, se proporcionan lineamientos sobre cómo usar herramientas para implementar, probar y también interactuar con Cloud Functions.

Desarrollo local

La implementación de funciones tarda un momento, por lo que suele ser más rápido probar el código de tu función de manera local.

Usa Sendgrid para enviar correos electrónicos

Cloud Functions no permite conexiones salientes en el puerto 25, por lo que no puedes establecer conexiones no seguras a un servidor SMTP. Para enviar correos electrónicos, se recomienda usar SendGrid. Puedes encontrar otras opciones para enviar correos electrónicos en el instructivo sobre cómo enviar correos electrónicos desde una instancia para Google Compute Engine.

Rendimiento

Esta sección describe las recomendaciones para optimizar el rendimiento.

Usa las dependencias de manera inteligente

Debido a que las funciones no tienen estado, el entorno de ejecución suele inicializarse desde cero (durante lo que se conoce como inicio en frío). Cuando se genera un inicio en frío, se evalúa el contexto global de la función.

Si tus funciones importan módulos, el tiempo de carga de estos se agrega a la latencia de invocación durante un inicio en frío. Para reducir esta latencia y el tiempo que se requiere para implementar tu función, carga las dependencias correctamente y no cargues las dependencias que tu función no utiliza.

Usa variables globales para volver a usar objetos en invocaciones futuras

No se garantiza que el estado de una función se conserve para las invocaciones futuras. Sin embargo, Cloud Functions suele reciclar el entorno de ejecución de una invocación previa. Si declaras una variable en alcance global, su valor se puede volver a usar en invocaciones posteriores sin tener que volver a procesarse.

De esta manera, puedes almacenar objetos en la caché, ya que volver a crearlos en cada invocación de la función puede ser costoso. Mover estos objetos desde el cuerpo de la función al alcance global puede generar importantes mejoras en el rendimiento. El siguiente ejemplo crea un objeto pesado solo una vez por instancia de la función y lo comparte en todas las invocaciones de la función que alcanzan la instancia determinada:

console.log('Global scope');
const perInstance = heavyComputation();
const functions = require('firebase-functions');

exports.function = functions.https.onRequest((req, res) => {
  console.log('Function invocation');
  const perFunction = lightweightComputation();

  res.send(`Per instance: ${perInstance}, per function: ${perFunction}`);
});

import time

from firebase_functions import https_fn

# Placeholder
def heavy_computation():
  return time.time()

# Placeholder
def light_computation():
  return time.time()

# Global (instance-wide) scope
# This computation runs at instance cold-start
instance_var = heavy_computation()

@https_fn.on_request()
def scope_demo(request):

  # Per-function scope
  # This computation runs every time this function is called
  function_var = light_computation()
  return https_fn.Response(f"Instance: {instance_var}; function: {function_var}")
  

Es especialmente importante almacenar en caché las conexiones de red, la biblioteca, las referencias y los clientes de la API en alcance global. Consulta Optimiza las herramientas de redes para ver ejemplos.

Haz una inicialización diferida de las variables globales

Si inicializas variables en alcance global, el código de inicialización se ejecutará siempre a través de una invocación de inicio en frío, lo que aumenta la latencia de tu función. En algunos casos, esto genera tiempos de espera intermitentes en los servicios a los que se llama si no se administran de forma apropiada en un bloque try/catch. Si algunos objetos no se usan en todas las rutas del código, te recomendamos inicializarlos de forma diferida según demanda:

const functions = require('firebase-functions');
let myCostlyVariable;

exports.function = functions.https.onRequest((req, res) => {
  doUsualWork();
  if(unlikelyCondition()){
      myCostlyVariable = myCostlyVariable || buildCostlyVariable();
  }
  res.status(200).send('OK');
});

from firebase_functions import https_fn

# Always initialized (at cold-start)
non_lazy_global = file_wide_computation()

# Declared at cold-start, but only initialized if/when the function executes
lazy_global = None

@https_fn.on_request()
def lazy_globals(request):

  global lazy_global, non_lazy_global

  # This value is initialized only if (and when) the function is called
  if not lazy_global:
      lazy_global = function_specific_computation()

  return https_fn.Response(f"Lazy: {lazy_global}, non-lazy: {non_lazy_global}.")
  

Esto es especialmente importante si defines varias funciones en un solo archivo y si varias funciones usan variables diferentes. A menos que uses la inicialización diferida, puedes perder recursos si inicializas variables que nunca se usan.

Configura una cantidad mínima de instancias para reducir los inicios en frío

De forma predeterminada, Cloud Functions escala la cantidad de instancias según la cantidad de solicitudes entrantes. Para cambiar este comportamiento predeterminado, configura una cantidad mínima de instancias que Cloud Functions debe tener listas para entregar solicitudes. Establecer una cantidad mínima de instancias reduce los inicios en frío de tu aplicación. Recomendamos que configures una cantidad mínima de instancias si tu aplicación es sensible a la latencia.

Recursos adicionales

Obtén más información para optimizar el rendimiento en el video de “Google Cloud Performance Atlas” y consulta el Cloud Functions Tiempo de inicio en frío .