Diese Seite wurde von der Cloud Translation API übersetzt.

Serverseitige Remote Config mit Cloud Functions und Vertex AI verwenden

In diesem Leitfaden wird beschrieben, wie Sie Cloud Functions der 2. Generation mit serverseitigem Remote Config verwenden, um serverseitige Aufrufe an die Vertex AI Gemini API auszuführen.

In dieser Anleitung fügen Sie Remote Config einer Chatbot-ähnlichen Funktion hinzu, nutzt das Gemini-Modell, um Fragen von Nutzern zu beantworten. Remote Config verwaltet Gemini API-Eingabewerte (einschließlich eines Prompts, den Sie an eingehende Nutzeranfragen anhängen). Sie können diese Eingabewerte bei Bedarf über die Firebase-Konsole aktualisieren. Außerdem verwenden Sie die Firebase Local Emulator Suite zum Testen und Fehler in der Funktion beheben. Nachdem Sie überprüft haben, ob sie funktioniert, stellen Sie Teste es auf Google Cloud.

Vorbereitung

In diesem Leitfaden wird vorausgesetzt, dass Sie mit JavaScript zur Entwicklung von Anwendungen.

Firebase-Projekt einrichten

Wenn Sie noch kein Firebase-Projekt haben:

Melden Sie sich in der Firebase-Konsole an.
Klicken Sie auf Projekt erstellen und verwenden Sie eine der folgenden Optionen:
- Option 1: Sie erstellen ein neues Firebase-Projekt und Google Cloud-Projekt automatisch erstellen, indem Sie einen neuen Projektnamen in im ersten Schritt des Projekts „Projekt erstellen“ zu optimieren.
- Option 2: Sie können einem vorhandenen Google Cloud-Projekt „Firebase hinzufügen“, indem Sie im ersten Schritt des Workflows „Projekt erstellen“ den Namen Ihres Google Cloud-Projekts aus dem Drop-down-Menü auswählen.
Wenn Sie dazu aufgefordert werden, müssen Sie Google Analytics nicht einrichten, um diese Lösung zu verwenden.
Folgen Sie weiterhin der Anleitung auf dem Bildschirm, um Ihr Projekt zu erstellen.

Wenn Sie bereits ein Firebase-Projekt haben:

Fahren Sie mit Entwicklungsumgebung konfigurieren fort.

Entwicklungsumgebung konfigurieren

Zum Schreiben von Funktionen benötigen Sie eine Node.js-Umgebung und die Firebase CLI, um Funktionen in der Cloud Functions-Laufzeit bereitzustellen.

Installieren Sie Node.js und npm.

Zur Installation von Node.js und npm empfehlen wir die Verwendung von Knotenversionsmanager.

Wichtig: Wir empfehlen die Verwendung von Node.js 20 oder höher. Unter Laufzeitoptionen festlegen finden Sie wichtige Informationen zum laufenden Support für Node.js-Versionen.
Installieren Sie die Firebase CLI mit Ihrer bevorzugten Methode. Wenn Sie die Befehlszeile beispielsweise mit npm installieren möchten, führen Sie diesen Befehl aus:
```
npm install -g firebase-tools@latest
```
Mit diesem Befehl wird der global verfügbare firebase-Befehl installiert. Wenn dieser Befehl fehlschlägt, müssen Sie möglicherweise die npm-Berechtigungen ändern.

Führen Sie denselben Befehl noch einmal aus, um auf die neueste Version von firebase-tools zu aktualisieren.
Installiere firebase-functions und firebase-admin und verwende --save, um zu sparen an Ihr package.json:
```
npm install firebase-functions@latest firebase-admin@latest --save
```

Sie können jetzt mit der Implementierung dieser Lösung fortfahren.

Implementierung

Folgen Sie dieser Anleitung, um Ihr Gerät der 2. Generation zu erstellen, zu testen und bereitzustellen. Cloud Functions mit Remote Config und Vertex AI:

Aktivieren Sie die empfohlenen APIs von Vertex AI in der Google Cloud Console.
Initialisieren Sie Ihr Projekt und installieren Sie Knotenabhängigkeiten.
Konfigurieren Sie IAM-Berechtigungen für Ihr Admin SDK-Dienstkonto und speichern Sie den Schlüssel.
Erstellen Sie die Funktion.
Erstellen Sie eine serverspezifische Remote Config-Vorlage.
Bringen Sie die Funktion in der Firebase Local Emulator Suite zum Laufen und testen Sie sie.
Stellen Sie die Funktion in Google Cloud bereit.

Schritt 1: Empfohlene Vertex AI APIs in der Google Cloud Console aktivieren

Öffnen Sie die Google Cloud Console und wählen Sie auf Aufforderung Ihr Projekt aus.
Geben Sie oben in der Console im Feld Suchen den Wert Vertex AI ein und warten Sie, bis Vertex AI als Ergebnis angezeigt wird.
Wählen Sie Vertex AI aus. Das Vertex AI-Dashboard wird angezeigt.
Klicken Sie auf Alle empfohlenen APIs aktivieren.

Es kann einige Minuten dauern, bis die API aktiviert ist. Seite beibehalten aktiv und offen, bis die Aktivierung abgeschlossen ist.
Ist die Abrechnung nicht aktiviert, werden Sie aufgefordert, eine Cloud Billing-Konto. Nachdem Sie ein Abrechnungskonto aktiviert haben, kehren Sie zum Dashboard Vertex AI zurück und prüfen Sie, ob alle empfohlenen APIs aktiviert sind.

Schritt 2: Projekt initialisieren und Knotenabhängigkeiten installieren

Öffnen Sie ein Terminal auf Ihrem Computer und wechseln Sie zu dem Verzeichnis, in dem Sie die Funktion erstellen möchten.
Melden Sie sich in Firebase an:
```
firebase login
```
Führen Sie den folgenden Befehl aus, um Cloud Functions for Firebase zu initialisieren:
```
firebase init functions
```
Wählen Sie Vorhandenes Projekt verwenden aus und geben Sie Ihre Projekt-ID an.
Wählen Sie Javascript aus und drücken Sie die Eingabetaste.
Wählen Sie für alle anderen Optionen die Standardeinstellungen aus.

Im aktuellen Verzeichnis wird ein functions-Verzeichnis erstellt. Im Inneren eine index.js-Datei finden, mit der Sie Ihre Funktion erstellen, ein node_modules-Verzeichnis, das die Abhängigkeiten für Ihre Funktion enthält, und einer package.json-Datei, die die Paketabhängigkeiten enthält.
Fügen Sie die Admin SDK- und Vertex AI-Pakete hinzu, indem Sie die folgenden Befehle ausführen. Verwenden Sie --save, damit sie in der Datei package.json gespeichert werden:
```
cd functions
npm install firebase-admin@latest @google-cloud/vertexai --save
```

Die Datei functions/package.json sollte jetzt so aussehen, mit dem die neuesten angegebenen Versionen:

  {
    "name": "functions",
    "description": "Cloud Functions for Firebase",
    "scripts": {
      "serve": "firebase emulators:start --only functions",
      "shell": "firebase functions:shell",
      "start": "npm run shell",
      "deploy": "firebase deploy --only functions",
      "logs": "firebase functions:log"
    },
    "engines": {
      "node": "20"
    },
    "main": "index.js",
    "dependencies": {
      "@google-cloud/vertexai": "^1.1.0",
      "firebase-admin": "^12.1.0",
      "firebase-functions": "^5.0.0"
    },
    "devDependencies": {
      "firebase-functions-test": "^3.1.0"
    },
    "private": true
  }

Wenn Sie ESLint verwenden, wird eine Strophe mit diesem Element angezeigt. In Stellen Sie außerdem sicher, dass die Version der Knoten-Engine mit der installierten Version übereinstimmt. von Node.js und der Version, die Sie letztendlich auf Google Cloud ausführen. Wenn die engines-Strophe in Ihrer package.json beispielsweise für Node-Version 18 konfiguriert ist und Sie Node.js 20 verwenden, aktualisieren Sie die Datei so, dass 20 verwendet wird:

  "engines": {
    "node": "20"
  },

Schritt 3: IAM-Berechtigungen für das Admin SDK-Dienstkonto konfigurieren und Schlüssel speichern

In dieser Lösung verwenden Sie das Firebase-Dienstkonto Admin SDK, um Ihre Funktion auszuführen.

Öffnen Sie in der Google Cloud-Konsole das IAM und Seite „Verwaltung“ und suchen Sie das Dienstkonto Admin SDK (mit dem Namen firebase-adminsdk).
Wählen Sie das Konto aus und klicken Sie auf Hauptkonto bearbeiten. Die Seite „Zugriff bearbeiten“ wird angezeigt.
Klicken Sie auf Weitere Rolle hinzufügen und wählen Sie Remote Config Betrachter aus.
Klicken Sie auf Weitere Rolle hinzufügen und wählen Sie AI Platform-Entwickler aus.
Klicken Sie auf Weitere Rolle hinzufügen und wählen Sie Vertex AI Nutzer aus.
Klicken Sie auf Weitere Rolle hinzufügen und wählen Sie Cloud Run Invoker aus.
Klicken Sie auf Speichern.

Exportieren Sie als Nächstes die Anmeldedaten für das Admin SDK-Dienstkonto und speichern Sie sie in der Umgebungsvariablen GOOGLE_APPLICATION_CREDENTIALS.

Öffnen Sie in der Google Cloud Console die Seite Anmeldedaten.
Klicken Sie auf das Dienstkonto Admin SDK, um die Seite Details zu öffnen.
Klicken Sie auf Schlüssel.
Klicken Sie auf Schlüssel hinzufügen > Neuen Schlüssel erstellen.
Achten Sie darauf, dass JSON als Schlüsseltyp ausgewählt ist, und klicken Sie dann auf Erstellen.
Laden Sie den Schlüssel an einen sicheren Ort auf Ihrem Computer herunter.

Exportieren Sie den Schlüssel über das Terminal als Umgebungsvariable:

export GOOGLE_APPLICATION_CREDENTIALS="/path/to/your/service-account-key.json"

Schritt 4: Funktion erstellen

In diesem Schritt erstellen Sie eine Funktion, die Nutzereingaben verarbeitet und KI-gestützte Antworten generiert. Sie kombinieren mehrere Code-Snippets, um ein umfassende Funktion zum Initialisieren von Admin SDK und Vertex AI Gemini API, konfiguriert Standardparameter mithilfe von Remote Config, ruft die letzten Remote Config-Parameter ab, Prozesse Nutzereingabe und sendet eine Antwort an den Nutzer zurück.

Öffnen Sie functions/index.js in Ihrer Codebasis in einem Texteditor oder einer IDE.

Löschen Sie den vorhandenen Inhalt und fügen Sie dann Admin SDK hinzu. Remote Config und das Vertex AI SDK an und initialisieren Sie die App, indem Sie und fügen Sie folgenden Code in die Datei ein:

const { onRequest } = require("firebase-functions/v2/https");
const logger = require("firebase-functions/logger");

const { initializeApp } = require("firebase-admin/app");
const { VertexAI } = require('@google-cloud/vertexai');
const { getRemoteConfig } = require("firebase-admin/remote-config");

// Set and check environment variables.
const project = process.env.GCLOUD_PROJECT;

// Initialize Firebase.
const app = initializeApp();index.js

Konfigurieren Sie Standardwerte, die von Ihrer Funktion verwendet werden, wenn keine Verbindung zum Remote Config-Server hergestellt werden kann. Bei dieser Lösung werden textModel, generationConfig, safetySettings, textPrompt und location als Remote Config-Parameter konfiguriert, die den Remote Config-Parametern entsprechen, die Sie weiter unten in diesem Leitfaden konfigurieren. Weitere Informationen Informationen zu diesen Parametern finden Sie unter Vertex AI Node.js-Client.

Optional können Sie auch einen Parameter konfigurieren, um zu steuern, auf den Vertex AI Gemini API zugreifen (in diesem Beispiel ein Parameter namens vertex_enabled). Diese Konfiguration kann beim Testen der Funktion nützlich sein. In folgenden Code-Snippets zurückgegeben, ist dieser Wert auf false gesetzt, wodurch mit Vertex AI, während Sie die grundlegende Funktionsbereitstellung testen. Einstellen auf true ruft den Vertex AI Gemini API auf.
```
// Define default (fallback) parameter values for Remote Config.
const defaultConfig = {

  // Default values for Vertex AI.
  model_name: "gemini-1.5-flash-preview-0514",
  generation_config: [{
    "stopSequences": [], "temperature": 0.7,
    "maxOutputTokens": 64, "topP": 0.1, "topK": 20
  }],
  prompt: "I'm a developer who wants to learn about Firebase and you are a \
    helpful assistant who knows everything there is to know about Firebase!",
  safety_settings: [{
    "category":
      "HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT",
    "threshold": "HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE"
  }],
  location: 'us-central1',

  // Disable Vertex AI Gemini API access for testing.
  vertex_enabled: false
};index.js
```

Funktion erstellen und einrichten serverseitige Remote Config:

// Export the function.
exports.generateWithVertex = onRequest(async (request, response) => {

  try {

    // Set up Remote Config.
    const rc = getRemoteConfig(app);

    // Get the Remote Config template and assign default values.
    const template = await rc.getServerTemplate({
      defaultConfig: defaultConfig
    });

    // Add the template evaluation to a constant.
    const config = template.evaluate();

    // Obtain values from Remote Config.
    const textModel = config.getString("model_name") ||
        defaultConfig.model_name;
    const textPrompt = config.getString("prompt") || defaultConfig.prompt;
    const generationConfig = config.getString("generation_config") ||
        defaultConfig.generation_config;
    const safetySettings = config.getString("safety_settings") ||
        defaultConfig.safety_settings;
    const location = config.getString("location") ||
        defaultConfig.location;
    const vertexEnabled = config.getBoolean("is_vertex_enabled") ||
        defaultConfig.vertex_enabled;index.js

Richten Sie Vertex AI ein und fügen Sie die Chat- und Antwortlogik hinzu:

  // Allow user input.
  const userInput = request.query.prompt || '';

  // Instantiate Vertex AI.
    const vertex_ai = new VertexAI({ project: project, location: location });
    const generativeModel = vertex_ai.getGenerativeModel({
      model: textModel,
      safety_settings: safetySettings,
      generation_config: generationConfig,
    });

    // Combine prompt from Remote Config with optional user input.
    const chatInput = textPrompt + " " + userInput;

    if (!chatInput) {
      return res.status(400).send('Missing text prompt');
    }
    // If vertexEnabled isn't true, do not send queries to Vertex AI.
    if (vertexEnabled !== true) {
      response.status(200).send({
        message: "Vertex AI call skipped. Vertex is not enabled."
      });
      return;
    }

    logger.log("\nRunning with model ", textModel, ", prompt: ", textPrompt,
      ", generationConfig: ", generationConfig, ", safetySettings: ",
      safetySettings, " in ", location, "\n");

    const result = await generativeModel.generateContentStream(chatInput); 
    response.writeHead(200, { 'Content-Type': 'text/plain' });

    for await (const item of result.stream) {
      const chunk = item.candidates[0].content.parts[0].text;
      logger.log("Received chunk:", chunk);
      response.write(chunk);
    }

    response.end();

  } catch (error) {
    logger.error(error);
    response.status(500).send('Internal server error');
  }
});index.js

Speichern und schließen Sie die Datei.

Schritt 5: Serverspezifische Remote Config-Vorlage erstellen

Erstellen Sie als Nächstes eine serverseitige Remote Config-Vorlage und konfigurieren Sie die Parameter und Werte, die in Ihrer Funktion verwendet werden sollen. Um ein serverspezifisches Vorlage „Remote Config“:

Öffnen Sie die Firebase-Console und maximieren Sie im Navigationsmenü Ausführen. Wählen Sie dann Remote Config aus.
Wählen Sie Server aus der Auswahl Client/Server oben auf der Remote Config Seite.
- Wenn Sie Remote Config oder Servervorlagen zum ersten Mal verwenden, Klicken Sie auf Konfiguration erstellen. Das Feld Erstes serverseitiges Parameter angezeigt.
- Wenn Sie Remote Config-Servervorlagen bereits verwendet haben, klicken Sie auf Parameter hinzufügen.

Definieren Sie die folgenden Remote Config-Parameter:

Parametername	Beschreibung	Typ	Standardwert
`model_name`	Modellname Aktuelle Listen der Modellnamen, die Sie in Ihrem Code verwenden können, finden Sie unter Modell Versionen und Lebenszyklen oder Verfügbar Modellnamen.	String	`gemini-1.5-pro-preview-0514`
`prompt`	Prompt, der der Suchanfrage des Nutzers vorangestellt werden soll.	String	`I'm a developer who wants to learn about Firebase and you are a helpful assistant who knows everything there is to know about Firebase!`
`generation_config`	Parameter an das Modell zu senden.	JSON	`[{"stopSequences": ["I hope this helps"],"temperature": 0.7,"maxOutputTokens": 512, "topP": 0.1,"topK": 20}]`
`safety_settings`	Sicherheitseinstellungen für Vertex AI	JSON	`[{"category": "HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "HarmBlockThreshold.BLOCK_LOW_AND_ABOVE"}]`
`location`	Speicherort, an dem der Vertex AI-Dienst und das Vertex AI-Modell ausgeführt werden sollen	String	`us-central1`
`is_vertex_enabled`	Optionaler Parameter, der steuert, ob Abfragen an folgende Adresse gesendet werden: Vertex AI	Boolesch	`true`

Wenn Sie alle gewünschten Parameter hinzugefügt haben, und überprüfen Sie, ob die Datentypen korrekt sind. Klicken Sie dann auf Änderungen veröffentlichen.

Schritt 6: Funktion bereitstellen und in Firebase Local Emulator Suite testen

Jetzt können Sie Ihre Funktion lokal bereitstellen und testen. Firebase Local Emulator Suite

Achten Sie darauf, dass Sie GOOGLE_APPLICATION_CREDENTIALS als Umgebungsvariable festgelegt haben, wie in Schritt 3: IAM-Berechtigungen für Ihr Admin SDK-Dienstkonto konfigurieren und Schlüssel speichern beschrieben. Wählen Sie dann im des Verzeichnisses functions haben, stellen Sie die Funktion im Firebase-Emulator:
```
firebase emulators:start --project PROJECT_ID --only functions
```
Tipp: Sie können Funktionen auch im Emulator ausführen, indem Sie npm run serve ausführen. aus dem Verzeichnis functions.
Öffnen Sie die Seite mit den Protokollen des Emulators. Dies sollte anzeigen, dass Ihre Funktion geladen wurde.
Führen Sie den folgenden Befehl aus, um auf Ihre Funktion zuzugreifen. Dabei ist PROJECT_ID Ihre Projekt-ID und LOCATION die Region, in der Sie die Funktion bereitgestellt haben (z. B. us-central1):
```
curl http://localhost:5001/PROJECT_ID/LOCATION/generateWithVertex
```
Tipp :Dieser Link wird auch in der Konsolenausgabe angezeigt, nachdem Sie Emulator. Sie können den Link auch ausschneiden und in einen Browser einfügen.
Warten Sie auf eine Antwort und kehren Sie dann zur Seite mit den Firebase Emulator-Protokollen oder zur Konsole zurück. Prüfen Sie, ob Fehler oder Warnungen vorliegen.
Sende einige Nutzereingaben. Beachte dabei, dass is_vertex_enabled in deiner Remote Config-Servervorlage konfiguriert ist und daher über Vertex AI Gemini API auf Gemini zugreifen sollte. Dies kann zu Gebühren führen:
```
curl http://localhost:5001/PROJECT_ID/LOCATION/generateWithVertex?prompt=Tell%20me%20everything%20you%20know%20about%20cats
```
Nehmen Sie Änderungen an Ihrer Remote Config-Servervorlage für den Firebase-Konsole und greifen Sie dann noch einmal auf die Funktion zu, um Änderungen zu beobachten.

Schritt 7: Funktion in Google Cloud bereitstellen

Nachdem Sie die Funktion getestet und verifiziert haben, können Sie sie auf Google Cloud bereitstellen und die Livefunktion testen.

Funktion bereitstellen

Stellen Sie die Funktion mit der Firebase-Befehlszeile bereit:

firebase deploy --only functions

Nicht authentifizierten Zugriff auf die Funktion blockieren

Wenn Funktionen mit Firebase bereitgestellt werden, sind nicht authentifizierte Aufrufe standardmäßig zugelassen, wenn die Richtlinie Ihrer Organisation sie nicht einschränkt. Während der Tests und vor dem Sichern mit App Check empfehlen, den nicht authentifizierten Zugriff zu blockieren.

So blockieren Sie den nicht authentifizierten Zugriff auf die Funktion:

Öffnen Sie in der Google Cloud-Konsole Cloud Run:
Klicken Sie auf generateWithVertex und dann auf den Tab Sicherheit.
Aktivieren Sie Authentifizierung erforderlich und klicken Sie dann auf Speichern.

Nutzerkonto für die Verwendung der Anmeldedaten des Admin SDK-Dienstkontos konfigurieren

Da das Dienstkonto Admin SDK alle erforderlichen Rollen und zum Ausführen der Funktion und zum Interagieren mit Remote Config und Vertex AI Gemini API, können Sie damit Ihre Funktion ausführen. Dazu müssen Sie in der Lage sein, über Ihr Nutzerkonto Tokens für das Konto zu erstellen.

In den folgenden Schritten wird beschrieben, wie Sie Ihr Nutzerkonto und die Funktion konfigurieren. So wird sie mit den Dienstkontoberechtigungen Admin SDK ausgeführt.

Aktivieren Sie in der Google Cloud Console die IAM Service Account Credentials API.
Weisen Sie Ihrem Nutzerkonto die Rolle Ersteller von Dienstkonto-Tokens zu: Öffnen Sie in der Google Cloud-Konsole IAM und Verwaltung > IAM, wählen Sie Ihr Nutzerkonto aus und klicken Sie dann auf Hauptkonto bearbeiten > Weitere Rolle hinzufügen.
Wählen Sie Ersteller von Dienstkonto-Tokens aus und klicken Sie auf Speichern.

Weitere Informationen zur Identitätsübernahme von Dienstkonten finden Sie in der Google Cloud-Dokumentation unter Identitätsübernahme des Dienstkontos.
Öffnen Sie die Seite „Cloud Functions“ der Google Cloud-Konsole. Klicken Sie in der Liste Functions auf die Funktion generateWithVertex.
Wählen Sie Trigger > Bearbeiten aus und maximieren Sie Laufzeit, Build, Verbindungen und Sicherheitseinstellungen.
Ändern Sie auf dem Tab Laufzeit das Laufzeitdienstkonto in das Admin SDK-Konto.
Klicken Sie auf Weiter und dann auf Bereitstellen.

Die gcloud CLI einrichten

Um Ihre Funktion sicher über die Befehlszeile auszuführen und zu testen, müssen Sie beim Dienst Cloud Functions authentifizieren und eine gültige Authentifizierungstoken.

Installieren und konfigurieren Sie die gcloud CLI, um die Tokengenerierung zu aktivieren:

Falls die gcloud CLI noch nicht auf Ihrem Computer installiert ist, installieren Sie sie wie unter gcloud CLI installieren beschrieben.
Rufen Sie die Anmeldedaten für Ihr Google Cloud-Konto ab:
```
gcloud auth login
```
Legen Sie Ihre Projekt-ID in gcloud fest:
```
gcloud config set project PROJECT_ID
```

Funktion testen

Sie können die Funktion jetzt in Google Cloud testen. Um die Funktion zu testen, führen Sie den folgenden Befehl aus:

curl -X POST https://LOCATION-PROJECT_ID.cloudfunctions.net/generateWithVertex \
  -H "Authorization: bearer $(gcloud auth print-identity-token)" \
  -H "Content-Type: application/json"

Versuchen Sie es noch einmal mit von Nutzern bereitgestellten Daten:

curl -X POST https://LOCATION-PROJECT_ID.cloudfunctions.net/generateWithVertex?prompt=Tell%20me%20everything%20you%20know%20about%20dogs \
 -H "Authorization: bearer $(gcloud auth print-identity-token)" \
 -H "Content-Type: application/json"

Sie können jetzt Änderungen an Ihrer Remote Config-Servervorlage vornehmen, diese veröffentlichen und verschiedene Optionen testen.

Nächste Schritte

Firebase empfiehlt, Cloud Functions mit App Check zu schützen. Siehe App Check-Erzwingung aktivieren für Cloud Functions finden Sie weitere Informationen zum Sichern Ihrer Funktion mit App Check
Beispiel für eine aufrufbare Funktion mit dem serverseitigen Remote Config und App Check mit Vertex AI Gemini API mit Remote Config anrufen und App Check.
Weitere Informationen zu Cloud Functions für Firebase
Weitere Informationen zur Verwendung von Remote Config auf dem Server Umgebungen.