Se usó la API de Cloud Translation para traducir esta página.

Comienza a usar Cloud Functions (2nd gen)

1. Introducción

Para comenzar a escribir funciones de Cloud Run, puedes usar los siguientes codelabs:

De lo contrario, en este codelab se explica cómo crear Cloud Functions (2ª gen.).

Descripción general

Cloud Functions (2nd gen) es la próxima versión de Google Cloud Functions, la oferta de funciones como servicio de Google Cloud. Esta nueva versión incluye un conjunto de atributos avanzados y ahora se ejecuta con Cloud Run y Eventarc, lo que te brinda un control más avanzado sobre el rendimiento y la escalabilidad, y más control sobre el tiempo de ejecución de las funciones y los activadores de más de 90 fuentes de eventos.

En este codelab, te explicaremos cómo crear funciones de Cloud Functions que respondan a llamadas HTTP y que se activen con mensajes de Pub/Sub y Registros de auditoría de Cloud.

Novedades

Esta nueva versión de Cloud Functions ofrece una experiencia de FaaS mejorada con la tecnología de Cloud Run, Cloud Build, Artifact Registry y Eventarc.

Infraestructura mejorada

Procesamiento de solicitudes más largo: Ejecuta tus funciones de Cloud Functions durante más tiempo que el valor predeterminado de 5 minutos, lo que facilita la ejecución de cargas de trabajo de solicitudes más largas, como el procesamiento de grandes flujos de datos desde Cloud Storage o BigQuery. Para las funciones de HTTP, esto es de hasta 60 minutos. En el caso de las funciones controladas por eventos, actualmente es de hasta 10 minutos.
Instancias más grandes: Aprovecha hasta 16 GB de RAM y 4 CPU virtuales en Cloud Functions, lo que permite cargas de trabajo más paralelas, de mayor tamaño en la memoria, y procesamiento intensivo.
Simultaneidad: Procesa hasta 1,000 solicitudes simultáneas con una sola instancia de función, lo que minimiza los inicios en frío y mejora la latencia durante el escalamiento.
Instancias mínimas: Proporciona instancias preparadas con anterioridad para reducir los inicios en frío y asegúrate de que el tiempo de arranque de la aplicación no afecte su rendimiento.
División del tráfico: Admite varias versiones de tus funciones, divide el tráfico entre diferentes versiones y revierte la función a una versión anterior.

Amplia cobertura de eventos y compatibilidad con CloudEvents

Integración de Eventarc: Cloud Functions ahora incluye compatibilidad nativa con Eventarc, que ofrece más de 90 fuentes de eventos con los registros de auditoría de Cloud (BigQuery, Cloud SQL, Cloud Storage, etcétera). Por supuesto, Cloud Functions aún admite eventos de fuentes personalizadas mediante la publicación directamente en Cloud Pub/Sub.
Formato de CloudEvent: Todas las funciones controladas por eventos cumplen con los CloudEvents estándar de la industria ( cloudevents.io), independientemente de la fuente, para garantizar una experiencia de desarrollador coherente. Las cargas útiles se envían a través de un CloudEvent estructurado con una carga útil de cloudevent.data y, además, implementan el estándar de CloudEvent.

Qué aprenderás

Descripción general de Cloud Functions (2ª gen.).
Cómo escribir una función que responda a llamadas HTTP
Cómo escribir una función que responda a los mensajes de Pub/Sub
Cómo escribir una función que responda a los eventos de Cloud Storage
Cómo escribir una función que responda a los Registros de auditoría de Cloud
Cómo dividir el tráfico entre dos revisiones
Cómo deshacerte de los inicios en frío con instancias mínimas
Cómo configurar la simultaneidad

2. Configuración y requisitos

Configuración del entorno de autoaprendizaje

Accede a Google Cloud Console y crea un proyecto nuevo o reutiliza uno existente. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.

El Nombre del proyecto es el nombre visible de los participantes de este proyecto. Es una cadena de caracteres que no se utiliza en las APIs de Google. Puedes actualizarla en cualquier momento.
El ID del proyecto debe ser único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). La consola de Cloud genera automáticamente una cadena única. Por lo general, no importa cuál sea. En la mayoría de los codelabs, deberás hacer referencia al ID del proyecto (suele identificarse como PROJECT_ID). Si no te gusta el ID que se generó, podrías generar otro aleatorio. También puedes probar uno propio y ver si está disponible. No se puede cambiar después de este paso y se mantendrá durante todo el proyecto.
Recuerda que hay un tercer valor, un número de proyecto, que usan algunas APIs. Obtén más información sobre estos tres valores en la documentación.

