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 sinnvoll in einer einzigen Datei unterzubringen. Oder verschiedene Teams stellen unterschiedliche Gruppen von Funktionen bereit, wodurch das Risiko besteht, 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 Property codebase des Konfigurationsobjekts für Funktionen in firebase.json können Sie eine große Sammlung von Funktionen in mehreren Repositories oder Unterpaketen innerhalb einer Monorepo-Einrichtung mit einem einzelnen Repository 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.
}

Die Property codebase wird in der Firebase CLI Version 10.7.1 und höher unterstützt.

Mehrere Repositories verwalten

Die Property codebase kann die Verwaltung mehrerer Repositories vereinfachen. Sehen wir uns einen Fall an, in 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 Codebase-Anmerkungen hätte die Firebase CLI Sie zum Zeitpunkt der Bereitstellung 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 im Konfigurationsbereich für Funktionen der Datei firebase.json in jedem Projekt-Repository eine eindeutige Codebase-Anmerkung hinzufügen:

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

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

Mit der Codebase-Anmerkung fordert die Firebase CLI Sie nicht mehr auf, Funktionen zu löschen, die außerhalb Ihres unmittelbaren Repository 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)

Die Property codebase kann die Verwaltung mehrerer Quellpakete in einem einzelnen Repository vereinfachen. Sehen wir uns einen Fall an, in 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 eine Monorepo-Einrichtung und verschiedene Teams verwalten ihre eigenen Funktionsdefinitionen in einem isolierten Paket.
• Sie haben eine Funktion mit einer umfangreichen externen Abhängigkeit und einer zeitaufwendigen Initialisierung und möchten diese Funktion von anderen latenzempfindlichen Funktionen isolieren.

Um eine solche Monorepo-Einrichtung zu unterstützen, 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 Codebase 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, legen Sie Ihre ersten Funktionen möglicherweise in einer einzigen Datei ab:

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 ablegen und Ihre 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

Funktionen gruppieren

In vielen Projekten können Funktionen in logische Gruppen unterteilt werden, die zusammen bereitgestellt und verwaltet werden sollten. Beispielsweise haben Sie möglicherweise eine Gruppe von Funktionen, die zum Melden von Messwerten 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 der 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 wird den Funktionen der Name ihrer Gruppe vorangestellt. In diesem Beispiel heißen die Funktionen also metrics-usageStats und metrics-nightlyReport.

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:

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