Zadbaj o dobrą organizację dzięki kolekcji
Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.
Cloud Functions dla Firebase
plat_ios
plat_android
plat_web
plat_flutter
plat_cpp
plat_unity
Cloud Functions dla Firebase to bezserwerowa platforma, która umożliwia automatyczne uruchamianie kodu backendu w odpowiedzi na zdarzenia wywoływane przez zdarzenia w tle, żądania HTTPS,
Admin SDK lub zadania
Cloud Scheduler. Kod w języku JavaScript, TypeScript lub Python jest przechowywany w infrastrukturze Google Cloud i działa w zarządzanym środowisku. Nie musisz zarządzać własnymi serwerami ani ich skalować.
Korzystasz już z Cloud Functions w Google Cloud?
Więcej informacji o tym, jak Firebase wpisuje się w ten obraz.
Pierwsze kroki
Przypadki użycia
Najważniejsze funkcje
| Integracja funkcji Firebase i łączenie Firebase z Google Cloud |
Napisane przez Ciebie funkcje mogą reagować na zdarzenia generowane przez różne usługi Firebase i Google Cloud, od aktywatorów Uwierzytelniania Firebase po aktywatory Cloud Storage.
Integracja z różnymi funkcjami Firebase za pomocą pakietu Admin SDK w połączeniu z Cloud Functions oraz integracja z usługami innych firm przez pisanie własnych webhooków.
Cloud Functions minimalizuje powtarzalny kod, co ułatwia korzystanie z Firebase i Google Cloud w funkcji. |
| Bezobsługowość |
Wdrażaj kod w JavaScript, TypeScript lub Pythonie na naszych serwerach za pomocą jednego polecenia w wierszu poleceń.
Gdy to zrobisz, Firebase będzie automatycznie skalować zasoby obliczeniowe w górę, w zależności od wzorców wykorzystania aplikacji przez użytkowników. Nie musisz zawracać sobie głowy danymi logowania, konfigurowaniem serwera, udostępnianiem nowych serwerów ani wycofywaniem z użytku starych. |
| Prywatność i bezpieczeństwo logiki użytkownika |
Wielu deweloperów woli kontrolować logikę aplikacji na serwerze, aby uniknąć manipulacji po stronie klienta. Czasami nie jest też pożądane, aby kod ten można było analizować wstecznie.
Cloud Functions jest całkowicie odizolowany od klienta, więc możesz mieć pewność, że jest prywatny i zawsze robi dokładnie to, czego oczekujesz. |
Jak to działa?
Po napisaniu i wdrożeniu funkcji serwery Google natychmiast zaczynają nią zarządzać. Funkcję możesz uruchomić bezpośrednio za pomocą żądania HTTP, Admin SDK lub zaplanowanego zadania. W przypadku funkcji działających w tle serwery Google nasłuchują zdarzeń i uruchamiają funkcję, gdy zostanie ona wywołana.
W miarę wzrostu lub spadku obciążenia Google szybko skaluje liczbę instancji serwera wirtualnego potrzebnych do uruchomienia funkcji. Każda funkcja działa w izolacji, we własnym środowisku z własną konfiguracją.
Cykl życia funkcji w tle
- Piszesz kod nowej funkcji, wybierając dostawcę zdarzeń (np.Cloud Firestore) i określając warunki, w których funkcja ma być wykonywana.
- Podczas wdrażania funkcji:
- Interfejs wiersza poleceń Firebase tworzy archiwum
.zip z kodem funkcji, które jest następnie przesyłane do zasobnika Cloud Storage (z prefiksem gcf-sources), zanim Cloud Functions utworzy w Twoim projekcie repozytorium Artifact Registry (o nazwie gcf-artifacts).
- Cloud Build pobiera kod funkcji i tworzy źródło funkcji. Dzienniki Cloud Build możesz wyświetlić w Google Cloudkonsoli.
- Obraz kontenera z skompilowanym kodem funkcji jest przesyłany do prywatnego repozytorium Artifact Registry w Twoim projekcie (o nazwie
gcf-artifacts), a nowa funkcja jest wdrażana.
- Gdy dostawca zdarzeń wygeneruje zdarzenie, które spełnia warunki funkcji, kod zostanie wywołany. Funkcja ma dołączone konto usługi, które można wykorzystać do uzyskiwania dostępu do innych usług Firebase za pomocą Firebase Admin SDK.
- Jeśli funkcja jest zajęta obsługą wielu zdarzeń, Google tworzy więcej instancji, aby szybciej wykonywać zadania. Jeśli funkcja jest bezczynna, instancje są czyszczone.
- Gdy zaktualizujesz funkcję, wdrażając zaktualizowany kod, instancje starszych wersji zostaną usunięte wraz z artefaktami kompilacji w Artifact Registry i zastąpione nowymi instancjami.
- Gdy usuniesz funkcję, wszystkie instancje i archiwa ZIP zostaną wyczyszczone, a także powiązane artefakty kompilacji w Artifact Registry.
Połączenie między funkcją a dostawcą zdarzeń zostanie usunięte.
Oprócz nasłuchiwania zdarzeń za pomocą funkcji działającej w tle możesz wywoływać funkcje bezpośrednio za pomocą żądania HTTP lub wywołania z klienta. Możesz też aktywować funkcje zgodnie z ustalonym harmonogramem lub kolejkować funkcje zadań za pomocą ikony Admin SDK.
Ścieżka implementacji
|
Skonfiguruj usługę Cloud Functions |
Zainstaluj Firebase CLI i zainicjuj Cloud Functions w projekcie Firebase. |
|
Pisanie funkcji |
Pisz kod w JavaScript, TypeScript lub Pythonie, aby obsługiwać zdarzenia z usług Firebase, usług Google Cloud lub innych dostawców zdarzeń. |
|
Funkcje testowe |
Użyj lokalnego emulatora, aby przetestować funkcje. |
|
Wdrażanie i monitorowanie |
Przenieś projekt na abonament Blaze z płatnością według wykorzystania i wdrażaj funkcje za pomocą interfejsu wiersza poleceń Firebase. Następnie możesz użyć
Google Cloud konsoli, aby wyświetlać i przeszukiwać logi. |
Dalsze kroki
O ile nie stwierdzono inaczej, treść tej strony jest objęta licencją Creative Commons – uznanie autorstwa 4.0, a fragmenty kodu są dostępne na licencji Apache 2.0. Szczegółowe informacje na ten temat zawierają zasady dotyczące witryny Google Developers. Java jest zastrzeżonym znakiem towarowym firmy Oracle i jej podmiotów stowarzyszonych.
Ostatnia aktualizacja: 2025-08-17 UTC.
[null,null,["Ostatnia aktualizacja: 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)."]]
