Erste Schritte mit Firebase Data Connect

In dieser Kurzanleitung erfahren Sie, wie Sie Firebase Data Connect in Ihrer Anwendung mit einer Produktions-SQL-Instanz erstellen. Sie werden Folgendes tun:

  • Fügen Sie Firebase Data Connect Ihrem Firebase-Projekt hinzu.
  • Stellen Sie eine Cloud SQL-Instanz für Ihre App bereit.
  • Richten Sie eine Entwicklungsumgebung mit einer Visual Studio Code-Erweiterung ein, um mit einer Produktionsinstanz zu arbeiten.
  • Anschließend zeigen wir Ihnen, wie Sie:
    • Schema für eine Film-App erstellen
    • Abfragen und Mutationen definieren, die in Ihrer App verwendet werden
    • Abfragen und Mutationen mit Beispieldaten testen
    • Stark typisierte SDKs generieren und in Ihrer App verwenden
    • Bereitstellen Sie das endgültige Schema, die Abfragen und die Daten in der Cloud.

Firebase-Projekt und Cloud SQL-Datenbank erstellen

  1. Erstellen Sie ein Firebase-Projekt, falls noch nicht geschehen.
    1. Klicken Sie in der Firebase Console auf Projekt hinzufügen und folgen Sie der Anleitung auf dem Bildschirm.
  2. Rufe in der Firebase-Konsole den Bereich Data Connect auf und folge dem Workflow zur Produkteinrichtung.

  3. Führen Sie für Ihr Projekt ein Upgrade auf den Tarif „Blaze“ durch. So können Sie eine Cloud SQL for PostgreSQL-Instanz erstellen.

  4. Wählen Sie einen Speicherort für Ihre Cloud SQL for PostgreSQL-Datenbank aus.

  5. Notieren Sie sich die Namen und IDs von Projekt, Dienst und Datenbank für später.

  6. Folgen Sie den verbleibenden Einrichtungsschritten und klicken Sie auf Fertig.

Entwicklungsablauf auswählen

Data Connect bietet zwei Möglichkeiten, Entwicklungstools zu installieren.

Entwicklungsumgebung einrichten

  1. Erstellen Sie ein neues Verzeichnis für Ihr lokales Projekt.

  2. Führen Sie den folgenden Befehl im neu erstellten Verzeichnis aus.

      curl -sL https://firebase.tools/dataconnect | bash

    Dieses Script versucht, die Entwicklungsumgebung für Sie einzurichten und eine browserbasierte IDE zu starten. Diese IDE bietet Tools, einschließlich einer vorinstallierten VS Code-Erweiterung, mit denen Sie Ihr Schema verwalten, Abfragen und Mutationen für Ihre Anwendung definieren und stark typisierte SDKs generieren können.

alias dataconnect='curl -sL https://firebase.tools/dataconnect | bash'

Projektverzeichnis einrichten

Um Ihr lokales Projekt einzurichten, müssen Sie das Projektverzeichnis initialisieren. Klicken Sie im IDE-Fenster im linken Bereich auf das Firebase-Symbol, um die Benutzeroberfläche der Data Connect-VS Code-Erweiterung zu öffnen:

  1. Klicken Sie auf die Schaltfläche Über Google anmelden.
  2. Klicken Sie auf die Schaltfläche Firebase-Projekt verknüpfen und wählen Sie das Projekt aus, das Sie zuvor in der Console erstellt haben.
  3. Klicken Sie auf die Schaltfläche firebase init ausführen und führen Sie den Vorgang aus.

  4. Klicken Sie auf die Schaltfläche Emulatoren starten.

Schema erstellen

Definieren Sie im Firebase-Projektverzeichnis in der Datei /dataconnect/schema/schema.gql ein GraphQL-Schema, das Filme enthält.

Film

In Data Connect werden GraphQL-Felder Spalten zugeordnet. Der Typ Movie hat id, title, imageUrl und genre. Data Connecterkennt die primitiven Datentypen String und UUID.