A continuación, deberás habilitar la facturación en la consola de Cloud para usar las APIs o los recursos de Cloud. Ejecutar este codelab no debería costar mucho, tal vez nada. Para cerrar recursos y evitar que se generen cobros más allá de este instructivo, puedes borrar los recursos que creaste o borrar todo el proyecto. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de USD 300.

Inicia Cloud Shell

Si bien Google Cloud y Spanner se pueden operar de manera remota desde tu laptop, en este codelab usarás Google Cloud Shell, un entorno de línea de comandos que se ejecuta en la nube.

En Google Cloud Console, haz clic en el ícono de Cloud Shell en la barra de herramientas en la parte superior derecha:

El aprovisionamiento y la conexión al entorno deberían tomar solo unos minutos. Cuando termine el proceso, debería ver algo como lo siguiente:

Esta máquina virtual está cargada con todas las herramientas de desarrollo que necesitarás. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud, lo que permite mejorar considerablemente el rendimiento de la red y la autenticación. Todo tu trabajo en este codelab se puede hacer en un navegador. No es necesario que instales nada.

Configura gcloud

En Cloud Shell, asegúrate de que el ID de tu proyecto esté configurado y guardado en una variable PROJECT_ID, y de que REGION esté configurado como us-west1:

gcloud config set project [YOUR-PROJECT-ID]
PROJECT_ID=$(gcloud config get-value project)
REGION=us-west1

Habilita las APIs

Habilita todos los servicios necesarios con el siguiente comando:

gcloud services enable \
  artifactregistry.googleapis.com \
  cloudfunctions.googleapis.com \
  cloudbuild.googleapis.com \
  eventarc.googleapis.com \
  run.googleapis.com \
  logging.googleapis.com \
  pubsub.googleapis.com

3. Función HTTP

Para la primera función, crearemos una función de Node.js autenticada que responda a las solicitudes HTTP. También usaremos un tiempo de espera de 10 minutos para mostrar cómo una función puede tener más tiempo para responder a las solicitudes HTTP.

Creación

Crea una carpeta para la app y navega a ella:

mkdir ~/hello-http && cd $_

Crea un archivo index.js que simplemente responda a las solicitudes HTTP:

const functions = require('@google-cloud/functions-framework');

functions.http('helloWorld', (req, res) => {
  res.status(200).send('HTTP with Node.js in GCF 2nd gen!');
});

Crea un archivo package.json para especificar las dependencias:

{
  "name": "nodejs-functions-gen2-codelab",
  "version": "0.0.1",
  "main": "index.js",
  "dependencies": {
    "@google-cloud/functions-framework": "^2.0.0"
  }
}

Implementación

Sigue estos pasos para implementar la función:

gcloud functions deploy nodejs-http-function \
  --gen2 \
  --runtime nodejs16 \
  --entry-point helloWorld \
  --source . \
  --region $REGION \
  --trigger-http \
  --timeout 600s

Aunque no es estrictamente necesario para este paso, ten en cuenta el tiempo de espera de 600 segundos. Esto permite que la función tenga un tiempo de espera más largo para responder a las solicitudes HTTP.

Una vez que se implemente la función, podrás verla en la sección Cloud Functions de la consola de Cloud:

Prueba

Prueba la función con el siguiente comando:

gcloud functions call nodejs-http-function \
  --gen2 --region $REGION

Deberías ver el mensaje HTTP with Node.js in GCF 2nd gen! como respuesta.

4. Función de Pub/Sub

Para la segunda función, crearemos una función de Python activada por un mensaje de Pub/Sub publicado en un tema específico.

Configura tokens de autenticación de Pub/Sub

Si habilitaste la cuenta de servicio de Pub/Sub el 8 de abril de 2021 o antes de esa fecha, otorga el rol iam.serviceAccountTokenCreator a la cuenta de servicio de Pub/Sub:

