Restez organisé à l'aide des collections
Enregistrez et classez les contenus selon vos préférences.
Cloud Functions pour Firebase
plat_ios
plat_android
plat_web
plat_flutter
plat_cpp
plat_unity
Cloud Functions pour Firebase est un framework sans serveur qui vous permet d'exécuter automatiquement du code de backend en réponse à des événements déclenchés par des événements en arrière-plan, des requêtes HTTPS, le
Admin SDK ou des jobs
Cloud Scheduler. Votre code JavaScript, TypeScript ou Python est stocké sur l'infrastructure Google Cloud et s'exécute dans un environnement géré. Vous n'avez pas besoin de gérer ni de faire évoluer vos propres serveurs.
Vous utilisez déjà Cloud Functions dans Google Cloud ?
En savoir plus sur la place de Firebase dans l'ensemble.
Premiers pas
Cas d'utilisation
Capacités clés
Intègre les fonctionnalités Firebase et connecte Firebase à Google Cloud |
Les fonctions que vous écrivez peuvent répondre à des événements générés par diverses fonctionnalités Firebase et Google Cloud, des déclencheurs Firebase Authentication aux déclencheurs Cloud Storage.
Intégrez les fonctionnalités Firebase à l'aide du SDK Admin avec Cloud Functions, et intégrez des services tiers en écrivant vos propres Webhooks.
Cloud Functions minimise le code récurrent, ce qui facilite l'utilisation de Firebase et de Google Cloud dans votre fonction. |
Aucune maintenance nécessaire |
Déployez votre code JavaScript, TypeScript ou Python sur nos serveurs à l'aide d'une seule commande de la ligne de commande.
Ensuite, Firebase effectue un scaling automatique des ressources de calcul afin de s'adapter aux tendances des utilisateurs. Vous n'avez plus à vous préoccuper des identifiants, de la configuration des serveurs, du provisionnement de nouveaux serveurs ou de la mise hors service des anciens serveurs. |
Protégez la confidentialité et la sécurité de votre logique |
Dans de nombreux cas, les développeurs préfèrent contrôler la logique de l'application sur le serveur pour éviter toute falsification côté client. De plus, il n'est parfois pas souhaitable d'autoriser la rétro-ingénierie de ce code.
Cloud Functions est entièrement isolé du client. Vous pouvez donc être sûr qu'il est privé et qu'il fait toujours exactement ce que vous voulez. |
Fonctionnement
Une fois que vous avez écrit et déployé une fonction, les serveurs de Google commencent immédiatement à la gérer. Vous pouvez déclencher la fonction directement avec une requête HTTP, Admin SDK ou un job planifié. Dans le cas des fonctions en arrière-plan, les serveurs Google écoutent les événements et exécutent la fonction lorsqu'elle est déclenchée.
À mesure que la charge augmente ou diminue, Google répond en ajustant rapidement le nombre d'instances de serveur virtuel nécessaires à l'exécution de votre fonction. Chaque fonction s'exécute de manière isolée, dans son propre environnement avec sa propre configuration.
Cycle de vie d'une fonction d'arrière-plan
- Vous écrivez le code d'une nouvelle fonction, en sélectionnant un fournisseur d'événements (tel que Cloud Firestore) et en définissant les conditions dans lesquelles la fonction doit s'exécuter.
- Lorsque vous déployez votre fonction :
- La CLI Firebase crée une archive
.zip
du code de la fonction, qui est ensuite importée dans un bucket Cloud Storage (avec le préfixe gcf-sources
) avant que Cloud Functions ne crée un dépôt Artifact Registry (nommé gcf-artifacts
) dans votre projet.
- Cloud Build récupère le code de la fonction et crée la source de la fonction. Vous pouvez afficher les journaux Cloud Build dans la console Google Cloud.
- L'image de conteneur pour le code des fonctions compilées est importée dans un dépôt Artifact Registry privé de votre projet (nommé
gcf-artifacts
), et votre nouvelle fonction est déployée.
- Lorsque le fournisseur d'événements génère un événement qui correspond aux conditions de la fonction, le code est appelé. La fonction est associée à un compte de service qui peut être utilisé pour accéder à d'autres services Firebase à l'aide de Firebase Admin SDK.
- Si la fonction est occupée à gérer de nombreux événements, Google crée d'autres instances pour traiter le travail plus rapidement. Si la fonction est inactive, les instances sont nettoyées.
- Lorsque vous mettez à jour la fonction en déployant le code modifié, les instances des anciennes versions sont nettoyées en même temps que les artefacts de compilation dans Artifact Registry et remplacées par de nouvelles instances.
- Lorsque vous supprimez la fonction, toutes les instances et les archives ZIP sont nettoyées, ainsi que les artefacts de compilation associés dans Artifact Registry.
La connexion entre la fonction et le fournisseur d'événements est supprimée.
En plus d'écouter les événements avec une fonction d'arrière-plan, vous pouvez appeler des fonctions directement avec une requête HTTP ou un appel depuis le client. Vous pouvez également déclencher des fonctions selon un planning fixe ou mettre en file d'attente des fonctions de tâches via Admin SDK.
Chemin d'accès de l'exécution
|
Configurer Cloud Functions |
Installez la CLI Firebase et initialisez Cloud Functions dans votre projet Firebase. |
|
Écrire des fonctions |
Écrivez du code JavaScript, TypeScript ou Python pour gérer les événements des services Firebase, des services Google Cloud ou d'autres fournisseurs d'événements. |
|
Fonctions de test |
Utilisez l'émulateur local pour tester vos fonctions. |
|
Déployer et surveiller |
Mettez à jour votre projet pour utiliser le forfait Blaze avec paiement à l'usage et déployez vos fonctions à l'aide de la CLI Firebase. Vous pouvez ensuite utiliser la
console Google Cloud
pour afficher vos journaux et les parcourir. |
Étapes suivantes
Sauf indication contraire, le contenu de cette page est régi par une licence Creative Commons Attribution 4.0, et les échantillons de code sont régis par une licence Apache 2.0. Pour en savoir plus, consultez les Règles du site Google Developers. Java est une marque déposée d'Oracle et/ou de ses sociétés affiliées.
Dernière mise à jour le 2025/08/17 (UTC).
[null,null,["Dernière mise à jour le 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)."]]