Mehrere Funktionen organisieren

Wenn Sie Cloud Functions in Ihr Projekt einbinden, kann Ihr Code viele unabhängige Funktionen enthalten. Möglicherweise haben Sie zu viele Funktionen, um sie in einer einzigen Datei unterzubringen, oder verschiedene Teams stellen unterschiedliche Funktionsgruppen bereit. Dadurch besteht das Risiko, 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 Verwaltung Ihrer Funktionen zu vereinfachen.

Funktionen in Codebasen organisieren

Sie können das Attribut codebase des Funktionskonfigurationsobjekts in firebase.json verwenden, um eine große Sammlung von Funktionen über mehrere Repositories oder Unterpakete innerhalb eines einzelnen Repository-Monorepo-Setups zu 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

Das Attribut codebase kann die Verwaltung mehrerer Repositories vereinfachen. Sehen wir uns ein Beispiel an, bei dem Sie zwei verschiedene Repositories haben, die Funktionen im selben Firebase-Projekt bereitstellen:

$  tree .
├── repoA
│   ├── firebase.json
│   └── functions
│       ├── index.js
│       └── package.json
└── repoB
    ├── firebase.json
    └── functions
        ├── index.js
        └── package.json

Ohne Codebasis-Anmerkungen hätte die Firebase CLI Sie bei der Bereitstellung aufgefordert, die im anderen Repository definierten Funktionen zu löschen:

$ (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 im Abschnitt zur Funktionskonfiguration der firebase.json in jedem Projekt-Repository eine eindeutige Codebasis-Annotation hinzufügen:

# repoA/firebase.json
"functions": {
  "codebase": "repo-a"
}

# repoB/firebase.json
"functions": {
  "codebase": "repo-b"
}

Wenn Sie die Codebasis mit Annotationen versehen, werden Sie von der Firebase CLI nicht mehr aufgefordert, Funktionen zu löschen, die außerhalb Ihres unmittelbaren Repositorys 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)

Das Attribut codebase kann die Verwaltung mehrerer Quellpakete in einem einzelnen Repository vereinfachen. Sehen wir uns ein Beispiel an, bei dem Sie ein Firebase-Projektverzeichnis mit Funktionsdefinitionen haben, die auf mehrere Unterpakete verteilt sind:

$  tree .
├── firebase.json
├── teamA
│   ├── index.js
│   └── package.json
└── teamB
    ├── index.js
    └── package.json

Diese Einrichtung eignet sich für die folgenden Anwendungsfälle:

• Sie haben ein Monorepo-Setup und verschiedene Teams verwalten ihre eigenen Funktionsdefinitionen in einem isolierten Paket.
• Sie haben eine Funktion mit einer starken externen Abhängigkeit und einer langwierigen Initialisierung und möchten diese Funktion von anderen, latenzempfindlichen Funktionen isolieren.

Wenn Sie eine solche Monorepo-Einrichtung unterstützen möchten, definieren Sie mehrere Funktionskonfigurationen in firebase.json:

"functions": [
  {
    "source": "teamA",
    "codebase": "team-a"
  },
  {
    "source": "teamB",
    "codebase": "team-b"
  },
]

Mit dieser Konfiguration stellt die Firebase CLI Funktionen aus allen Paketen mit einem einzigen Bereitstellungsbefehl bereit:

$ 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 speichern:

const functions = require('firebase-functions/v1');
exports.foo = functions.https.onRequest((request, response) => {
  // ...
});
exports.bar = functions.https.onRequest((request, response) => {
  // ...
});

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!")

Dies kann bei mehr als ein paar Funktionen schwierig zu verwalten sein. Stattdessen können Sie die gesamte Logik für jede Funktion in einer eigenen Datei speichern und die Quelldatei als Liste von Exporten verwenden:

const functions = require('firebase-functions/v1');
exports.foo = functions.https.onRequest((request, response) => {
  // ...
});

const functions = require('firebase-functions/v1');
exports.bar = functions.https.onRequest((request, response) => {
  // ...
});

const foo = require('./foo');
const bar = require('./bar');
exports.foo = foo.foo;
exports.bar = bar.bar;

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!")

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!")

from fn_impl.foo import *
from fn_impl.bar import *

my-project
├── firebase.json
└── functions
    ├── fn_impl
    │   ├── __init__.py
    │   ├── foo.py
    │   └── bar.py
    ├── main.py
    └── requirements.txt

Gruppenfunktionen

In vielen Projekten können Funktionen in logische Gruppen unterteilt werden, die zusammen bereitgestellt und verwaltet werden sollten. Sie könnten beispielsweise eine Gruppe von Funktionen haben, 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 einer Gruppe zusammenfassen, wenn Sie sie in Ihrer index.js-Datei exportieren:

index.js

// Export both functions from metrics.js in the "metrics" group:
//  - metrics-usageStats
//  - metrics-nightlyReport
exports.metrics = require('./metrics');

Bei der Bereitstellung wird den Funktionen der Name ihrer Gruppe vorangestellt. 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 hier:

• Abhängigkeiten verarbeiten
• Bereitstellungs- und Laufzeitoptionen für Funktionen verwalten