PROJECT_NUMBER=$(gcloud projects list --filter="project_id:$PROJECT_ID" --format='value(project_number)')

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member  serviceAccount:service-$PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com \
  --role roles/iam.serviceAccountTokenCreator

Creación

Crea un tema de Pub/Sub para usar en la muestra:

TOPIC=cloud-functions-gen2-topic
gcloud pubsub topics create $TOPIC

Crea una carpeta para la app y navega a ella:

mkdir ~/hello-pubsub && cd $_

Crea un archivo main.py que simplemente registre un mensaje que contenga el ID de CloudEvent:

import functions_framework

@functions_framework.cloud_event
def hello_pubsub(cloud_event):
   print('Pub/Sub with Python in GCF 2nd gen! Id: ' + cloud_event['id'])

Crea un archivo requirements.txt con el siguiente contenido para especificar las dependencias:

functions-framework==3.*

Implementación

Sigue estos pasos para implementar la función:

gcloud functions deploy python-pubsub-function \
  --gen2 \
  --runtime python39 \
  --entry-point hello_pubsub \
  --source . \
  --region $REGION \
  --trigger-topic $TOPIC

Una vez que se implemente la función, podrás verla en la sección Cloud Functions de la consola de Cloud:

Prueba

Para probar la función, envía un mensaje al tema:

gcloud pubsub topics publish $TOPIC --message="Hello World"

Debería ver el CloudEvent recibido en los registros:

gcloud functions logs read python-pubsub-function \
  --region $REGION --gen2 --format "value(log)"

5. Función de Cloud Storage

Para la siguiente función, crearemos una función de Node.js que responda a eventos de un bucket de Cloud Storage.

Configurar

Para usar las funciones de Cloud Storage, otorga el rol de IAM pubsub.publisher a la cuenta de servicio de Cloud Storage:

SERVICE_ACCOUNT=$(gsutil kms serviceaccount -p $PROJECT_NUMBER)

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member serviceAccount:$SERVICE_ACCOUNT \
  --role roles/pubsub.publisher

Creación

Crea una carpeta para la app y navega a ella:

mkdir ~/hello-storage && cd $_

Crea un archivo index.js que simplemente responda a los eventos de Cloud Storage:

const functions = require('@google-cloud/functions-framework');

functions.cloudEvent('helloStorage', (cloudevent) => {
  console.log('Cloud Storage event with Node.js in GCF 2nd gen!');
  console.log(cloudevent);
});

Crea un archivo package.json para especificar las dependencias:

{
  "name": "nodejs-functions-gen2-codelab",
  "version": "0.0.1",
  "main": "index.js",
  "dependencies": {
    "@google-cloud/functions-framework": "^2.0.0"
  }
}

Implementación

Primero, crea un bucket de Cloud Storage (o usa uno existente):

export BUCKET="gs://gcf-gen2-storage-$PROJECT_ID"
gsutil mb -l $REGION $BUCKET

Sigue estos pasos para implementar la función:

gcloud functions deploy nodejs-storage-function \
  --gen2 \
  --runtime nodejs16 \
  --entry-point helloStorage \
  --source . \
  --region $REGION \
  --trigger-bucket $BUCKET \
  --trigger-location $REGION

Una vez que se implemente la función, podrás verla en la sección Cloud Functions de la consola de Cloud.

Prueba

Sube un archivo al bucket para probar la función:

echo "Hello World" > random.txt
gsutil cp random.txt $BUCKET/random.txt

Debería ver el CloudEvent recibido en los registros:

gcloud functions logs read nodejs-storage-function \
  --region $REGION --gen2 --limit=100 --format "value(log)"

6. Función de Registros de auditoría de Cloud

Para la siguiente función, crearemos una función de Node.js que reciba un evento de registro de auditoría de Cloud cuando se cree una instancia de VM de Compute Engine. En respuesta, agrega una etiqueta a la VM recién creada y especifica el creador de la VM.

Determina las VMs de Compute Engine creadas recientemente

Compute Engine emite 2 registros de auditoría cuando se crea una VM.

La primera se emite al comienzo de la creación de la VM y se ve de la siguiente manera:

El segundo se emite después de la creación de la VM y se ve de la siguiente manera:

Observa el campo de operación con los valores first: true y last: true. El segundo registro de auditoría contiene toda la información que necesitamos para etiquetar una instancia. Por lo tanto, usaremos la marca last: true para detectarla en Cloud Functions.

Configurar

Para usar las funciones de los registros de auditoría de Cloud, debes habilitar los registros de auditoría para Eventarc. También debes usar una cuenta de servicio con el rol eventarc.eventReceiver.

Habilita los tipos de registros de lectura de administrador, lectura de datos y escritura de datos de los Registros de auditoría de Cloud para la API de Compute Engine:

Otorga el rol de IAM eventarc.eventReceiver a la cuenta de servicio predeterminada de Compute Engine:

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com \
  --role roles/eventarc.eventReceiver

Obtén el código

Clona el repo que contiene la aplicación:

git clone https://github.com/GoogleCloudPlatform/eventarc-samples.git

Navega al directorio de la app:

cd eventarc-samples/gce-vm-labeler/gcf/nodejs

El archivo index.js contiene el código de la aplicación que recibe el registro de auditoría unido a un CloudEvent. Luego, extrae los detalles de la instancia de VM de Compute Engine y establece una etiqueta en ella. No dudes en estudiar index.js con más detalle por tu cuenta.

Implementación

Puedes implementar la función con gcloud como antes. Observa cómo la función filtra los registros de auditoría para las inserciones de Compute Engine con la marca --trigger-event-filters:

gcloud functions deploy gce-vm-labeler \
  --gen2 \
  --runtime nodejs16 \
  --entry-point labelVmCreation \
  --source . \
  --region $REGION \
  --trigger-event-filters="type=google.cloud.audit.log.v1.written,serviceName=compute.googleapis.com,methodName=beta.compute.instances.insert" \
  --trigger-location us-central1

También puedes implementar la función y agregar un activador de Eventarc desde la consola de Google Cloud.

Primero, ve a la sección de Cloud Functions y crea una función con el entorno de 2ª gen.:

Haz clic en el botón Add Eventarc Trigger:

Se abrirá un panel lateral a la derecha en el que podrás elegir diferentes proveedores y eventos para el activador de Eventarc.

Elige el proveedor y el evento adecuados y, luego, haz clic en Save Trigger:

Por último, en la siguiente página, puedes actualizar los archivos index.js y package.json con los archivos index.js y package.json en GitHub y hacer clic en el botón Deploy:

Prueba

Para probar la función de registro de auditoría, debes crear una VM de Compute Engine en la consola de Cloud (también puedes crear VMs con gcloud, pero parece que no genera registros de auditoría).

Ve a la sección Compute Engine > Instancias de VM de la consola de Cloud y crea una VM nueva. Una vez que se complete la creación de la VM, deberías ver la etiqueta creator agregada en la VM en la consola de Cloud, en la sección Información básica o con el siguiente comando:

gcloud compute instances describe YOUR_VM_NAME

Deberías ver la etiqueta en el resultado como en el siguiente ejemplo:

...
labelFingerprint: ULU6pAy2C7s=
labels:
  creator: atameldev
...

7. División del tráfico

Cloud Functions (2ª gen.) admite varias revisiones de tus funciones, divide el tráfico entre diferentes revisiones y revierte la función a una versión anterior. Esto es posible porque las funciones de 2ª gen. son servicios de Cloud Run en su interior.

En este paso, implementarás 2 revisiones de una función y, luego, dividirás el tráfico entre ellas en partes iguales.

Creación

Crea una carpeta para la app y navega a ella:

mkdir ~/traffic-splitting && cd $_

Crea un archivo main.py con una función de Python que lea una variable de entorno de color y responda con Hello World en ese color de fondo:

import os

color = os.environ.get('COLOR')

def hello_world(request):
    return f'<body style="background-color:{color}"><h1>Hello World!</h1></body>'

Implementación

Implementa la primera revisión de la función con un fondo naranja:

COLOR=orange
gcloud functions deploy hello-world-colored \
  --gen2 \
  --runtime python39 \
  --entry-point hello_world \
  --source . \
  --region $REGION \
  --trigger-http \
  --allow-unauthenticated \
  --update-env-vars COLOR=$COLOR

En este punto, si pruebas la función viendo el activador HTTP (el resultado del URI del comando de implementación anterior) en tu navegador, deberías ver Hello World con un fondo naranja:

Implementa la segunda revisión con un fondo amarillo:

COLOR=yellow
gcloud functions deploy hello-world-colored \
  --gen2 \
  --runtime python39 \
  --entry-point hello_world \
  --source . \
  --region $REGION \
  --trigger-http \
  --allow-unauthenticated \
  --update-env-vars COLOR=$COLOR

Dado que esta es la última revisión, si pruebas la función, deberías ver Hello World con un fondo amarillo:

Cómo dividir el tráfico 50/50

Para dividir el tráfico entre las revisiones naranja y amarilla, debes encontrar los IDs de revisión de los servicios subyacentes de Cloud Run. Este es el comando para ver los IDs de revisión:

gcloud run revisions list --service hello-world-colored \
  --region $REGION --format 'value(REVISION)'

El resultado debería ser similar al siguiente ejemplo:

hello-world-colored-00001-man
hello-world-colored-00002-wok

Ahora, divide el tráfico entre estas dos revisiones de la siguiente manera (actualiza el X-XXX según los nombres de tus revisiones):

gcloud run services update-traffic hello-world-colored \
  --region $REGION \
  --to-revisions hello-world-colored-0000X-XXX=50,hello-world-colored-0000X-XXX=50

Prueba

Para probar la función, visita su URL pública. La mitad de las veces, deberías ver la revisión naranja y, la otra mitad, la revisión amarilla:

Consulta reversiones, lanzamientos graduales y migración de tráfico para obtener más información.

8. Cantidad mínima de instancias

En Cloud Functions (2ª gen.), se puede especificar una cantidad mínima de instancias de función que se deben mantener en espera y listas para entregar solicitudes. Esto es útil para limitar la cantidad de inicios en frío.

En este paso, implementarás una función con inicialización lenta. Observarás el problema de inicio en frío. Luego, implementarás la función con el valor de instancia mínima establecido en 1 para eliminar el inicio en frío.

Creación

Crea una carpeta para la app y navega hasta ella:

mkdir ~/min-instances && cd $_

Crea un archivo main.go. Este servicio de Go tiene una función init que se suspende durante 10 segundos para simular una inicialización larga. También tiene una función HelloWorld que responde a las llamadas HTTP:

package p

import (
        "fmt"
        "net/http"
        "time"
)

func init() {
        time.Sleep(10 * time.Second)
}

func HelloWorld(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "Slow HTTP Go in GCF 2nd gen!")
}

Implementación

Implementa la primera revisión de la función con el valor mínimo predeterminado de instancia cero:

gcloud functions deploy slow-function \
  --gen2 \
  --runtime go116 \
  --entry-point HelloWorld \
  --source . \
  --region $REGION \
  --trigger-http \
  --allow-unauthenticated

Prueba la función con este comando:

gcloud functions call slow-function \
  --gen2 --region $REGION

Observarás una demora de 10 segundos (inicio en frío) en la primera llamada y, luego, verás el mensaje. Las llamadas posteriores deberían mostrarse de inmediato.

Establece la cantidad mínima de instancias

Para deshacerte del inicio en frío en la primera solicitud, vuelve a implementar la función con la marca --min-instances establecida en 1 de la siguiente manera:

gcloud functions deploy slow-function \
  --gen2 \
  --runtime go116 \
  --entry-point HelloWorld \
  --source . \
  --region $REGION \
  --trigger-http \
  --allow-unauthenticated \
  --min-instances 1

Prueba

Vuelve a probar la función:

gcloud functions call slow-function \
  --gen2 --region $REGION

Ya no deberías ver la demora de 10 segundos en la primera solicitud. El problema de inicio en frío de la primera invocación (después de mucho tiempo sin él) desapareció, gracias a las instancias mínimas.

Consulta Usa una cantidad mínima de instancias para obtener más información.

9. Simultaneidad

En Cloud Functions (2ª gen.), una instancia de función maneja 1 solicitud simultánea de forma predeterminada, pero puedes especificar la cantidad de solicitudes simultáneas que una instancia puede procesar de forma simultánea. Esto también puede ser útil para evitar los inicios en frío, ya que no es necesario crear una instancia de función nueva para cada solicitud en paralelo.

