Mehrere Funktionen organisieren

Wenn Sie Cloud Functions in Ihr Projekt einbinden, kann Ihr Code auf viele unabhängige Funktionen enthalten. 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, um die Navigation und Verwaltung Ihrer Funktionen zu erleichtern.

Funktionen in Codebasen organisieren

Sie können das Attribut codebase des Funktionskonfigurationsobjekts in firebase.json zum Verwalten einer großen Funktionssammlung über mehrere Repositories oder Unterpakete innerhalb einer einzelnen Repository-Monorepo-Einrichtung:

# 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 Firebase CLI v10.7.1 und höher unterstützt.

Mehrere Repositories verwalten

Mit der Property codebase lässt sich die Verwaltung mehrerer Repositories vereinfachen. Schauen wir uns einen Fall an, in dem Sie zwei verschiedene Repositories 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-Annotationen hätte Sie die Firebase CLI aufgefordert, Löschen von Funktionen, die bei der Bereitstellung im anderen Repository definiert wurden:

$ (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 eine eindeutige Codebasis-Annotation im Abschnitt „Funktionskonfiguration“ von firebase.json in jedem Projekt-Repository:

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

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

Mit der Codebasis-Annotation werden Sie von Firebase CLI nicht mehr zum Löschen aufgefordert. Funktionen, 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 (Monorrepo)

Mit dem Attribut codebase lässt sich die Verwaltung mehrerer Quellen vereinfachen. in einem Repository gespeichert. Nehmen wir als Beispiel einen Fall, bei dem Sie 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 folgende Anwendungsfälle:

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

Definieren Sie mehrere Funktionskonfigurationen, um eine solche Monrepo-Einrichtung zu unterstützen 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 bereit mit einem einzigen Bereitstellungsbefehl:

$ 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 mehrere Dateien schreiben

Zu Beginn der Nutzung von Cloud Functions können Sie Funktionen in einer einzigen Datei:

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 mit mehr als nur wenigen Funktionen schwierig sein. Stattdessen können Sie die gesamte Logik für jede Funktion in eine eigene Datei einfügen und die Quelldatei als Liste der Exporte 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 gemeinsam bereitgestellt und gepflegt werden. Vielleicht haben Sie eine Gruppe von Funktionen für Berichtsmesswerte:

metrics.js

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

Wenn Sie diese Funktionen in index.js exportieren, können Sie sie in einer Gruppe zusammenfassen. Datei:

index.js:

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

Nach der Bereitstellung wird Funktionen der Name ihrer Gruppe vorangestellt, sodass In diesem Beispiel würden die Funktionen metrics-usageStats heißen. und metrics-nightlyReport.

Wenn Sie Funktionen bereitstellen, 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.
• Funktionen für Bereitstellung und Laufzeitoptionen verwalten