Wenn Sie Cloud Functions in Ihr Projekt einbinden, kann Ihr Code um viele unabhängige Funktionen erweitert werden. Möglicherweise haben Sie zu viele Funktionen, um sie in eine einzige Datei zu packen, oder verschiedene Teams stellen unterschiedliche Funktionsgruppen bereit, was das Risiko birgt, dass ein Team die Funktionen eines anderen Teams überschreibt oder versehentlich löscht. Cloud Functions bietet verschiedene Möglichkeiten, Ihren Code zu organisieren, um die Navigation und Wartung Ihrer Funktionen zu erleichtern.
Funktionen in Codebases organisieren
Mit der codebase-Eigenschaft des Konfigurationsobjekts „functions“ in firebase.json können Sie eine große Sammlung von Funktionen in mehreren Repositories oder Unterpaketen innerhalb einer einzelnen Monorepo-Repository-Einrichtung verwalten:
# firebase.json
"functions": {
"codebase": "my-codebase"
# NOTE: Codebase must be less than 63 characters and can contain only
# lowercase letters, numeric characters, underscores, and dashes.
}
Das Attribut codebase wird in der Firebase CLI ab Version 10.7.1 unterstützt.
Mehrere Repositories verwalten
Mit der Property codebase lässt sich die Verwaltung mehrerer Repositories vereinfachen. Angenommen, Sie haben zwei verschiedene Repositories, in denen Funktionen in dasselbe Firebase-Projekt bereitgestellt werden:
$ tree .
├── repoA
│ ├── firebase.json
│ └── functions
│ ├── index.js
│ └── package.json
└── repoB
├── firebase.json
└── functions
├── index.js
└── package.json
Ohne Anmerkungen zur Codebasis würden Sie von der Firebase CLI beim Bereitstellen aufgefordert, Funktionen zu löschen, die im anderen Repository definiert sind:
$ (cd repoA && firebase deploy --only functions)
...
i functions: preparing functions directory for uploading...
✔ functions: functions folder uploaded successfully
The following functions are found in your project but do not exist in your local source code:
fn1FromRepoB
fn2FromRepoB
...
? Would you like to proceed with deletion? Selecting no will continue the rest of the deployments. (y/N)
Sie können dieses Problem vermeiden, indem Sie in jedem Projekt-Repository im Abschnitt „functions configuration“ der firebase.json eine eindeutige Codebasis-Anmerkung hinzufügen:
# repoA/firebase.json
"functions": {
"codebase": "repo-a"
}
# repoB/firebase.json
"functions": {
"codebase": "repo-b"
}
Wenn Sie die Codebasis annotieren, werden Sie in der Firebase CLI nicht mehr aufgefordert, Funktionen zu löschen, die außerhalb Ihres unmittelbaren Repositories definiert sind:
$ (cd repoA && firebase deploy --only functions)
...
i functions: preparing functions directory for uploading...
✔ functions: functions folder uploaded successfully
# Gleefully ignores functions from repoB
i functions: creating Node.js 16 function fnFromRepoA (us-central1)...
✔ Deploy Complete!
Mehrere Quellpakete verwalten (Monorepo)
Mit dem Attribut codebase lässt sich die Verwaltung mehrerer Quellpakete in einem einzigen Repository vereinfachen. Angenommen, Sie haben ein FireBase-Projektverzeichnis mit Funktionsdefinitionen, die auf mehrere Unterpakete verteilt sind:
$ tree .
├── firebase.json
├── teamA
│ ├── index.js
│ └── package.json
└── teamB
├── index.js
└── package.json
Diese Konfiguration eignet sich für die folgenden Anwendungsfälle:
- Sie haben ein Monorepo eingerichtet und verschiedene Teams verwalten ihre eigenen Funktionsdefinitionen in einem separaten Paket.
- Sie haben eine Funktion mit einer hohen externen Abhängigkeit und einer langwierigen Initialisierung und möchten diese Funktion von anderen latenzempfindlichen Funktionen isolieren.
Um eine solche Monrepo-Einrichtung zu unterstützen, definieren Sie in firebase.json mehrere Funktionskonfigurationen:
"functions": [
{
"source": "teamA",
"codebase": "team-a"
},
{
"source": "teamB",
"codebase": "team-b"
},
]
Mit dieser Konfiguration werden mit der Firebase CLI Funktionen aus allen Paketen mit einem einzigen Bereitstellungsbefehl bereitgestellt:
$ firebase deploy --only functions
i deploying functions
i functions: preparing codebase team-a for deployment
i functions: preparing codebase team-b for deployment
i functions: creating Node.js 16 function team-a:helloATeam(us-central1)...
i functions: creating Node.js 16 function team-b:helloBTeam(us-central1)...
...
Sie können auch eine bestimmte Codebasis bereitstellen:
$ firebase deploy --only functions:team-b
i deploying functions
i functions: preparing codebase team-b for deployment
i functions: updating Node.js 16 function team-b:helloBTeam(us-central1)...
...
Funktionen in mehreren Dateien schreiben
Wenn Sie mit Cloud Functions beginnen, können Sie Ihre ersten Funktionen in einer einzigen Datei platzieren:
index.js
const functions = require('firebase-functions/v1');
exports.foo = functions.https.onRequest((request, response) => {
// ...
});
exports.bar = functions.https.onRequest((request, response) => {
// ...
});
main.py
from firebase_functions import https_fn
@https_fn.on_request()
def foo(req: https_fn.Request) -> https_fn.Response:
return https_fn.Response("Hello foo!")
@https_fn.on_request()
def bar(req: https_fn.Request) -> https_fn.Response:
return https_fn.Response("Hello bar!")
Bei mehreren Funktionen kann das schwierig werden. Stattdessen können Sie die gesamte Logik für jede Funktion in einer eigenen Datei platzieren und die Quelldatei als Liste der Exporte verwenden:
Node.js
foo.js
const functions = require('firebase-functions/v1'); exports.foo = functions.https.onRequest((request, response) => { // ... });
bar.js
const functions = require('firebase-functions/v1'); 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;
Python
foo.py
from firebase_functions import https_fn
@https_fn.on_request()
def foo(req: https_fn.Request) -> https_fn.Response:
return https_fn.Response("Hello foo!")
bar.py
from firebase_functions import https_fn
@https_fn.on_request()
def bar(req: https_fn.Request) -> https_fn.Response:
return https_fn.Response("Hello foo!")
main.py
from fn_impl.foo import *
from fn_impl.bar import *
Bei dieser Einrichtung wird eine Projektverzeichnisstruktur wie die folgende vorausgesetzt:
my-project
├── firebase.json
└── functions
├── fn_impl
│ ├── __init__.py
│ ├── foo.py
│ └── bar.py
├── main.py
└── requirements.txt
fn_impl: Kann beliebigen Namen haben
__init__.py: Erforderlich, kann aber leer sein
Gruppenfunktionen
In vielen Projekten können Funktionen in logische Gruppen unterteilt werden, die gemeinsam bereitgestellt und verwaltet werden sollten. Angenommen, Sie haben eine Gruppe von Funktionen, die für Berichtsmesswerte verwendet werden:
metrics.js
const functions = require('firebase-functions/v1'); exports.usageStats = functions.https.onRequest((request, response) => { // ... }); exports.nightlyReport = functions.https.onRequest((request, response) => { // ... });
Sie können diese Funktionen in eine Gruppe einfügen, wenn Sie sie in die Datei index.js exportieren:
index.js
// Export both functions from metrics.js in the "metrics" group: // - metrics-usageStats // - metrics-nightlyReport exports.metrics = require('./metrics');
Bei der Bereitstellung erhalten Funktionen das Präfix der Gruppe. In diesem Beispiel würden die Funktionen also metrics-usageStats und metrics-nightlyReport heißen.
Beim Bereitstellen von Funktionen können Sie die Aktion auf eine einzelne Gruppe beschränken:
firebase deploy --only functions:metrics
Nächste Schritte
Weitere Informationen zu Cloud Functions finden Sie unter: