Você pode implantar, excluir e modificar funções usando os comandos da CLI do Firebase ou definindo opções de ambiente de execução no código-fonte das suas funções.
Implantar funções
Para implantar funções, execute este comando da CLI do Firebase:
firebase deploy --only functions
Por padrão, a CLI do Firebase implanta todas as funções dentro de
index.js
ao mesmo tempo. Se o projeto tiver mais de cinco funções,
recomendamos que você use a sinalização --only
com nomes de função específicos
para implantar apenas as
funções editadas. Implantar funções específicas
dessa forma acelera o procedimento e ajuda a evitar alcançar o limite de
cotas de implantação. Exemplo:
firebase deploy --only functions:addMessage,functions:makeUppercase
Ao implantar um grande número de funções, talvez você exceda a cota padrão e receba mensagens de erro HTTP 429 ou 500. Para resolver esse problema, implante funções em grupos de 10 ou menos.
Consulte a Referência da CLI do Firebase para ver uma lista completa de comandos disponíveis.
Por padrão, a CLI do Firebase procura o código-fonte
na pasta functions/
. É possível especificar outra pasta adicionando as seguintes linhas em
firebase.json
:
"functions": {
"source": "another-folder"
}
Excluir funções
Funções implantadas previamente podem ser excluídas:
- explicitamente na CLI do Firebase com
functions:delete
- explicitamente usando o menu de contexto na lista de funções no Console do Firebase
- implicitamente removendo a função de
index.js
antes da implantação.
Em todas as operações é necessário confirmar antes de remover a função da produção.
A exclusão explícita de funções na CLI do Firebase aceita vários argumentos, como grupos de funções, e permite especificar uma função executada em uma região específica. Além disso, você pode substituir o prompt de confirmação.
# Delete all functions that match the specified name in all regions. firebase functions:delete myFunction
# Delete a specified function running in a specific region. firebase functions:delete myFunction --region us-east-1
# Delete more than one function firebase functions:delete myFunction myOtherFunction
# Delete a specified functions group. firebase functions:delete groupA
# Bypass the confirmation prompt. firebase functions:delete myFunction --force
Com a exclusão implícita de funções, firebase deploy
analisa index.js
e
remove da produção todas as funções que foram removidas do arquivo.
Modificar o nome, a região ou o gatilho de uma função
Se você estiver renomeando ou alterando a região ou o gatilho para funções que estão manipulando o tráfego de produção, siga as etapas nesta seção para evitar a perda de eventos durante a modificação. Antes de prosseguir, verifique se a função é idempotente, já que a versão antiga e a nova serão executadas simultaneamente durante a modificação.
Renomear uma função
Para renomear uma função, crie uma nova versão renomeada da função em index.js
e
execute dois comandos de implantação separados. O primeiro comando implanta a
função recém-nomeada e o segundo remove a versão implementada
anteriormente. Por exemplo, se você tiver uma função chamada webhook
e quiser
alterá-la para webhookNew
, revise o código da seguinte maneira:
// before
const functions = require('firebase-functions');
exports.webhook = functions.https.onRequest((req, res) => {
res.send("Hello");
});
// after
const functions = require('firebase-functions');
exports.webhookNew = functions.https.onRequest((req, res) => {
res.send("Hello");
});
Em seguida, execute os seguintes comandos para implantar a nova função:
# Deploy new function called webhookNew firebase deploy --only functions:webhookNew # Wait until deployment is done; now both webhookNew and webhook are running # Delete webhook firebase functions:delete webhook
Alterar a região ou as regiões de uma função
Se você estiver alterando as regiões especificadas de uma função que processa tráfego de produção, poderá evitar a perda de eventos executando estas etapas na ordem a seguir:
- Renomeie a função e altere a região ou as regiões dela, conforme quiser.
- Implante a função renomeada, o que resulta na execução temporária do mesmo código nos dois conjuntos de regiões.
- Exclua a função anterior.
Por exemplo, se você tiver uma função chamada webhook
que esteja atualmente na
região de funções padrão de us-central1
e quiser migrá-la para
asia-northeast1
, primeiro será necessário modificar o código-fonte para renomear a
função e revisar a região.
// before
const functions = require('firebase-functions');
exports.webhook = functions
.https.onRequest((req, res) => {
res.send("Hello");
});
// after
const functions = require('firebase-functions');
exports.webhookAsia = functions
.region('asia-northeast1')
.https.onRequest((req, res) => {
res.send("Hello");
});
Em seguida, implante executando o comando:
firebase deploy --only functions:webhookAsia
Agora, há duas funções idênticas em execução: webhook
está em execução em us-central1
,
enquanto webhookAsia
está em execução em asia-northeast1
.
Em seguida, exclua webhook
:
firebase functions:delete webhook
Agora, há apenas uma função: webhookAsia
, que está sendo executada em asia-northeast1
.
Alterar o tipo de gatilho de uma função
À medida que você desenvolve sua implantação do Cloud Functions para Firebase ao longo do tempo, pode ser necessário alterar o tipo de gatilho de uma função por vários motivos. Por exemplo:
- Altere do evento
onChange
de armazenamento legado paraonFinalize
,onDelete
,onArchive
eonMetadataUpdate
. Saiba mais sobre isso no Guia de atualização da versão Beta à v1 ou v2. - Altere de um tipo de evento do Firebase Realtime Database ou do Cloud Firestore para outro, como o evento
onWrite
genérico para o eventoonCreate
granular.
Não é possível alterar o tipo de evento de uma função apenas alterando o
código-fonte e executando firebase deploy
. Para evitar erros,
altere o tipo de gatilho de uma função ao seguir este procedimento:
- Modifique o código-fonte para incluir uma nova função com o tipo de gatilho desejado.
- Implante a função, o que resulta na execução temporária da função antiga e da nova.
- Exclua explicitamente a função antiga da produção usando a CLI do Firebase.
Por exemplo, se você tiver uma função objectChanged
com o tipo de evento legado onChange
e quiser alterá-la para onFinalize
, renomeie a função e edite-a para ter o tipo de evento onFinalize
.
// before
const functions = require('firebase-functions');
exports.objectChanged = functions.storage.object().onChange((object) => {
return console.log('File name is: ', object.name);
});
// after
const functions = require('firebase-functions');
exports.objectFinalized = functions.storage.object().onFinalize((object) => {
return console.log('File name is: ', object.name);
});
Em seguida, execute os seguintes comandos para criar a nova função primeiro, antes de excluir a função antiga:
# Create new function objectFinalized firebase deploy --only functions:objectFinalized # Wait until deployment is done; now both objectChanged and objectFinalized are running # Delete objectChanged firebase functions:delete objectChanged
Definir opções do ambiente de execução
Com o Cloud Functions para Firebase, você pode selecionar opções, como a versão do ambiente de execução do Node.js, o tempo limite por função, a alocação de memória e a quantidade mínima/máxima de instâncias de função.
Definir a versão do Node.js
O SDK do Firebase para Cloud Functions 2.0.0 e versões mais recentes permite uma seleção do ambiente de execução do Node.js. É possível executar exclusivamente todas as funções em um projeto no ambiente de execução correspondente a uma dessas versões com suporte do Node.js:
- Node.js 16
- Node.js 14
- Node.js 12
- Node.js 10
- Node.js 8 (descontinuado em 8 de junho de 2020) A implantação de funções no ambiente de execução do Node.js 8 foi desativada na CLI do Firebase em 15 de dezembro de 2020. A execução de funções já implantadas vai ser interrompida em algum momento no futuro. Se você implantou funções no ambiente de execução do Node.js 8, recomendamos fazer upgrade para o ambiente de execução do Node.js 16.
Para definir a versão do Node.js, siga as etapas a seguir:
Defina a versão no campo engines
no arquivo
package.json
que foi criado no diretório functions/
durante a inicialização.
Por exemplo, para usar apenas a
versão 16, edite esta linha em package.json
:
"engines": {"node": "16"}
O campo engines
é obrigatório. Ele precisa especificar uma das versões com suporte do Node.js para que você possa implantar e executar funções. Atualmente,
firebase init functions
define esse campo como 16
.
Fazer upgrade do ambiente de execução do Node.js
Para fazer upgrade do ambiente de execução do Node.js, siga as etapas a seguir:
- Verifique se o projeto está no plano de preços Blaze.
- Verifique se você está usando a CLI do Firebase v9.17.0 ou mais recente.
- Altere o valor
engines
no arquivopackage.json
criado no diretóriofunctions/
durante a inicialização. Por exemplo, se você estiver fazendo upgrade da versão 10 para a versão 16, a entrada terá esta aparência:"engines": {"node": "16"}
- Se quiser, teste suas alterações usando o Pacote de emuladores locais do Firebase.
- Implante novamente as funções usando a CLI do Firebase v9.17.0 ou versões mais recentes.
Controlar o comportamento de escalonamento
Por padrão, o Cloud Functions para Firebase escalona o número de instâncias em execução com base no número de solicitações recebidas. Isso pode reduzir até zero a quantidade de instâncias em períodos de tráfego menor. No entanto, se o app exigir latência reduzida, e você quiser limitar o número de inicializações a frio, altere esse comportamento padrão especificando um número mínimo de instâncias de contêiner a serem mantidas quentes e prontas para exibir solicitações.
Da mesma forma, é possível definir um número máximo para limitar o escalonamento de instâncias em resposta a solicitações recebidas. Use essa configuração como uma maneira de controlar seus custos ou de limitar o número de conexões com um serviço de apoio, como um banco de dados.
Reduzir o número de inicializações a frio
Para definir o número mínimo de instâncias em uma função no código-fonte, use o
parâmetro
runWith
. Essa opção de ambiente de execução aceita
um objeto JSON em conformidade com
a interface
RuntimeOptions
, que define o valor de minInstances
. Por exemplo,
esta função define um mínimo de cinco instâncias que devem ser mantidas quentes:
exports.getAutocompleteResponse = functions
.runWith({
// Keep 5 instances warm for this latency-critical function
minInstances: 5,
})
.https.onCall((data, context) => {
// Autocomplete a user's search term
});
Veja alguns pontos a serem considerados ao definir um valor para minInstances
:
- Se o Cloud Functions para Firebase escalonar seu app acima da configuração
minInstances
, uma inicialização a frio será feita para cada instância acima desse limite. - Inicializações a frio têm o impacto mais grave em apps com tráfego intenso. Se o
aplicativo tiver tráfego com picos, e você definir um valor de
minInstances
alto o suficiente para que as inicializações a frio sejam reduzidas a cada aumento do tráfego, você notará uma latência significativamente reduzida. Para apps com tráfego constante, inicializações a frio não afetam muito o desempenho. Definir um limite de instâncias mínimas é uma boa ideia para ambientes de produção, mas isso geralmente deve ser evitado em ambientes de teste. Para reduzir a escala a zero no projeto de teste, mas ainda reduzir as inicializações a frio no projeto de produção, defina
minInstances
com base na variável de ambienteFIREBASE_CONFIG
:// Get Firebase project id from `FIREBASE_CONFIG` environment variable const envProjectId = JSON.parse(process.env.FIREBASE_CONFIG).projectId; exports.renderProfilePage = functions .runWith({ // Keep 5 instances warm for this latency-critical function // in production only. Default to 0 for test projects. minInstances: envProjectId === "my-production-project" ? 5 : 0, }) .https.onRequest((req, res) => { // render some html });
Limitar o número máximo de instâncias para uma função
Para definir o máximo de instâncias no código-fonte da função, use o
parâmetro
runWith
. Essa opção de ambiente de
execução aceita um objeto JSON em conformidade com a
interface
RuntimeOptions
, que define valores
para maxInstances
. Por exemplo, esta função define um limite de 100
instâncias para não sobrecarregar um banco de dados legado hipotético:
exports.mirrorOrdersToLegacyDatabase = functions
.runWith({
// Legacy database only supports 100 simultaneous connections
maxInstances: 100,
})
.firestore.document("orders/{orderId}")
.onWrite((change, context) => {
// Connect to legacy database
});
Se uma função HTTP for escalonada até o limite maxInstances
, as novas solicitações serão
enfileiradas por 30 segundos e rejeitadas com um código de resposta 429 Too Many Requests
se
nenhuma instância estiver disponível depois desse tempo.
Para saber mais sobre as práticas recomendadas para o uso das configurações de instâncias máximas,
confira estas
práticas recomendadas para usar maxInstances
.
Definir o tempo limite e a alocação de memória
Em alguns casos, suas funções podem ter requisitos especiais para um valor de tempo limite longo ou uma grande alocação de memória. Você pode definir esses valores no Console do Google Cloud ou no código-fonte da função (somente no Firebase).
Para definir a alocação de memória e o tempo limite no código-fonte das funções, use o
parâmetro runWith
introduzido no SDK do Firebase para Cloud Functions 2.0.0. Essa opção de ambiente de
execução aceita um objeto JSON em conformidade com a
interface
RuntimeOptions
, que define os valores para timeoutSeconds
e memory
.
Por exemplo, essa função de armazenamento usa 1 GB de memória e expira após
300 segundos:
exports.convertLargeFile = functions
.runWith({
// Ensure the function has enough memory and time
// to process large files
timeoutSeconds: 300,
memory: "1GB",
})
.storage.object()
.onFinalize((object) => {
// Do some complicated things that take a lot of memory and time
});
O valor máximo para timeoutSeconds
é 540
ou 9 minutos.
A quantidade de memória concedida a uma função corresponde à CPU alocada para a função, conforme detalhado nesta lista de valores válidos para memory
:
128MB
— 200MHz256MB
— 400MHz512MB
— 800MHz1GB
— 1,4 GHz2GB
— 2,4 GHz4GB
— 4,8 GHz8GB
— 4,8 GHz
Para definir a alocação de memória e o tempo limite no Console do Google Cloud, siga as etapas a seguir:
- No Console do Google Cloud, selecione Cloud Functions no menu à esquerda.
- Clique no nome de uma função para selecioná-la em uma lista de funções.
- Clique no ícone Editar no menu na parte superior.
- Selecione uma alocação de memória no menu suspenso Memória alocada.
- Clique em Mais para exibir as opções avançadas e insira um número de segundos na caixa de texto Tempo limite.
- Clique em Salvar para atualizar a função.