Kopieren Sie das folgende Snippet oder entfernen Sie die Kommentarzeichen für die entsprechenden Zeilen in der Datei.

# File `/dataconnect/schema/schema.gql`

# By default, a UUID id key will be created by default as primary key.
type Movie @table {
  id: UUID! @default(expr: "uuidV4()")
  title: String!
  imageUrl: String!
  genre: String
}

MovieMetadata

Jetzt, da Sie Filme haben, können Sie Metadaten für Filme modellieren.

Kopieren Sie das folgende Snippet oder entfernen Sie die Kommentarzeichen für die entsprechenden Zeilen in der Datei.

# Movie - MovieMetadata is a one-to-one relationship
type MovieMetadata @table {
  # This time, we omit adding a primary key because
  # you can rely on Data Connect to manage it.

  # @unique indicates a 1-1 relationship
  movie: Movie! @unique
  # movieId: UUID <- this is created by the above reference
  rating: Float
  releaseYear: Int
  description: String
}

Das Feld movie ist einem Typ von Movie zugeordnet. Data Connect ist sich bewusst, dass es sich um eine Beziehung zwischen Movie und MovieMetadata handelt, und verwaltet diese Beziehung für Sie.

Weitere Informationen zu Data Connect-Schemas in der Dokumentation

Schema für die Produktion bereitstellen

Sie müssen Ihr Schema bereitstellen, bevor Sie fortfahren können.

Klicken Sie in der Benutzeroberfläche der Erweiterung im Bereich Firebase Data Connect auf In Produktion bereitstellen.

Nachdem Sie Ihr Schema in Ihrer Produktionsdatenbank bereitgestellt haben, sollten Sie es in der Firebase-Konsole sehen können.

Tabellen Daten hinzufügen

Im Bereich „IDE-Editor“ werden im /dataconnect/schema/schema.gql CodeLens-Schaltflächen über den GraphQL-Typen angezeigt. Da Sie Ihr Schema in der Produktion bereitgestellt haben, können Sie mit den Schaltflächen Daten hinzufügen und Ausführen (Produktion) Ihrer Datenbank im Backend Daten hinzufügen.

So fügen Sie der Tabelle Movie Einträge hinzu:

  1. Klicken Sie in schema.gql über der Typdeklaration für Movie auf die Schaltfläche Daten hinzufügen.
    Code Lens-Schaltfläche „Daten hinzufügen“ für Firebase Data Connect
  2. Codieren Sie in der generierten Movie_insert.gql-Datei Daten für die vier Felder.
  3. Klicken Sie auf die Schaltfläche Ausführen (Produktion).
    Code Lens-Schaltfläche „Ausführen“ für Firebase Data Connect
  4. Wiederhole die vorherigen Schritte, um der Tabelle MovieMetadata einen Datensatz hinzuzufügen. Gib dazu die id deines Films in das Feld movieId ein, wie in der generierten MovieMetadata_insert-Mutation angegeben.

So prüfen Sie schnell, ob Daten hinzugefügt wurden:

  1. Klicken Sie in schema.gql über der Typdeklaration für Movie auf die Schaltfläche Daten lesen.
  2. Klicken Sie in der resultierenden Movie_read.gql-Datei auf die Schaltfläche Ausführen (Produktion), um die Abfrage auszuführen.

Weitere Informationen zu Data Connect-Mutationen in der Dokumentation

Abfrage definieren

Jetzt kommt der spaßige Teil: Abfragen. Als Entwickler sind Sie es gewohnt, SQL-Abfragen anstelle von GraphQL-Abfragen zu schreiben. Das kann sich also anfangs etwas anders anfühlen. GraphQL ist jedoch viel prägnanter und typsicherer als reines SQL. Unsere VS Code-Erweiterung erleichtert die Entwicklung.

Bearbeiten Sie die Datei /dataconnect/connector/queries.gql. Wenn Sie alle Filme abrufen möchten, verwenden Sie eine Abfrage wie diese.

# File `/dataconnect/connector/queries.gql`

# @auth() directives control who can call each operation.
# Anyone should be able to list all movies, so the auth level
# is set to PUBLIC
query ListMovies @auth(level: PUBLIC) {
  movies {
    id
    title
    imageUrl
    genre
  }
}

Führen Sie die Abfrage mit der CodeLens-Schaltfläche aus.

Weitere Informationen zu Data Connect-Abfragen finden Sie in der Dokumentation.

SDKs generieren

  1. Klicken Sie auf die Schaltfläche SDK zur App hinzufügen.

  2. Wählen Sie im angezeigten Dialogfeld ein Verzeichnis mit Code für Ihre App aus. Data Connect Der SDK-Code wird dort generiert und gespeichert.

  3. Wählen Sie Ihre App-Plattform aus. Der SDK-Code wird dann sofort im ausgewählten Verzeichnis generiert.

Schema und Abfrage in der Produktion bereitstellen

Sie haben eine Entwicklungsiteration durchlaufen. Jetzt können Sie Ihr Schema, Ihre Daten und Abfragen mit der Benutzeroberfläche der Firebase-Erweiterung oder der Firebase-Befehlszeile auf dem Server bereitstellen, genau wie Sie es mit Ihrem Schema getan haben.

Klicken Sie im IDE-Fenster in der VS Code-Erweiterungs-Benutzeroberfläche auf die Schaltfläche In Produktion bereitstellen.

Rufen Sie nach der Bereitstellung die Firebase Console auf, um zu prüfen, ob das Schema, die Vorgänge und die Daten in die Cloud hochgeladen wurden. Sie sollten das Schema sehen und Ihre Vorgänge auch in der Console ausführen können. Die Cloud SQL for PostgreSQL-Instanz wird mit dem endgültig bereitgestellten generierten Schema und den Daten aktualisiert.

Weitere Informationen zur Verwendung des Data Connect-Emulators finden Sie in der Dokumentation.

Abfrage über SDKs aus einer App aufrufen

Nachdem Sie Ihr Schema und Ihre Abfrage in der Produktionsumgebung bereitgestellt haben, können Sie das von Data Connect generierte SDK verwenden, um einen Aufruf Ihrer ListMovies-Abfrage zu implementieren.

Web

  1. Fügen Sie Firebase Ihrer Web-App hinzu.

  2. In der Hauptdatei Ihrer React-App:

    • Ihr generiertes SDK importieren
    • Data Connect-Methoden aufrufen.
    import React from 'react';
import ReactDOM from 'react-dom/client';

// Generated queries.
// Update as needed with the path to your generated SDK.
import { listMovies, ListMoviesData } from '@movie-app/movies';

function App() {
  const [movies, setMovies] = useState<ListMoviesData['movies']>([]);
  useEffect(() => {
    listMovies.then(res => setMovies(res.data));
  }, []);
  return (
    movies.map(movie => <h1>{movie.title}</h1>);
  );
}

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(<App />);

Swift

  1. Fügen Sie Firebase Ihrer iOS-App hinzu.

  2. Wenn Sie das generierte SDK verwenden möchten, konfigurieren Sie es in Xcode als Abhängigkeit.

    Wählen Sie in der oberen Navigationsleiste von Xcode File > Add Package Dependencies > Add Local (Datei > Paketabhängigkeiten hinzufügen > Lokal hinzufügen) aus und wählen Sie den Ordner mit der generierten Package.swift aus.

  3. Im Hauptdelegierten Ihrer App:

    • Ihr generiertes SDK importieren
    • Data Connect-Methoden aufrufen.
    import SwiftUI

import FirebaseDataConnect
// Generated queries.
// Update as needed with the package name of your generated SDK.
import <CONNECTOR-PACKAGE-NAME>

let connector = DataConnect.moviesConnector

struct ListMovieView: View {
@StateObject private var queryRef = connector.listMovies.ref()

