Mantenha tudo organizado com as coleções
Salve e categorize o conteúdo com base nas suas preferências.
Cloud Functions para Firebase
plat_ios
plat_android
plat_web
plat_flutter
plat_cpp
plat_unity
O
Cloud Functions para Firebase é um framework sem servidor que
permite executar automaticamente códigos de back-end em resposta a eventos acionados por
eventos em segundo plano, solicitações HTTPS, o
Admin SDK ou jobs do
Cloud Scheduler. Seu
código em JavaScript, TypeScript ou Python é armazenado na infraestrutura do Google Cloud
e executado em um ambiente gerenciado. Não é necessário gerenciar e escalonar
servidores próprios.
Você já usa o Cloud Functions no Google Cloud?
Saiba mais sobre o papel do Firebase
nesse contexto.
Introdução
Casos de uso
Principais recursos
| Integra os recursos do Firebase e conecta o Firebase ao
Google Cloud |
As funções criadas podem responder a eventos gerados por vários
recursos do Firebase e do Google Cloud, de
gatilhos do Firebase Authentication
a gatilhos do Cloud Storage.
Faça a integração em todos os recursos do Firebase com o
SDK Admin
junto ao Cloud Functions. Além disso, grave seus próprios webhooks
para fazer a integração com serviços de terceiros.
O Cloud Functions minimiza o código boilerplate,
facilitando o uso do Firebase e do Google Cloud na sua
função. |
| Manutenção zero |
Implante seu código em JavaScript, TypeScript ou Python nos nossos servidores com apenas um
comando na linha de comando.
Em seguida, o Firebase escalona automaticamente os recursos computacionais para corresponder
aos padrões de uso dos seus usuários. Você não precisa se preocupar com credenciais,
configuração e provisionamento de novos servidores ou desativação
dos antigos. |
| Mantém a privacidade e a segurança do seu código |
Em muitos casos, os desenvolvedores preferem controlar a lógica do aplicativo no
servidor para evitar adulterações no lado do cliente. Além disso, às vezes,
eles querem evitar a engenharia reversa desse código.
O Cloud Functions é totalmente isolado do cliente. Assim,
é possível ter a certeza de que o código permanecerá particular e sempre fará exatamente o que você quer. |
Como funciona?
Depois que você escreve e implanta uma função, os servidores do Google começam a gerenciá-la
imediatamente. Você pode acionar a função diretamente com uma solicitação HTTP,
com o Admin SDK ou com um job programado. No caso de funções em segundo plano,
os servidores do Google detectam eventos e executam a função quando ela é
acionada.
À medida que a carga aumenta ou
diminui, o Google responde escalonando rapidamente o número de instâncias de servidor
virtual necessárias para executar sua função. Cada função é executada isoladamente, no
próprio ambiente e com a própria configuração.
Ciclo de vida de uma função de segundo plano
- Você escreve o código para uma nova função, seleciona um provedor de eventos, como o
Cloud Firestore, e define as condições sob as quais
ela precisa ser executada.
- Quando você implanta a função:
- A CLI do Firebase cria um arquivo
.zip com base no código da função,
que é enviado para um bucket do Cloud Storage (prefixado com
gcf-sources) antes que
o Cloud Functions crie um repositório do Artifact Registry (chamado
gcf-artifacts) no projeto.
- O Cloud Build recupera o código da função e cria a fonte
dela. É possível conferir os registros do Cloud Build no
console do Google Cloud.
- A imagem de contêiner do código de funções criado é enviada para um
repositório particular do Artifact Registry no projeto
(chamado
gcf-artifacts), e a nova função é lançada.
- Quando o provedor de eventos gera um evento que corresponde às condições
da função, o código é invocado. A função tem uma conta de serviço anexada
que pode ser usada para acessar outros serviços do Firebase com a ajuda do
Firebase Admin SDK.
- Se a função estiver ocupada com muitos eventos, o Google criará mais instâncias
para executar o trabalho com mais rapidez. Caso a função esteja ociosa, as instâncias serão limpas.
- Ao atualizar a função implantando o código atualizado, as instâncias de versões
mais antigas são limpas, além dos artefatos de builds, no
Artifact Registry e substituídas por novas instâncias.
- Ao excluir a função, todas as instâncias e arquivos ZIP são limpos,
além dos artefatos de builds relacionados, no Artifact Registry.
A conexão entre a função e o provedor de eventos é removida.
Além de detectar eventos com uma função de segundo plano, você pode chamá-las diretamente com uma solicitação HTTP ou uma chamada do cliente. Também é possível acionar funções
em uma programação fixa ou
enfileirar funções de tarefas usando o Admin SDK.
Caminho de implementação
|
Configurar Cloud Functions |
Instale a CLI do Firebase e inicialize
o Cloud Functions no projeto do Firebase. |
|
Escrever funções |
Escreva códigos em JavaScript, TypeScript ou Python
para processar eventos de serviços do
Firebase, do Google Cloud ou de outros provedores de eventos. |
|
Testar funções |
Use o emulador local
para testar suas funções. |
|
Implantar e monitorar |
Faça upgrade do seu projeto para o plano de preços Blaze de pagamento por uso e implante as
funções usando a CLI Firebase. Depois, você pode usar o
console Google Cloud
para conferir e pesquisar seus registros. |
Próximas etapas
Exceto em caso de indicação contrária, o conteúdo desta página é licenciado de acordo com a Licença de atribuição 4.0 do Creative Commons, e as amostras de código são licenciadas de acordo com a Licença Apache 2.0. Para mais detalhes, consulte as políticas do site do Google Developers. Java é uma marca registrada da Oracle e/ou afiliadas.
Última atualização 2025-08-17 UTC.
[null,null,["Última atualização 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)."]]
