Как структурировать облачные функции для Firebase для развертывания нескольких функций из нескольких файлов?
Я хотел бы создать несколько облачных функций для Firebase и развернуть их одновременно из одного проекта. Я также хотел бы разделить каждую функцию в отдельный файл. В настоящее время я могу создать несколько функций, если я помещу их обе в index.js, например:
exports.foo = functions.database.ref('/foo').onWrite(event => {
...
});
exports.bar = functions.database.ref('/bar').onWrite(event => {
...
});
Однако я хотел бы поместить foo и bar в отдельные файлы. Я попробовал это:
/functions
|--index.js (blank)
|--foo.js
|--bar.js
|--package.json
где foo.js
exports.foo = functions.database.ref('/foo').onWrite(event => {
...
});
и bar.js это
exports.bar = functions.database.ref('/bar').onWrite(event => {
...
});
Есть ли способ сделать это, не помещая все функции в index.js?
19 ответов
Ах, Cloud Functions для Firebase загружают модули узлов нормально, так что это работает
состав:
/functions
|--index.js
|--foo.js
|--bar.js
|--package.json
index.js:
const functions = require('firebase-functions');
const fooModule = require('./foo');
const barModule = require('./bar');
exports.foo = functions.database.ref('/foo').onWrite(fooModule.handler);
exports.bar = functions.database.ref('/bar').onWrite(barModule.handler);
foo.js:
exports.handler = (event) => {
...
};
bar.js:
exports.handler = (event) => {
...
};
Ответ @jasonsirota был очень полезным. Но может быть полезно увидеть более подробный код, особенно в случае запускаемых по HTTP функций.
Используя ту же структуру, что и в ответе @ jasonsirota, предположим, что вы хотите иметь две отдельные функции триггера HTTP в двух разных файлах:
структура каталогов:
/functions
|--index.js
|--foo.js
|--bar.js
|--package.json`
index.js:
'use strict';
const fooFunction = require('./foo');
const barFunction = require('./bar');
// Note do below initialization tasks in index.js and
// NOT in child functions:
const functions = require('firebase-functions');
const admin = require('firebase-admin');
admin.initializeApp(functions.config().firebase);
const database = admin.database();
// Pass database to child functions so they have access to it
exports.fooFunction = functions.https.onRequest((req, res) => {
fooFunction.handler(req, res, database);
});
exports.barFunction = functions.https.onRequest((req, res) => {
barFunction.handler(req, res, database);
});
foo.js:
exports.handler = function(req, res, database) {
// Use database to declare databaseRefs:
usersRef = database.ref('users');
...
res.send('foo ran successfully');
}
bar.js:
exports.handler = function(req, res, database) {
// Use database to declare databaseRefs:
usersRef = database.ref('users');
...
res.send('bar ran successfully');
}
Вот как я лично сделал это с машинописью:
/functions
|--src
|--index.ts
|--http-functions.ts
|--main.js
|--db.ts
|--package.json
|--tsconfig.json
Позвольте мне предварить это, дав два предупреждения, чтобы сделать эту работу:
- порядок импорта / экспорта имеет значение в index.ts
- БД должна быть отдельным файлом
Для пункта № 2 я не уверен, почему. Secundo, вы должны точно соблюдать мою конфигурацию index, main и db (по крайней мере, попробовать).
index.ts: занимается экспортом. Я считаю, что index.ts лучше разобраться с экспортом.
// main must be before functions
export * from './main';
export * from "./http-functions";
main.ts: имеет дело с инициализацией.
import { config } from 'firebase-functions';
import { initializeApp } from 'firebase-admin';
initializeApp(config().firebase);
export * from "firebase-functions";
db.ts: просто переэкспортируйте базу данных, чтобы ее имя короче database()
import { database } from "firebase-admin";
export const db = database();
HTTP-functions.ts
// de must be imported like this
import { db } from './db';
// you can now import everything from index.
import { https } from './index';
// or (both work)
// import { https } from 'firebase-functions';
export let newComment = https.onRequest(createComment);
export async function createComment(req: any, res: any){
db.ref('comments').push(req.body.comment);
res.send(req.body.comment);
}
С Node 8 LTS, который теперь доступен с Cloud/Firebase Functions, вы можете делать следующее с помощью операторов распространения:
/package.json
"engines": {
"node": "8"
},
/index.js
module.exports = {
...require("./lib/foo.js"),
// ...require("./lib/bar.js") // add as many as you like
};
/shared.js
const functions = require("firebase-functions");
const admin = require("firebase-admin");
admin.initializeApp();
if (process.env.GCLOUD_PROJECT == "production-app") {
// production stuff
} else {
// dev stuff
}
module.exports = { functions, admin };
/lib/foo.js
const { functions, admin } = require("../shared.js");
exports.fooHandler = functions.database
.ref("/food/{id}")
.onCreate((snap, context) => {
let id = context.params["id"];
return admin
.database()
.ref(`/bar/${id}`)
.set(true);
});
Чтобы быть простым (но делает работу), я лично структурировал свой код следующим образом.
раскладка
├── /src/
│ ├── index.ts
│ ├── foo.ts
│ ├── bar.ts
| ├── db.ts
└── package.json
foo.ts
import * as functions from 'firebase-functions';
export const fooFunction = functions.database()......... {
//do your function.
}
export const someOtherFunction = functions.database().......... {
// do the thing.
}
bar.ts
import * as functions from 'firebase-functions';
export const barFunction = functions.database()......... {
//do your function.
}
export const anotherFunction = functions.database().......... {
// do the thing.
}
db.ts
import * as admin from 'firebase-admin';
import * as functions from 'firebase-functions';
export const firestore = admin.firestore();
export const realtimeDb = admin.database();
index.ts
import * as admin from 'firebase-admin';
import * as functions from 'firebase-functions';
admin.initializeApp(functions.config().firebase);
// above codes only needed if you use firebase admin
export * from './foo';
export * from './bar';
Работает для каталогов любых вложенных уровней. Просто следуйте шаблону внутри каталогов тоже.
кредит @zaidfazil ответ
Схема bigcodenerd.org представляет собой более простой шаблон архитектуры, позволяющий разделять методы на разные файлы и экспортировать их в одну строку в файле ind ex.js.
Архитектура проекта в этом примере следующая:
projectDirectory
- ind ex.js
- podcast.js
- profile.js
ind ex.js
const admin = require('firebase-admin');
const podcast = require('./podcast');
const profile = require('./profile');
admin.initializeApp();
exports.getPodcast = podcast.getPodcast();
exports.removeProfile = user.removeProfile();
podcast.js
const functions = require('firebase-functions');
exports.getPodcast = () => functions.https.onCall(async (data, context) => {
...
return { ... }
});
Тот же шаблон будет использоваться для removeProfile метод в файле профиля.
В случае с Babel/ Flow это будет выглядеть так:
Макет каталога
.
├── /build/ # Compiled output for Node.js 6.x
├── /src/ # Application source files
│ ├── db.js # Cloud SQL client for Postgres
│ ├── index.js # Main export(s)
│ ├── someFuncA.js # Function A
│ ├── someFuncA.test.js # Function A unit tests
│ ├── someFuncB.js # Function B
│ ├── someFuncB.test.js # Function B unit tests
│ └── store.js # Firebase Firestore client
├── .babelrc # Babel configuration
├── firebase.json # Firebase configuration
└── package.json # List of project dependencies and NPM scripts
src/index.js - Основной экспорт (ы)
export * from './someFuncA.js';
export * from './someFuncB.js';
src/db.js - Облачный SQL-клиент для Postgres
import { Pool } from 'pg';
import { config } from 'firebase-functions';
export default new Pool({
max: 1,
user: '<username>',
database: '<database>',
password: config().db.password,
host: `/cloudsql/${process.env.GCP_PROJECT}:<region>:<instance>`,
});
src/store.js - Firebase Firestore Client
import firebase from 'firebase-admin';
import { config } from 'firebase-functions';
firebase.initializeApp(config().firebase);
export default firebase.firestore();
src/someFuncA.js - функция А
import { https } from 'firebase-functions';
import db from './db';
export const someFuncA = https.onRequest(async (req, res) => {
const { rows: regions } = await db.query(`
SELECT * FROM regions WHERE country_code = $1
`, ['US']);
res.send(regions);
});
src/someFuncB.js - функция B
import { https } from 'firebase-functions';
import store from './store';
export const someFuncB = https.onRequest(async (req, res) => {
const { docs: regions } = await store
.collection('regions')
.where('countryCode', '==', 'US')
.get();
res.send(regions);
});
.babelrc
{
"presets": [["env", { "targets": { "node": "6.11" } }]],
}
firebase.json
{
"functions": {
"source": ".",
"ignore": [
"**/node_modules/**"
]
}
}
package.json
{
"name": "functions",
"verson": "0.0.0",
"private": true,
"main": "build/index.js",
"dependencies": {
"firebase-admin": "^5.9.0",
"firebase-functions": "^0.8.1",
"pg": "^7.4.1"
},
"devDependencies": {
"babel-cli": "^6.26.0",
"babel-core": "^6.26.0",
"babel-jest": "^22.2.2",
"babel-preset-env": "^1.6.1",
"jest": "^22.2.2"
},
"scripts": {
"test": "jest --env=node",
"predeploy": "rm -rf ./build && babel --out-dir ./build src",
"deploy": "firebase deploy --only functions"
}
}
$ yarn install # Install project dependencies
$ yarn test # Run unit tests
$ yarn deploy # Deploy to Firebase
Чтобы быть простым (но делает работу), я лично структурировал свой код следующим образом.
раскладка
├── /src/
│ ├── index.ts
│ ├── foo.ts
│ ├── bar.ts
└── package.json
foo.ts
export const fooFunction = functions.database()......... {
//do your function.
}
export const someOtherFunction = functions.database().......... {
// do the thing.
}
bar.ts
export const barFunction = functions.database()......... {
//do your function.
}
export const anotherFunction = functions.database().......... {
// do the thing.
}
index.ts
import * as fooFunctions from './foo';
import * as barFunctions from './bar';
module.exports = {
...fooFunctions,
...barFunctions,
};
Работает для каталогов любых вложенных уровней. Просто следуйте шаблону внутри каталогов тоже.
В документацию Firebase добавлено хорошее руководство по организации многофайлового кода:
Документы> Облачные функции> Функции записи> Упорядочить функции
Обобщить:
foo.js
const functions = require('firebase-functions');
exports.foo = functions.https.onRequest((request, response) => {
// ...
});
bar.js
const functions = require('firebase-functions');
exports.bar = functions.https.onRequest((request, response) => {
// ...
});
index.js
const foo = require('./foo');
const bar = require('./bar');
exports.foo = foo.foo;
exports.bar = bar.bar;
Этот формат позволяет вашей точке входа находить дополнительные файлы функций и автоматически экспортировать каждую функцию в каждый файл.
Сценарий главной точки входа
Находит все файлы.js внутри папки функций и экспортирует каждую функцию, экспортированную из каждого файла.
const fs = require('fs');
const path = require('path');
// Folder where all your individual Cloud Functions files are located.
const FUNCTIONS_FOLDER = './scFunctions';
fs.readdirSync(path.resolve(__dirname, FUNCTIONS_FOLDER)).forEach(file => { // list files in the folder.
if(file.endsWith('.js')) {
const fileBaseName = file.slice(0, -3); // Remove the '.js' extension
const thisFunction = require(`${FUNCTIONS_FOLDER}/${fileBaseName}`);
for(var i in thisFunction) {
exports[i] = thisFunction[i];
}
}
});Пример экспорта нескольких функций из одного файла
const functions = require('firebase-functions');
const query = functions.https.onRequest((req, res) => {
let query = req.query.q;
res.send({
"You Searched For": query
});
});
const searchTest = functions.https.onRequest((req, res) => {
res.send({
"searchTest": "Hi There!"
});
});
module.exports = {
query,
searchTest
}http доступные конечные точки имеют соответствующие имена
✔ functions: query: http://localhost:5001/PROJECT-NAME/us-central1/query
✔ functions: helloWorlds: http://localhost:5001/PROJECT-NAME/us-central1/helloWorlds
✔ functions: searchTest: http://localhost:5001/PROJECT-NAME/us-central1/searchTestОдин файл
Если у вас есть только несколько дополнительных файлов (например, только один), вы можете использовать:
const your_functions = require('./path_to_your_functions');
for (var i in your_functions) {
exports[i] = your_functions[i];
}Так что у меня есть этот проект, который имеет фоновые функции и функции http. У меня также есть тесты для юнит-тестирования. CI/CD значительно облегчит вашу жизнь при развертывании облачных функций
Структура папок
|-- package.json
|-- cloudbuild.yaml
|-- functions
|-- index.js
|-- background
| |-- onCreate
| |-- index.js
|-- create.js
|
|-- http
| |-- stripe
| |-- index.js
| |-- payment.js
|-- utils
|-- firebaseHelpers.js
|-- test
|-- ...
|-- package.json
Замечания: utils/ папка для обмена кодом между функциями
Функции /index.js
Здесь вы можете просто импортировать все нужные вам функции и объявить их. Не нужно иметь логику здесь. Это делает его чище по моему мнению.
require('module-alias/register');
const functions = require('firebase-functions');
const onCreate = require('@background/onCreate');
const onDelete = require('@background/onDelete');
const onUpdate = require('@background/onUpdate');
const tours = require('@http/tours');
const stripe = require('@http/stripe');
const docPath = 'tours/{tourId}';
module.exports.onCreate = functions.firestore.document(docPath).onCreate(onCreate);
module.exports.onDelete = functions.firestore.document(docPath).onDelete(onDelete);
module.exports.onUpdate = functions.firestore.document(docPath).onUpdate(onUpdate);
module.exports.tours = functions.https.onRequest(tours);
module.exports.stripe = functions.https.onRequest(stripe);
CI / CD-
Как насчет непрерывной интеграции и развертывания каждый раз, когда вы вносите свои изменения в репозиторий? Вы можете получить его с помощью Google Google Cloud сборки. Это бесплатно до определенного момента:) Проверьте эту ссылку.
./cloudbuild.yaml
steps:
- name: "gcr.io/cloud-builders/npm"
args: ["run", "install:functions"]
- name: "gcr.io/cloud-builders/npm"
args: ["test"]
- name: "gcr.io/${PROJECT_ID}/firebase"
args:
[
"deploy",
"--only",
"functions",
"-P",
"${PROJECT_ID}",
"--token",
"${_FIREBASE_TOKEN}"
]
substitutions:
_FIREBASE_TOKEN: nothing
Существует довольно хороший способ организовать все ваши облачные функции на длительный срок. Я сделал это недавно, и это работает без нареканий.
Я организовал каждую облачную функцию в отдельных папках в зависимости от конечной точки запуска. Каждое имя облачной функции заканчивается на *.f.js, Например, если у вас было onCreate а также onUpdate срабатывает на user/{userId}/document/{documentId} затем создайте два файла onCreate.f.js а также onUpdate.f.js в каталоге functions/user/document/ и ваша функция будет названа userDocumentOnCreate а также userDocumentOnUpdate соответственно. (1)
Вот пример структуры каталога:
functions/
|----package.json
|----index.js
/----user/
|-------onCreate.f.js
|-------onWrite.f.js
/-------document/
|------------onCreate.f.js
|------------onUpdate.f.js
/----books/
|-------onCreate.f.js
|-------onUpdate.f.js
|-------onDelete.f.js
Функция образца
const functions = require('firebase-functions');
const admin = require('firebase-admin');
const db = admin.database();
const documentsOnCreate = functions.database
.ref('user/{userId}/document/{documentId}')
.onCreate((snap, context) => {
// your code goes here
});
exports = module.exports = documentsOnCreate;
index.js
const glob = require("glob");
const camelCase = require('camelcase');
const admin = require('firebase-admin');
const serviceAccount = require('./path/to/ServiceAccountKey.json');
try {
admin.initializeApp({ credential: admin.credential.cert(serviceAccount),
databaseURL: "Your database URL" });
} catch (e) {
console.log(e);
}
const files = glob.sync('./**/*.f.js', { cwd: __dirname });
for (let f = 0, fl = files.length; f < fl; f++) {
const file = files[f];
const functionName = camelCase(file.slice(0, -5).split('/'));
if (!process.env.FUNCTION_NAME || process.env.FUNCTION_NAME === functionName) {
exports[functionName] = require(file);
}
}
(1): Вы можете использовать любое имя, которое хотите. Для меня onCreate.f.js, onUpdate.f.js и т. Д. Кажутся более подходящими для того типа триггера, которым они являются.
Я также ищу лучшую структуру папок для Cloud Functions, поэтому решил поделиться тем, что придумал:
+ /src
| - index.ts
| + /events
| | - moduleA_events.ts
| | - moduleB_events.ts
| + /service
| | - moduleA_services.ts
| | - moduleB_services.ts
| + /model
| | - objectA.ts
| | - objectB.ts
| | - objectC.ts
/src/index.ts этот файл работает как точка входа для всех событий (функций), доступных в вашем приложении, таких как события базы данных, запросы https, запланированные функции. Однако функции объявлены не непосредственно в index.js, а в папке событий. Пример кода:
exports.user = require("./events/userEvents") exports.order
= require("./events/orderEvents") exports.product
= require("./events/productEvents")
Примечание: согласно официальной документации GCF , такой подход автоматически переименует все ваши функции в шаблон «модуль-функция». Пример: если у вас есть функция «userCreated» внутри userEvents.ts, firebase переименует эту функцию в «user-userCreated».
/src/events эта папка должна содержать только объявления облачных функций и не должна напрямую обрабатывать бизнес-логику. Для реального бизнеса вы должны вызывать пользовательские функции из вашей папки /service (которая отображает те же модули, что и в папке событий). Пример кода для userEvents.ts:
exports.userCreated = functions.firestore.document("/users/{documentId}").onCreate(async (моментальный снимок) => {userServices.sendWelcomeEmail() }
/src/service фактическая бизнес-логика, которая будет подключаться к другим службам firebase, таким как firestore, storage, auth. Вы также можете импортировать сюда свой слой /model (только машинописный текст).
/src/model — интерфейсы, используемые в typescript для обеспечения строго типизированных функций и объектов.
Как вы заметили, этот подход в основном основан на принципах MVC и ООП. Существует много хороших дебатов о том, должны ли мы вместо этого использовать функциональное программирование в бессерверной среде. Так как я работаю с бэкендом на Java и C#, представленная здесь структура папок кажется мне более естественной, однако мне было бы очень интересно узнать, насколько изменится эта структура папок при переходе к подходу функционального программирования.
Вот простой ответ, если вы создаете облачные функции с помощью машинописного текста.
/functions
|--index.ts
|--foo.ts
Рядом со всем вашим обычным импортом вверху просто экспортируйте все функции из foo.ts.
export * from './foo';
Для последних версий Fireabse V9 и Node 18 (мой стек Next.Js 13 + Fireabse sdk v9)
Приступая к работе с облачными функциями, вы можете поместить несколько первых функций в один файл:
index.js
const functions = require('firebase-functions');
exports.foo = functions.https.onRequest((request, response) => {
// ...
});
exports.bar = functions.https.onRequest((request, response) => {
// ...
});
С этим может оказаться сложно справиться, если использовать несколько функций. Вместо этого вы можете поместить всю логику для каждой функции в отдельный файл и использовать файл index.js в качестве простого списка экспорта:
foo.js
const functions = require('firebase-functions');
exports.fooFunc = functions.https.onRequest((request, response) => {
// ...
});
бар.js
const functions = require('firebase-functions');
exports.barFunc = functions.https.onRequest((request, response) => {
// ...
});
index.js
const foo = require('./foo');
const bar = require('./bar');
exports.foo = foo.fooFunc;
exports.bar = bar.barFunc;
Ссылка: Документы Firebase.
Не забудьте развернуть:
firebase deploy --only functions:fooFunc
Помните, что если вы будете следовать этой структуре, вы можете увидеть ошибку при многократном вызове метода InitializeApp(). Помните, что вам нужно просто включить инициализацию в индексный файл следующим образом:
const functions = require("firebase-functions");
const admin = require("firebase-admin");
admin.initializeApp();
Пытаясь реализовать решение @zaidfazil, я придумал следующее (используя JavaScript, а не TypeScript).
мульти.js
exports.onQuestionMultiCreate = functions.database
.ref("/questions-multi/{questionId}")
.onCreate(async (snapshot, context) => {
...
}
});
trueFalse.js
exports.onQuestionTrueFalseCreate = functions.database
.ref("/questions-truefalse/{questionId}")
.onCreate(async (snapshot, context) => {
...
}
});
index.js
const multi = require("./multi");
const trueFalse = require("./trueFalse");
module.exports = {
...multi,
...trueFalse
Я использую загрузчик vanilla JS для автоматического включения всех функций, которые я хочу использовать.
├── /functions
│ ├── /test/
│ │ ├── testA.js
│ │ └── testB.js
│ ├── index.js
│ └── package.json
index.js (загрузчик)
/**
* The bootloader reads all directories (single level, NOT recursively)
* to include all known functions.
*/
const functions = require('firebase-functions');
const fs = require('fs')
const path = require('path')
fs.readdirSync(process.cwd()).forEach(location => {
if (!location.startsWith('.')) {
location = path.resolve(location)
if (fs.statSync(location).isDirectory() && path.dirname(location).toLowerCase() !== 'node_modules') {
fs.readdirSync(location).forEach(filepath => {
filepath = path.join(location, filepath)
if (fs.statSync(filepath).isFile() && path.extname(filepath).toLowerCase() === '.js') {
Object.assign(exports, require(filepath))
}
})
}
}
})
В этом примере только файл index.js автоматически включает каталоги в корне. Это может быть расширено, чтобы идти каталогами, соблюдать.gitignore и т. Д. Это было достаточно для меня, хотя.
При наличии индексного файла добавление новых функций тривиально.
/test/testA.js
const functions = require('firebase-functions');
exports.helloWorld = functions.https.onRequest((request, response) => {
response.send("Hello from Firebase!");
});
/test/testB.js
const functions = require('firebase-functions');
exports.helloWorld2 = functions.https.onRequest((request, response) => {
response.send("Hello again, from Firebase!");
});
npm run serve выходы:
λ ~/Workspace/Ventures/Author.io/Firebase/functions/ npm run serve
> functions@ serve /Users/cbutler/Workspace/Ventures/Author.io/Firebase/functions
> firebase serve --only functions
=== Serving from '/Users/cbutler/Workspace/Ventures/Author.io/Firebase'...
i functions: Preparing to emulate functions.
Warning: You're using Node.js v9.3.0 but Google Cloud Functions only supports v6.11.5.
✔ functions: helloWorld: http://localhost:5000/authorio-ecorventures/us-central1/helloWorld
✔ functions: helloWorld2: http://localhost:5000/authorio-ecorventures/us-central1/helloWorld2
Этот рабочий процесс в значительной степени просто "напиши и запусти", без необходимости изменять файл index.js каждый раз, когда новая функция / файл добавляется / модифицируется / удаляется.
Приведенные выше ответы указали мне правильное направление, просто ни один из них не работал у меня. Ниже представлен рабочий прототип, пример onCall, onRequest и триггера базы данных.
foo.js - onCall
exports.handler = async function(data, context, admin) {
// const database = admin.database();
// const firestore = admin.firestore();
//...
};
bar.js - onRequest
exports.handler = async function(req, res, admin) {
// const database = admin.database();
// const firestore = admin.firestore();
//...
};
jar.js - триггер / документ / onCreate
exports.handler = async function(snapshot, context, admin) {
// const database = admin.database();
// const firestore = admin.firestore();
//...
};
index.js
// импортировать зависимости SDK администратора firebase
const functions = require('firebase-functions');
const admin = require('firebase-admin');
admin.initializeApp(functions.config().firebase);
// import functions
const foo = require("./foo");
const bar = require("./bar");
const jar = require("./jar");
// onCall for foo.js
exports.foo = functions.https.onCall((data, context) => {
return foo.handler(data, context, admin);
});
// onRequest for bar.js
exports.bar = functions.https.onRequest((req, res) => {
return bar.handler(req, res, admin);
});
// document trigger for jar.js
exports.jar = functions.firestore
.document("parentCollection/{parentCollectionId}")
.onCreate((snapshot, context) => {
return jar.handler(snapshot, context, admin);
});
ПРИМЕЧАНИЕ: Вы также можете создать подпапку для хранения ваших индивидуальных функций.
Я потратил много времени на поиски того же, и я считаю, что это лучший способ добиться этого (я использую firebase@7.3.0):
https://codeburst.io/organizing-your-firebase-cloud-functions-67dc17b3b0da
Без пота;)