Organizowanie wielu funkcji

Gdy zintegrujesz Cloud Functions ze swoim projektem, Twój kod może się rozwijać do zawierają wiele niezależnych funkcji. Możesz mieć zbyt wiele funkcji, aby zmieści się w jednym pliku; inne zespoły mogą też wdrażać różne grupy. funkcji, co stwarza ryzyko zastąpienia przez jeden zespół lub przypadkowego usunięcia tych funkcji. nad funkcjami innych zespołów. Cloud Functions oferuje różne sposoby porządkowania co ułatwia poruszanie się po funkcjach i ich obsługę.

Uporządkuj funkcje w bazach kodu

Możesz użyć właściwości codebase obiektu konfiguracji funkcji w: firebase.json do zarządzania dużym zbiorem funkcji w wielu repozytoriów lub podpakietów w ramach konfiguracji monorepozytorium w jednym repozytorium:

# 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.
}

Właściwość codebase jest obsługiwana w interfejsie wiersza poleceń Firebase w wersji 10.7.1 i nowszych.

Zarządzanie wieloma repozytoriami

Właściwość codebase ułatwia zarządzanie wieloma repozytoriów. Przeanalizujmy przypadek, w którym masz 2 różne repozytoria które wdrażają funkcje w tym samym projekcie Firebase:

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

Bez adnotacji bazy kodu interfejs wiersza poleceń Firebase poprosi Cię o wykonanie usuń funkcje zdefiniowane w innym repozytorium podczas wdrażania:

$ (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)

Aby uniknąć tego problemu, dodaj unikalną adnotację dotyczącą bazy kodu w sekcji sekcji konfiguracji funkcji interfejsu firebase.json w każdym repozytorium projektu:

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

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

Gdy dodasz adnotację w bazie kodu, interfejs wiersza poleceń Firebase nie będzie już prosić o usunięcie funkcje zdefiniowane poza bezpośrednim repozytorium:

$ (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!

Zarządzanie wieloma pakietami źródłowymi (monorepo)

Właściwość codebase może ułatwić zarządzanie wieloma źródłami w jednym repozytorium. Przeanalizujmy przypadek, w którym masz Firebase katalogu projektu z definicjami funkcji rozmieszczonymi w kilku podpakietach:

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

Ta konfiguracja pasuje do tych przypadków użycia:

• Masz konfigurację monorepo i różne zespoły zarządzają własnymi definicjami funkcji w osobnym pakiecie.
• Masz funkcję z silną zależnością zewnętrzną i długotrwałą inicjacją i chcesz odizolować ją od innych funkcji wrażliwych na opóźnienia.

Aby zapewnić obsługę konfiguracji Monrepo w taki sposób, zdefiniuj konfiguracje wielu funkcji w firebase.json:

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

Dzięki tej konfiguracji interfejs wiersza poleceń Firebase wdraża funkcje ze wszystkich pakietów w jednym poleceniu wdrożenia:

$ 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)...
...

Możesz też wdrożyć określoną bazę kodu:

$ 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)...
...

Zapisz funkcje w wielu plikach

Rozpoczynając pracę z Cloud Functions, możesz umieścić kilka funkcje w jednym pliku:

const functions = require('firebase-functions');
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!")

Zarządzanie wieloma funkcjami może być trudne. Zamiast tego: możesz umieścić całą logikę każdej funkcji w osobnym pliku i użyć funkcji pliku źródłowego jako listę eksportów:

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

const functions = require('firebase-functions');
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

Funkcje grupowania

W wielu projektach funkcje można podzielić na grupy logiczne, które powinny i wdrażać je razem. Możesz mieć na przykład grupę funkcje używane do raportowania danych:

dane metryczne.js

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

Te funkcje możesz umieścić w grupie podczas eksportowania ich w narzędziu index.js plik:

index.js

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

Po wdrożeniu funkcje będą poprzedzone nazwą grupy, więc W tym przykładzie funkcje miałyby nazwę metrics-usageStats i metrics-nightlyReport.

Podczas wdrażania funkcji możesz ograniczyć działanie do jednej grupy:

firebase deploy --only functions:metrics

Dalsze kroki

Więcej informacji o Cloud Functions:

• Obsługa zależności.
• Zarządzanie opcjami wdrażania funkcji i środowiska wykonawczego