Mantieni tutto organizzato con le raccolte
Salva e classifica i contenuti in base alle tue preferenze.
Cloud Functions per Firebase
plat_ios
plat_android
plat_web
plat_flutter
plat_cpp
plat_unity
Cloud Functions per Firebase è un framework serverless che
ti consente di eseguire automaticamente codice di backend in risposta a eventi attivati da
eventi in background, richieste HTTPS,
Admin SDK o job
Cloud Scheduler. Il tuo codice
JavaScript, TypeScript o Python è archiviato nell'infrastruttura Google Cloud
e viene eseguito in un ambiente gestito. Non è necessario gestire e scalare i tuoi server.
Utilizzi già Cloud Functions in Google Cloud?
Scopri di più su come Firebase si inserisce
nel quadro generale.
Inizia
Casi d'uso
Funzionalità chiave
| Integra le funzionalità di Firebase e lo collega a
Google Cloud |
Le funzioni che scrivi possono rispondere a eventi generati da varie
funzionalità di Firebase e Google Cloud, dai
trigger di Firebase Authentication
ai trigger di Cloud Storage.
Esegui l'integrazione tra le funzionalità di Firebase utilizzando l'SDK Admin insieme a Cloud Functions ed esegui l'integrazione con servizi di terze parti scrivendo i tuoi webhook.
Cloud Functions riduce al minimo il codice boilerplate, semplificando l'utilizzo di Firebase e Google Cloud all'interno della funzione. |
| Nessuna manutenzione |
Esegui il deployment del tuo codice JavaScript, TypeScript o Python sui nostri server con un solo comando dalla riga di comando.
A quel punto, Firebase eseguirà automaticamente la scalabilità delle risorse di elaborazione in modo da trovare una corrispondenza ai pattern di utilizzo dei tuoi utenti. Non dovrai mai preoccuparti di credenziali,
configurazione server, provisioning di nuovi server o ritiro di quelli obsoleti. |
| Mantieni la tua logica privata e al sicuro |
In molti casi, gli sviluppatori preferiscono controllare la logica dell'applicazione sul
server per evitare manomissioni sul lato client. Inoltre, a volte
non è consigliabile consentire il reverse engineering del codice.
Cloud Functions è completamente isolato dal client, quindi
puoi essere certo che sia privato e faccia sempre esattamente ciò che vuoi. |
Come funziona?
Dopo aver scritto ed eseguito il deployment di una funzione, i server di Google iniziano a gestirla immediatamente. Puoi attivare la funzione direttamente con una richiesta HTTP, con Admin SDK o con un job pianificato oppure, nel caso delle funzioni in background, i server di Google ascoltano gli eventi ed eseguono la funzione quando viene attivata.
Man mano che il carico aumenta o diminuisce, Google risponde scalando rapidamente il numero di istanze di server virtuali necessarie per eseguire la funzione. Ogni funzione viene eseguita in isolamento, nel proprio ambiente con la propria configurazione.
Ciclo di vita di una funzione in background
- Scrivi il codice per una nuova funzione, selezionando un provider di eventi (ad esempio
Cloud Firestore) e definendo le condizioni in base alle quali la funzione deve
essere eseguita.
- Quando esegui il deployment della funzione:
- La CLI Firebase crea un archivio
.zip del codice della funzione,
che viene poi caricato in un bucket Cloud Storage (con il prefisso
gcf-sources) prima che
Cloud Functions crei un repository Artifact Registry (denominato
gcf-artifacts) nel tuo progetto.
- Cloud Build recupera il codice della funzione e crea l'origine della funzione. Puoi visualizzare i log di Cloud Build nella
console Google Cloud.
- L'immagine container per il codice delle funzioni create viene caricata in un repository Artifact Registry privato nel tuo progetto (denominato
gcf-artifacts) e la tua nuova funzione viene implementata.
- Quando il provider di eventi genera un evento che corrisponde alle condizioni della funzione, il codice viene richiamato. La funzione ha un service account collegato
che può essere utilizzato per accedere ad altri servizi Firebase con l'aiuto di
Firebase Admin SDK.
- Se la funzione è occupata a gestire molti eventi, Google crea più istanze
per gestire il lavoro più rapidamente. Se la funzione è inattiva, le istanze vengono pulite.
- Quando aggiorni la funzione eseguendo il deployment del codice aggiornato, le istanze delle versioni precedenti vengono pulite insieme agli artefatti di build in Artifact Registry e sostituite da nuove istanze.
- Quando elimini la funzione, vengono ripulite tutte le istanze e gli archivi zip,
insieme agli artefatti di build correlati in Artifact Registry.
La connessione tra la funzione e il provider di eventi viene rimossa.
Oltre ad ascoltare gli eventi con una funzione in background, puoi chiamare le funzioni direttamente con una richiesta HTTP o una chiamata dal client. Puoi anche attivare funzioni
in base a una pianificazione fissa o
accodare funzioni di attività tramite Admin SDK.
Percorso di implementazione
|
Configura Cloud Functions |
Installa l'interfaccia a riga di comando Firebase e inizializza
Cloud Functions nel tuo progetto Firebase. |
|
Scrivere funzioni |
Scrivi codice JavaScript, TypeScript o Python
per gestire gli eventi provenienti da servizi Firebase, servizi Google Cloud o altri fornitori di eventi. |
|
Funzioni di test |
Utilizza l'emulatore locale
per testare le tue funzioni. |
|
Esegui il deployment e monitora |
Esegui l'upgrade del tuo progetto al piano tariffario Blaze con pagamento a consumo ed esegui il deployment delle tue
funzioni utilizzando la CLI Firebase. Puoi quindi utilizzare la
console Google Cloud
per visualizzare e cercare nei log. |
Passaggi successivi
Salvo quando diversamente specificato, i contenuti di questa pagina sono concessi in base alla licenza Creative Commons Attribution 4.0, mentre gli esempi di codice sono concessi in base alla licenza Apache 2.0. Per ulteriori dettagli, consulta le norme del sito di Google Developers. Java è un marchio registrato di Oracle e/o delle sue consociate.
Ultimo aggiornamento 2025-08-17 UTC.
[null,null,["Ultimo aggiornamento 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)."]]