En este paso, usarás la función con la inicialización lenta del paso anterior. Le enviarás 10 solicitudes y volverás a observar el problema de inicio en frío, ya que se deben crear instancias de función nuevas para controlar las solicitudes.

Para solucionar el problema de inicio en frío, implementarás otra función con un valor de simultaneidad de 100. Notarás que las 10 solicitudes ahora no causan el problema de inicio en frío y que una sola instancia de función puede controlar todas las solicitudes.

Cómo realizar pruebas sin simultaneidad

Obtén la URL de la función:

SLOW_URL=$(gcloud functions describe slow-function --region $REGION --gen2 --format="value(serviceConfig.uri)")

Usa una herramienta de comparativas de código abierto llamada hey para enviar 10 solicitudes simultáneas a la función lenta. hey ya está instalado en Cloud Shell:

hey -n 10 -c 10 $SLOW_URL

En el resultado de hey, deberías ver que algunas solicitudes tardan mucho:

Summary:
  Total:        10.9053 secs
  Slowest:      10.9048 secs
  Fastest:      0.4439 secs
  Average:      9.7930 secs
  Requests/sec: 0.9170

  Total data:   310 bytes
  Size/request: 31 bytes

Response time histogram:
  0.444 [1]     |■■■■
  1.490 [0]     |
  2.536 [0]     |
  3.582 [0]     |
  4.628 [0]     |
  5.674 [0]     |
  6.720 [0]     |
  7.767 [0]     |
  8.813 [0]     |
  9.859 [0]     |
  10.905 [9]    |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

Esto se debe a que se crean más instancias de función para manejar las solicitudes. Si verificas el recuento de instancias activas de la función, también deberías ver que se creó más de una instancia en algún momento y que estas son las que causan el problema de inicio en frío:

Implementación

Implementa una función nueva idéntica a la anterior. Una vez implementado, aumentarás su simultaneidad:

gcloud functions deploy slow-concurrent-function \
  --gen2 \
  --runtime go116 \
  --entry-point HelloWorld \
  --source . \
  --region $REGION \
  --trigger-http \
  --allow-unauthenticated \
  --min-instances 1

Cómo configurar la simultaneidad

Establece la simultaneidad del servicio subyacente de Cloud Run para la función en 100 (puede ser un máximo de 1,000). Esto garantiza que una sola instancia de función pueda controlar al menos 100 solicitudes:

gcloud run services update slow-concurrent-function \
  --concurrency 100 \
  --cpu 1 \
  --region $REGION

Realiza pruebas con simultaneidad

Obtén la URL de la función:

SLOW_CONCURRENT_URL=$(gcloud functions describe slow-concurrent-function --region $REGION --gen2 --format="value(serviceConfig.uri)")

Luego, usa hey para enviar 10 solicitudes simultáneas:

hey -n 10 -c 10 $SLOW_CONCURRENT_URL

En el resultado de hey, deberías ver que todas las solicitudes se procesan rápidamente:

Summary:
  Total:        0.2164 secs
  Slowest:      0.2163 secs
  Fastest:      0.0921 secs
  Average:      0.2033 secs
  Requests/sec: 46.2028

  Total data:   310 bytes
  Size/request: 31 bytes

Response time histogram:
  0.092 [1]     |■■■■
  0.105 [0]     |
  0.117 [0]     |
  0.129 [0]     |
  0.142 [0]     |
  0.154 [0]     |
  0.167 [0]     |
  0.179 [0]     |
  0.191 [0]     |
  0.204 [0]     |
  0.216 [9]     |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

Una sola instancia de función pudo controlar todas las solicitudes y el problema del inicio en frío desapareció, gracias al aumento de la simultaneidad.

Consulta simultaneidad para obtener más información.

10. ¡Felicitaciones!

¡Felicitaciones por completar el codelab!

Temas abordados

Descripción general de Cloud Functions (2nd gen).
Cómo escribir una función que responda a llamadas HTTP
Cómo escribir una función que responda a los mensajes de Pub/Sub
Cómo escribir una función que responda a los eventos de Cloud Storage
Cómo escribir una función que responda a los Registros de auditoría de Cloud
Cómo dividir el tráfico entre dos revisiones
Cómo deshacerte de los inicios en frío con instancias mínimas
Cómo configurar la simultaneidad