Organiza tus páginas con colecciones
Guarda y categoriza el contenido según tus preferencias.
Cloud Functions para Firebase
plat_ios
plat_android
plat_web
plat_flutter
plat_cpp
plat_unity
Cloud Functions para Firebase es un framework sin servidores que
te permite ejecutar automáticamente el código de backend en respuesta a los eventos que activan los eventos en segundo plano, las solicitudes HTTPS, el
Admin SDK o los trabajos de
Cloud Scheduler. Tu
código JavaScript, TypeScript o Python se almacena en la infraestructura de Google Cloud
y se ejecuta en un entorno administrado. No necesitas administrar ni escalar tus propios servidores.
¿Ya usas Cloud Functions en Google Cloud?
Obtén más información sobre cómo Firebase se ajusta
al contexto.
Comenzar
Casos de uso
Funciones clave
Integra las funciones de Firebase y conecta Firebase con
Google Cloud |
Las funciones que escribes pueden responder a eventos generados por varias
funciones de Firebase y Google Cloud, desde
activadores de Firebase Authentication
hasta activadores de Cloud Storage.
Integra distintas funciones de Firebase con el
SDK de Admin
y Cloud Functions. Además, escribe tus propios webhooks para realizar la integración en
servicios de terceros.
Cloud Functions minimiza el código
estándar, lo que facilita el uso de Firebase y Google Cloud en tu
función. |
Sin mantenimiento |
Implementa tu código de JavaScript, TypeScript o Python en nuestros servidores con un
comando desde la línea de comandos.
Después de eso, Firebase aumenta los recursos de procesamiento automáticamente según
los patrones de uso de los usuarios. No tendrás que preocuparte por las credenciales,
la configuración de servidores, el aprovisionamiento de servidores nuevos ni por sacar de servicio los servidores
antiguos. |
Protege la privacidad y seguridad de tu lógica |
En muchos casos, los desarrolladores prefieren controlar la lógica de la aplicación en el
servidor para evitar alteraciones del lado del cliente. A veces,
no es recomendable permitir que se aplique ingeniería inversa a ese código.
Cloud Functions está completamente aislada del cliente, de manera que
puedes estar seguro de su privacidad y de que siempre hará lo que quieres. |
¿Cómo funciona?
Después de escribir e implementar una función, los servidores de Google comienzan a administrarla de inmediato. Puedes activar la función directamente con una solicitud HTTP, Admin SDK o una trabajo programado, o, en el caso de funciones en segundo plano, los servidores de Google detectan los eventos y ejecutan la función cuando se activa.
A medida que la carga aumenta o disminuye, la respuesta de Google es escalar con rapidez la cantidad de instancias de servidor virtual necesarias para ejecutar la función. Cada función se ejecuta sin ayuda, en su propio entorno y con su propia configuración.
Ciclo de vida de una función en segundo plano
- Escribe código para una función nueva, selecciona un proveedor de eventos (como
Cloud Firestore) y define las condiciones en las que debe ejecutarse
la función.
- Cuando implementas la función, sucede lo siguiente:
- Firebase CLI crea un archivo
.zip
del código de la función,
que luego se sube a un bucket de Cloud Storage (con el prefijo
gcf-sources
) antes
de que Cloud Functions cree un repositorio de Artifact Registry (llamado
gcf-artifacts
) en tu proyecto.
- Cloud Build recupera el código de la función y compila la fuente
de esta. Puedes ver los registros de Cloud Build en la
consola de Google Cloud.
- La imagen del contenedor del código de las funciones compiladas se sube a
un repositorio privado de Artifact Registry en tu proyecto
(llamado
gcf-artifacts
) y se lanza la función nueva.
- Cuando el proveedor de eventos genera un evento que coincide con las condiciones
de la función, se invoca el código. La función tiene adjunta una cuenta de servicio que se puede usar para acceder a otros servicios de Firebase con la ayuda de Firebase Admin SDK.
- Si la función está ocupada con muchos eventos, Google crea más instancias
para controlar el trabajo con mayor rapidez. Si la función está inactiva, se borran las instancias.
- Cuando actualizas la función implementando el código actualizado, se borran las instancias de
versiones anteriores junto con los artefactos de compilación en
Artifact Registry, y se reemplazan por instancias nuevas.
- Cuando borras la función, se borran todas las instancias y los archivos ZIP,
junto con los artefactos de compilación relacionados en Artifact Registry.
También se quita la conexión entre la función y el proveedor de eventos.
Además de detectar los eventos con una función en segundo plano, puedes llamar a las funciones directamente con una solicitud HTTP o una llamada del cliente. También puedes activar funciones
en un programa fijo o
poner en cola funciones de tareas a través de Admin SDK.
Ruta de implementación
|
Configurar Cloud Functions |
Instala Firebase CLI y, luego, inicializa
Cloud Functions en tu proyecto de Firebase. |
|
Escribe funciones |
Escribe código JavaScript, TypeScript o Python
para controlar eventos de servicios
de Firebase, servicios de Google Cloud y otros proveedores de eventos. |
|
Prueba funciones |
Usa el emulador local
para probar tus funciones. |
|
Implementa y supervisa |
Actualiza tu proyecto al plan de precios Blaze de pago por uso y, luego, implementa tus
funciones con Firebase CLI. Luego, puedes usar la
consola de Google Cloud
para ver los registros y buscar entre ellos. |
Próximos pasos
Salvo que se indique lo contrario, el contenido de esta página está sujeto a la licencia Atribución 4.0 de Creative Commons, y los ejemplos de código están sujetos a la licencia Apache 2.0. Para obtener más información, consulta las políticas del sitio de Google Developers. Java es una marca registrada de Oracle o sus afiliados.
Última actualización: 2025-08-17 (UTC)
[null,null,["Última actualización: 2025-08-17 (UTC)"],[],[],null,["Cloud Functions for Firebase \nplat_ios plat_android plat_web plat_flutter plat_cpp plat_unity \nCloud Functions for Firebase is a serverless framework that lets you automatically run backend code in response to events triggered by background events, HTTPS requests, the Admin SDK, or Cloud Scheduler jobs. Your JavaScript, TypeScript or Python code is stored on Google Cloud infrastructure and runs in a managed environment. There's no need to manage and scale your own servers.\n\n\u003cbr /\u003e\n\nAlready using Cloud Functions in Google Cloud?\n[Learn more](/docs/functions/functions-and-firebase) about how Firebase fits\ninto the picture.\n\n[Get started](/docs/functions/get-started)\n[Use cases](/docs/functions/use-cases)\n\nKey capabilities\n\n|----------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| Integrates Firebase features and connects Firebase with Google Cloud | The functions you write can respond to events generated by various Firebase and Google Cloud features, from [Firebase Authentication triggers](/docs/functions/auth-events) to [Cloud Storage Triggers](/docs/functions/gcp-storage-events). Integrate across Firebase features using the [Admin SDK](/docs/admin/setup) together with Cloud Functions, and integrate with third-party services by writing your own webhooks. Cloud Functions minimizes boilerplate code, making it easier to use Firebase and Google Cloud inside your function. |\n| Zero maintenance | Deploy your JavaScript, TypeScript, or Python code to our servers with one command from the command line. After that, Firebase automatically scales up computing resources to match the usage patterns of your users. You never worry about credentials, server configuration, provisioning new servers, or decommissioning old ones. |\n| Keeps your logic private and secure | In many cases, developers prefer to control application logic on the server to avoid tampering on the client side. Also, sometimes it's not desirable to allow that code to be reverse engineered. Cloud Functions is fully insulated from the client, so you can be sure it is private and always does exactly what you want. |\n\nHow does it work?\n\nAfter you write and deploy a function, Google's servers begin to manage the\nfunction immediately. You can fire the function directly with an HTTP request,\nthe Admin SDK, or a scheduled job, or, in the case of background functions,\nGoogle's servers listen for events and run the function when it is\ntriggered.\n\nAs the load increases or\ndecreases, Google responds by rapidly scaling the number of virtual server\ninstances needed to run your function. Each function runs in isolation, in its\nown environment with its own configuration.\n\nLifecycle of a background function\n\n1. You write code for a new function, selecting an event provider (such as Cloud Firestore), and defining the conditions under which the function should execute.\n2. When you deploy your function:\n 1. The Firebase CLI creates a `.zip` archive of the function code, which is then uploaded to a Cloud Storage bucket (prefixed with `gcf-sources`) before Cloud Functions creates an Artifact Registry repository (named `gcf-artifacts`) in your project.\n 2. Cloud Build retrieves the function code and builds the function source. You can view Cloud Build logs in the [Google Cloud console](//console.cloud.google.com/logs/query;query%3Dresource.type%253D%2522build%2522&sa=D&ust=1597179510979000&usg=AFQjCNG2BmFrgWjGoP83WiMrB2TLLXpBEQ).\n 3. The container image for the built functions code is uploaded to a private Artifact Registry repository in your project (named `gcf-artifacts`), and your new function is rolled out.\n3. When the event provider generates an event that matches the function's conditions, the code is invoked. The function has a service account attached to it that can be used to access other Firebase services with the help of the Firebase Admin SDK.\n4. If the function is busy handling many events, Google creates more instances to handle work faster. If the function is idle, instances are cleaned up.\n5. When you update the function by deploying updated code, instances for older versions are cleaned up along with build artifacts in Artifact Registry, and replaced by new instances.\n6. When you delete the function, all instances and zip archives are cleaned up, along with related build artifacts in Artifact Registry. The connection between the function and the event provider is removed.\n\nIn addition to listening for events with a background function, you can call\nfunctions directly with an HTTP request or a\n[call from the client](/docs/functions/callable). You can also trigger functions\non a fixed [schedule](/docs/functions/schedule-functions) or\n[enqueue task functions](/docs/functions/task-functions) via the Admin SDK.\n\nImplementation path\n\n|---|------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| | Set up Cloud Functions | Install the Firebase CLI and initialize Cloud Functions in your Firebase project. |\n| | Write functions | Write JavaScript code, TypeScript code, or Python code to handle events from Firebase services, Google Cloud services, or other event providers. |\n| | Test functions | Use the [local emulator](/docs/functions/local-emulator) to test your functions. |\n| | Deploy and monitor | Upgrade your project to the [pay-as-you-go Blaze pricing plan](/pricing) and deploy your functions using the Firebase CLI. You can then use the [Google Cloud console](//console.cloud.google.com/functions/list) to view and search through your logs. |\n\nNext steps\n\n- [Get started](/docs/functions/get-started) setting up, creating, and deploying functions.\n- Learn more about [what you can do with functions](/docs/functions/use-cases).\n- Try the [Cloud Functions codelab](https://codelabs.developers.google.com/codelabs/firebase-cloud-functions/#0)."]]