    var body: some View {
        VStack {
            Button {
                Task {
                    do {
                        try await refresh()
                    } catch {
                        print("Failed to refresh: \(error)")
                    }
                }
            } label: {
                Text("Refresh")
            }

            // use the query results in a view
            ForEach(queryRef.data?.movies ?? []) { movie in
                    Text(movie.title)
                }
            }
    }
    @MainActor
    func refresh() async throws {
        _ = try await queryRef.execute()
    }

    struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ListMovieView()
    }
}

Kotlin Android

  1. Fügen Sie Firebase Ihrer Android-App hinzu.

  2. Wenn Sie das generierte SDK verwenden möchten, konfigurieren Sie Data Connect in Gradle als Abhängigkeit.

    Aktualisieren Sie plugins und dependencies in Ihrer app/build.gradle.kts.

    plugins {
  // Use whichever versions of these dependencies suit your application.
  // The versions shown here were the latest as of March 14, 2025.
  // Note, however, that the version of kotlin("plugin.serialization") must,
  // in general, match the version of kotlin("android").
  id("com.android.application") version "8.9.0"
  id("com.google.gms.google-services") version "4.4.2"
  val kotlinVersion = "2.1.10"
  kotlin("android") version kotlinVersion
  kotlin("plugin.serialization") version kotlinVersion
}

dependencies {
  // Use whichever versions of these dependencies suit your application.
  // The versions shown here were the latest versions as of March 14, 2025.
  implementation("com.google.firebase:firebase-dataconnect:16.0.0-beta04")
  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.1")
  implementation("org.jetbrains.kotlinx:kotlinx-serialization-core:1.7.3")

  // These dependencies are not strictly required, but will very likely be used
  // when writing modern Android applications.
  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0")
  implementation("androidx.appcompat:appcompat:1.7.0")
  implementation("androidx.activity:activity-ktx:1.10.1")
  implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.7")
  implementation("com.google.android.material:material:1.12.0")
}

  3. In der Hauptaktivität Ihrer App:

    • Ihr generiertes SDK importieren
    • Data Connect-Methoden aufrufen.
    import android.os.Bundle
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.repeatOnLifecycle
import kotlinx.coroutines.launch


private val connector = com.myapplication.MoviesConnector.instance

class MainActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    val textView: TextView = findViewById(R.id.text_view)

    lifecycleScope.launch {
      lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
        
        val result = connector.listMovies.runCatching { execute { } }
        
        val newTextViewText = result.fold(
          onSuccess = {
            val titles = it.data.movies.map { it.title }
            "${titles.size} movies: " + titles.joinToString(", ")
          },
          onFailure = { "ERROR: ${it.message}" }
        )
        textView.text = newTextViewText
      }
    }
  }
}

Flutter

  1. Fügen Sie Firebase Ihrer Flutter-App hinzu.
  2. Installieren Sie die FlutterFire-Befehlszeile dart pub global activate flutterfire_cli.
  3. Führen Sie flutterfire configure aus.
  4. In der Hauptfunktion Ihrer App:
    • Ihr generiertes SDK importieren
    • Data Connect-Methoden aufrufen.
import 'package:firebase_core/firebase_core.dart';
import 'package:flutter/material.dart';
import 'firebase_options.dart';

// Generated queries.
// Update as needed with the path to your generated SDK

import 'movies_connector/movies.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  
  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );
  
  
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
        home: Scaffold(
            body: Column(children: [
      ConstrainedBox(
        constraints: const BoxConstraints(maxHeight: 200),
        child: FutureBuilder(
            future: MoviesConnector.instance.listMovies().execute(),
            builder: (context, snapshot) {
              if (snapshot.connectionState == ConnectionState.done) {
                return ListView.builder(
                  scrollDirection: Axis.vertical,
                  itemBuilder: (context, index) => Card(
                      child: Text(
                    snapshot.data!.data.movies[index].title,
                  )),
                  itemCount: snapshot.data!.data.movies.length,
                );
              }
              return const CircularProgressIndicator();
            }),
      )
    ])));
  }
}

Nächste Schritte

Sehen Sie sich Ihr bereitgestelltes Projekt an und entdecken Sie weitere Tools: