Mehrere Projekte konfigurieren

Auf dieser Seite wird beschrieben, wie Sie mehrere Firebase-Projekte in Ihrer App verwenden.

Für viele Apps ist nur ein einziges Firebase-Projekt und die Standardeinrichtung erforderlich, die in den Einstiegsleitfäden beschrieben wird. In folgenden Fällen kann es nützlich sein, mehrere Firebase-Projekte zu verwenden:

• Sie können Ihre Entwicklungsumgebung so einrichten, dass je nach Buildtyp oder Ziel verschiedene Firebase-Projekte verwendet werden.
• Sie können in Ihrer App auf Inhalte aus mehreren Firebase-Projekten zugreifen.

Unterstützung verschiedener Umgebungen

Ein gängiger Anwendungsfall ist die Unterstützung separater Firebase-Projekte für Entwicklungs- und Produktionsumgebungen.

Die Web- und Admin SDKs werden konfiguriert, indem Werte direkt an ihre Initialisierungsfunktionen übergeben werden. Bei diesen SDKs können Sie mit einer Laufzeitprüfung Entwicklungs- oder Produktionskonfigurationsvariablen auswählen.

Android- und Apple-Plattformen (und ihre Unity- und C++-Wrapper) laden die Konfiguration normalerweise aus einer Konfigurationsdatei: GoogleService-Info.plist auf der Apple-Plattform und google-services.json auf Android-Geräten. Diese Dateien werden in ein Optionsobjekt (FIROption oder FirebaseOptions) gelesen, auf das das Firebase-Anwendungsobjekt (FIRApp oder FirebaseApp) verweist.

Bei diesen Plattformen wird der Wechsel zwischen Umgebungen in der Regel als Entscheidung zur Buildzeit implementiert, indem für jede Umgebung unterschiedliche Konfigurationsdateien verwendet werden.

Unterstützung mehrerer Umgebungen in Ihrer Apple-Anwendung

Standardmäßig lädt FirebaseApp.configure() die mit der Anwendung bereitgestellte GoogleService-Info.plist-Datei. Wenn Ihre Entwicklungs- und Produktionsumgebungen in Xcode als separate Ziele konfiguriert sind, haben Sie folgende Möglichkeiten:

• Beide GoogleService-Info.plist-Dateien herunterladen
• Speichern Sie die beiden Dateien in verschiedenen Verzeichnissen.
• Fügen Sie beide Ihrem Xcode-Projekt hinzu.
• Verknüpfen Sie die verschiedenen Dateien mit den verschiedenen Zielen über den Bereich „Zielmitgliedschaft“:

Wenn die Builds zu einem einzigen Ziel gehören, sollten Sie beiden Konfigurationsdateien eindeutige Namen geben (z.B. GoogleService-Info-Free.plist und GoogleService-Info-Paid.plist). Wählen Sie dann zur Laufzeit aus, welche plist geladen werden soll. Das ist im folgenden Beispiel zu sehen:

// Load a named file.
let filePath = Bundle.main.path(forResource: "MyGoogleService", ofType: "plist")
guard let fileopts = FirebaseOptions(contentsOfFile: filePath!)
  else { assert(false, "Couldn't load config file") }
FirebaseApp.configure(options: fileopts)

Mehrere Umgebungen in Ihrer Android-Anwendung unterstützen

Unter Android wird die Datei google-services.json vom Gradle-Plug-in für Google-Dienste in Android-Stringressourcen verarbeitet. Welche Ressourcen erstellt werden, erfahren Sie in der Dokumentation zum Google-Dienste-Plug-in unter JSON-Datei verarbeiten.

Sie können mehrere google-services.json-Dateien für verschiedene Buildvarianten haben, indem Sie google-services.json-Dateien in speziellen Verzeichnissen platzieren, die im Stammverzeichnis des App-Moduls nach jeder Variante benannt sind. Wenn Sie beispielsweise die Build-Varianten „Entwicklung“ und „Release“ haben, könnte Ihre Konfiguration so aussehen:

app/
    google-services.json
    src/development/google-services.json
    src/release/google-services.json
    ...

Weitere Informationen finden Sie in der Dokumentation zum Google Services-Plug-in unter JSON-Datei hinzufügen.

Diese Ressourcen werden dann vom FirebaseInitProvider geladen, der vor Ihrem Anwendungscode ausgeführt wird und die Firebase APIs mit diesen Werten initialisiert.

Da dieser Anbieter nur Ressourcen mit bekannten Namen liest, können Sie die Stringressourcen auch direkt Ihrer App hinzufügen, anstatt das Gradle-Plug-in für Google-Dienste zu verwenden. Dazu können Sie

• google-services-Plug-in aus dem Stammverzeichnis build.gradle entfernen
• google-services.json aus dem Projekt löschen
• Stringressourcen direkt hinzufügen
• apply plugin: 'com.google.gms.google-services' aus Ihrer App build.gradle löschen

Mehrere Projekte in Ihrer Anwendung verwenden

Manchmal müssen Sie mit denselben APIs auf verschiedene Projekte zugreifen, z. B. auf mehrere Datenbankinstanzen. In den meisten Fällen gibt es ein zentrales Firebase-Anwendungsobjekt, das die Konfiguration für alle Firebase APIs verwaltet. Dieses Objekt wird im Rahmen der normalen Einrichtung initialisiert. Wenn Sie jedoch von einer einzelnen Anwendung aus auf mehrere Projekte zugreifen möchten, benötigen Sie ein separates Firebase-Anwendungsobjekt, um auf jedes Projekt einzeln zu verweisen. Sie müssen diese anderen Instanzen selbst initialisieren.

In beiden Fällen müssen Sie zuerst ein Firebase-Optionsobjekt erstellen, um die Konfigurationsdaten für die Firebase-Anwendung zu speichern. Eine vollständige Dokumentation zu den Optionen finden Sie in der API-Referenzdokumentation für die folgenden Klassen:

• Swift: FirebaseOptions(googleAppID:gcmSenderID:)
• Android: FirebaseOptions.Builder
• Web: initializeApp()
• C++: firebase::App::Create
• Unity: FirebaseApp.Create
• Node.js: initializeApp
• Java: FirebaseOptions.Builder

In den folgenden Beispielen wird gezeigt, wie diese Klassen zur Unterstützung mehrerer Projekte in einer Anwendung verwendet werden:

// Configure with manual options. Note that projectID and apiKey, though not
// required by the initializer, are mandatory.
let secondaryOptions = FirebaseOptions(googleAppID: "1:27992087142:ios:2a4732a34787067a",
                                       gcmSenderID: "27992087142")
secondaryOptions.apiKey = "AIzaSyBicqfAZPvMgC7NZkjayUEsrepxuXzZDsk"
secondaryOptions.projectID = "projectid-12345"

// The other options are not mandatory, but may be required
// for specific Firebase products.
secondaryOptions.bundleID = "com.google.firebase.devrel.FiroptionConfiguration"
secondaryOptions.trackingID = "UA-12345678-1"
secondaryOptions.clientID = "27992087142-ola6qe637ulk8780vl8mo5vogegkm23n.apps.googleusercontent.com"
secondaryOptions.databaseURL = "https://myproject.firebaseio.com"
secondaryOptions.storageBucket = "myproject.appspot.com"
secondaryOptions.androidClientID = "12345.apps.googleusercontent.com"
secondaryOptions.deepLinkURLScheme = "myapp://"
secondaryOptions.storageBucket = "projectid-12345.appspot.com"
secondaryOptions.appGroupID = nil
AppDelegate.swift

// Manually configure Firebase Options. The following fields are REQUIRED:
//   - Project ID
//   - App ID
//   - API Key
val options = FirebaseOptions.Builder()
    .setProjectId("my-firebase-project")
    .setApplicationId("1:27992087142:android:ce3b6448250083d1")
    .setApiKey("AIzaSyADUe90ULnQDuGShD9W23RDP0xmeDc6Mvw")
    // .setDatabaseUrl(...)
    // .setStorageBucket(...)
    .build()
MainActivity.kt

// Manually configure Firebase Options. The following fields are REQUIRED:
//   - Project ID
//   - App ID
//   - API Key
FirebaseOptions options = new FirebaseOptions.Builder()
        .setProjectId("my-firebase-project")
        .setApplicationId("1:27992087142:android:ce3b6448250083d1")
        .setApiKey("AIzaSyADUe90ULnQDuGShD9W23RDP0xmeDc6Mvw")
        // setDatabaseURL(...)
        // setStorageBucket(...)
        .build();
MainActivity.java

// The following fields are REQUIRED:
//  - Project ID
//  - App ID
//  - API Key
const secondaryAppConfig = {
    projectId: "<PROJECT_ID>",
    appId: "<APP_ID>",
    apiKey: "<API_KEY>",
    // databaseURL: "...",
    // storageBucket: "...",
};
firebaseapp.js

firebase::AppOptions secondary_app_options;

// API key, app ID, and project ID are always required.
secondary_app_options.set_api_key("<API_KEY>");
secondary_app_options.set_app_id("<GOOGLE_APP_ID>");
secondary_app_options.set_project_id("<PROJECT_ID>");

// The following options are specific to individual Firebase products
// and may not always be required.
secondary_app_options.set_database_url("<DATABASE_URL>");
secondary_app_options.set_messaging_sender_id("<SENDER_ID>");
secondary_app_options.set_storage_bucket("<STORAGE_BUCKET>");

Firebase.AppOptions secondaryAppOptions = new Firebase.AppOptions {
  ApiKey = "<API_KEY>",
  AppId = "<GOOGLE_APP_ID>",
  ProjectId = "<PROJECT_ID>"
};

const secondaryServiceAccount = require('./path/to/serviceAccountKey.json');

// All required options are specified by the service account,
// add service-specific configuration like databaseURL as needed.
const secondaryAppConfig = {
    credential: cert(secondaryServiceAccount),
    // databaseURL: 'https://<DATABASE_NAME>.firebaseio.com'
};
index.js

FileInputStream serviceAccount = new FileInputStream("path/to/serviceAccountKey.json");

FirebaseOptions secondaryAppConfig = new FirebaseOptions.Builder()
  .setCredential(FirebaseCredentials.fromCertificate(serviceAccount))
  .setDatabaseUrl("https://<DATABASE_NAME>.firebaseio.com/")
  .build();

Nachdem Sie dieses Optionsobjekt initialisiert haben, können Sie damit eine zusätzliche Firebase-Anwendungs-Instanz konfigurieren. In allen folgenden Beispielen wird der String secondary verwendet. Mit diesem Namen wird die Anwendungsinstanz abgerufen und von anderen Instanzen unterschieden, einschließlich der Standardinstanz (mit dem Namen [DEFAULT]). Wählen Sie einen String aus, der der beabsichtigten Verwendung des anderen Firebase-Projekts entspricht.

In den folgenden Snippets wird die Verbindung zu einem alternativen Realtime Database veranschaulicht. Die APIs für andere Firebase-Funktionen folgen demselben Muster.

// Configure an alternative FIRApp.
FirebaseApp.configure(name: "secondary", options: secondaryOptions)

// Retrieve a previous created named app.
guard let secondary = FirebaseApp.app(name: "secondary")
  else { assert(false, "Could not retrieve secondary app") }


// Retrieve a Real Time Database client configured against a specific app.
let secondaryDb = Database.database(app: secondary)
AppDelegate.swift

// Initialize secondary FirebaseApp.
Firebase.initialize(context = this, options, "secondary")

// Retrieve secondary FirebaseApp.
val secondary = Firebase.app("secondary")
// Get the database for the other app.
val secondaryDatabase = Firebase.database(secondary)
MainActivity.kt

// Initialize with secondary app
FirebaseApp.initializeApp(this /* Context */, options, "secondary");

// Retrieve secondary FirebaseApp
FirebaseApp secondary = FirebaseApp.getInstance("secondary");
MainActivity.java

// Initialize another app with a different config
const secondaryApp = firebase.initializeApp(secondaryAppConfig, "secondary");
// Access services, such as the Realtime Database
// secondaryApp.database();
firebaseapp.js

firebase::App* secondary_app = firebase::App::Create(secondary_app_options, "Secondary");
firebase::database::Database* secondary_database = firebase::database::Database::GetInstance(secondary_app);

var secondaryApp = Firebase.FirebaseApp.Create(secondaryAppOptions, "Secondary"));
var secondaryDatabase = Firebase.Database.FirebaseDatabase.getInstance(secondaryApp);

// Initialize another app with a different config
const secondary = initializeApp(secondaryAppConfig, 'secondary');
// Access services, such as the Realtime Database
// const secondaryDatabase = secondary.database();
index.js

// Initialize another app with a different config
FirebaseApp secondaryApp = FirebaseApp.initializeApp(secondaryAppConfig, "secondary");

// Retrieve the database.
FirebaseDatabase secondaryDatabase = FirebaseDatabase.getInstance(secondaryApp);

Verlässliche Berichte für Analytics

Google Analytics erfasst Ereignisse sehr früh im App-Startvorgang, manchmal sogar noch bevor die primäre Firebase App-Instanz konfiguriert wurde. In diesen Fällen ruft Firebase die Android-Ressource oder GoogleService-Info.plist auf Apple-Plattformen auf, um die richtige Google-App-ID zum Speichern von Ereignissen abzurufen. Aus diesem Grund empfehlen wir, nach Möglichkeit die Standardkonfigurationsmethoden zu verwenden.

Wenn eine Laufzeitkonfiguration erforderlich ist, beachten Sie die folgenden Einschränkungen:

1. Wenn Sie AdMob verwenden und wie empfohlen Anzeigen beim Start anfordern, fehlen Ihnen möglicherweise einige Analytics-Daten zu mobilen Anzeigen, wenn Sie die ressourcenbasierte Konfiguration nicht verwenden.
2. Geben Sie in jeder verteilten Variante Ihrer App immer nur eine Google App-ID an. Wenn Sie beispielsweise Version 1 Ihrer App mit einer bestimmten GOOGLE_APP_ID in der Konfiguration bereitstellen und dann Version 2 mit einer anderen ID hochladen, werden möglicherweise Analysedaten verworfen.
3. Fügen Sie Ihrem Projekt auf Apple-Plattformen keine „GoogleService-Info.plist“ hinzu, wenn Sie zur Laufzeit eine andere Konfiguration angeben. Andernfalls kann es zu einer scheinbaren Änderung von GOOGLE_APP_ID und zu Datenverlusten in Analytics kommen.