Questa pagina è stata tradotta dall'API Cloud Translation.

Inizia a utilizzare Firebase Data Connect

In questa guida rapida, imparerai a creare Firebase Data Connect nella tua applicazione con un'istanza SQL di produzione.

Nella console Firebase:

Aggiungi Firebase Data Connect al tuo progetto Firebase.
Crea uno schema per un'app con la generazione di schemi basata sull'AI nella console Firebase e implementalo.
Esegui il provisioning di un'istanza Cloud SQL per la tua app.
Con Gemini in Firebase, puoi popolare il database con dati di esempio.
Crea query e mutazioni con la generazione di operazioni assistita dall'AI, che puoi eseguire il deployment e utilizzare per sviluppare codice client localmente.

Poi, nel tuo ambiente di sviluppo locale:

Configura uno strumento di sviluppo, inclusa un'estensione di Visual Studio Code, per lavorare con l'istanza di produzione.
Sincronizza l'ambiente locale con gli asset che hai creato nella console.
Genera SDK fortemente tipizzati e utilizzali nella tua app.

Flusso della console: utilizza l'assistenza dell'AI per progettare lo schema, quindi implementalo nel database

Se non l'hai ancora fatto, crea un progetto Firebase.
1. Nella Firebaseconsole, fai clic su Aggiungi progetto, quindi segui le istruzioni sullo schermo.
Vai alla sezione Data Connect della console Firebase.
Fai clic sul pulsante Inizia a usare Gemini.
Nel riquadro del flusso di lavoro Generatore di schema visualizzato, descrivi un'app in modo che Gemini possa aiutarti a creare uno schema GraphQL.
Rivedi lo schema GraphQL, quindi fai clic su Esegui l'upgrade e il deployment.
Esegui l'upgrade del tuo progetto al piano Blaze. In questo modo puoi creare un'istanza Cloud SQL per PostgreSQL.

Nota: anche se configuri la fatturazione nell'upgrade a Blaze, non ti verrà addebitato l'utilizzo di Data Connect o della configurazione predefinita di Cloud SQL per PostgreSQL durante la prova.
Seleziona Crea una nuova istanza Cloud SQL. Nella finestra di dialogo visualizzata, seleziona una località e un nome per il tuo database Cloud SQL per PostgreSQL.

Lo schema dell'app viene implementato insieme a un database PostgreSQL corrispondente a quello schema.

Nota: se vuoi utilizzare chiavi di crittografia gestite dal cliente (CMEK), assicurati di scegliere Utilizza un'istanza Cloud SQL esistente e seleziona un database Cloud SQL esistente con CMEK.
Nota: potrebbero essere necessari fino a 15 minuti per completare il provisioning dell'istanza Cloud SQL per PostgreSQL. Puoi verificare che il flusso di configurazione di Data Connect, inclusa la creazione di database, sia completato utilizzando la console Google Cloud.

Flusso della console: utilizza l'assistenza AI per creare operazioni per i tuoi clienti

Una volta implementato lo schema, puoi eseguire i primi passaggi per rendere questi dati accessibili dalle tue app client creando un connettore di query e mutazioni da implementare nel backend e chiamare in un secondo momento dai client.

I nostri strumenti di assistenza AI sono a tua disposizione.

Quando richiesto, fai clic sul pulsante Genera operazioni con Gemini.
Dopo qualche istante, nel riquadro del flusso di lavoro Genera le operazioni che viene visualizzato, esamina l'elenco di query e mutazioni fornito da Gemini in base al tuo schema.
Fai clic su ogni riga dell'operazione per esaminare il codice GraphQL che definisce l'operazione. Se necessario, utilizza il controllo del cestino per eliminare le operazioni che non ti servono.
Per aggiungere operazioni, fai clic sul pulsante + Aggiungi. Quindi:
1. Descrivi l'operazione in linguaggio naturale.
  
  Ad esempio:
```
List all products
```
2. Esamina il GraphQL generato.
3. Se l'operazione è accettabile, fai clic su Inserisci per aggiungerla all'elenco delle operazioni.
Continua a rimuovere e aggiungere operazioni finché il set di operazioni non è accettabile.
Per eseguire il deployment di questo elenco di operazioni come set di connettori richiamabili dal client, scegli il nome del connettore, quindi fai clic su Esegui il deployment.

Flusso della console: utilizza Gemini in Firebase per creare una mutazione e popolare il database

Completando i passaggi precedenti, hai creato uno Data Connect schema costituito da tipi di entità pertinenti e l'hai implementato in produzione, il che significa che è stato creato e implementato anche un database PostgreSQL con le tabelle corrispondenti.

Per popolare il database, puoi utilizzare Gemini in Firebase per definire una mutazione GraphQL per aggiornare una delle tue tabelle e una query per confermare gli aggiornamenti a partire dagli input in linguaggio naturale.

Apri la scheda Dati.
Fai clic sull'icona Aiutami a scrivere GraphQL pen_spark e, nella casella visualizzata, digita il tuo input.

Nota: scegli un'entità semplice e di base come Product o Account da compilare con i dati.

Ad esempio:
```
Add data for three sample products to my app.
```
Fai clic su Genera. La mutazione viene restituita.
Rivedi l'output. Se necessario, fai clic su Modifica per perfezionare il prompt e fai clic su Rigenera.
Successivamente, fai clic su Inserisci per inserire la mutazione nell'editor dei dati.
Fai clic su Esegui.

Quando esegui la mutazione, i dati vengono scritti nella tabella applicabile del tuo database PostgreSQL. Puoi creare una query nella console per visualizzare i dati archiviati:

Ripeti i passaggi precedenti utilizzando Aiutami a scrivere GraphQL pen_spark per creare una query.
Digita l'input nella casella visualizzata.

Ad esempio:
```
Query data for all sample products in my app.
```
Fai clic su Genera, quindi su Esegui.

Flusso locale: scegli gli strumenti di sviluppo

Ora che hai dati nel database di cui è stato eseguito il deployment e hai eseguito il deployment di un connettore, puoi continuare lo sviluppo dello schema e dei connettori nel tuo ambiente di sviluppo locale.

Innanzitutto, devi configurare un ambiente locale. Data Connect ti offre due modi per installare gli strumenti di sviluppo.

Flusso locale: configura l'ambiente di sviluppo

Crea una nuova directory per il progetto locale.
Per configurare un ambiente di sviluppo Data Connect e un IDE basato su browser e generare SDK client, esegui questo comando nella nuova directory che hai creato.
```
  curl -sL https://firebase.tools/init/dataconnect | editor=true bash
```
Questo script tenta l'installazione. L'IDE installato fornisce strumenti, tra cui estensioni VS Code pre-bundle, per aiutarti a gestire lo schema e definire query e mutazioni da utilizzare nella tua applicazione e generare SDK fortemente tipizzati.

Lo script sincronizza anche gli asset che hai creato nella console Firebase con la tua directory locale e genera SDK client per le app che hai registrato per il tuo progetto.

Flusso locale: configura il progetto locale

Per configurare il progetto locale, inizializza la directory del progetto. Nella finestra IDE, nel riquadro a sinistra, fai clic sull'icona di Firebase per aprire l'interfaccia utente dell'estensione Data Connect VS Code:

Fai clic sul pulsante Avvia emulatori.

Nota :nel terminale integrato, verifica che gli emulatori configurati vengano avviati. Una volta in esecuzione, dovresti visualizzare l'aggiornamento dell'interfaccia utente dell'estensione con i dettagli dell'emulatore.

Flusso locale: trova lo schema e il connettore nell'ambiente locale

L'opzione di installazione automatica per macOS o Linux che hai utilizzato per sincronizzare gli asset con un progetto esistente ha i seguenti effetti:

Sincronizza lo schema che hai implementato
- Trova lo schema: si trova nella directory del progetto Firebase, nel file /dataconnect/schema/schema.gql.
Sincronizza le query e le mutazioni nel connettore che hai implementato
- Trova il connettore: le operazioni si trovano nella directory del progetto Firebase, nella directory /dataconnect/connector/.

Flusso locale: comprendere lo schema

Esempio di schema: film

In Data Connect, i campi GraphQL vengono mappati alle colonne. Un tipo di Movie probabilmente avrà id, title, imageUrl e genre. Data Connect riconosce i tipi di dati primitivi String e UUID.

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

Esempio di schema di tabella 1:1: MovieMetadata

Con i film, puoi modellare i metadati dei film.

Ad esempio, in schema.gql, puoi aggiungere il seguente snippet o rivedere il codice generato da Gemini.

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

Tieni presente che il campo movie è mappato a un tipo di Movie. Data Connect comprende che si tratta di un rapporto tra Movie e MovieMetadata e lo gestirà per tuo conto.

Scopri di più sugli schemi di Data Connect nella documentazione

Flusso locale: aggiungi altri dati alle tabelle

Nel riquadro dell'editor IDE, puoi vedere i pulsanti CodeLens sopra i tipi GraphQL in /dataconnect/schema/schema.gql. Come hai fatto nella console, puoi creare una mutazione per aggiungere dati al tuo database di produzione.

Per aggiungere dati a una tabella in locale:

In schema.gql, fai clic sul pulsante Aggiungi dati sopra la dichiarazione per uno dei tuoi tipi (ad esempio Movie, Product, Account, a seconda della natura della tua app).
Un nuovo file, <type>_insert.qgl, viene aggiunto alla directory di lavoro, ad esempio Movie_insert.gql o Product_insert.gql. Codifica in modo permanente i dati nei campi per questo tipo.
Fai clic sul pulsante Esegui (produzione).
Ripeti i passaggi precedenti per aggiungere un record ad altre tabelle.

Per verificare rapidamente che i dati siano stati aggiunti:

In schema.gql, fai clic sul pulsante Leggi dati sopra la dichiarazione del tipo.
Nel file <type>_read.gql risultante, ad esempio Product_read.gql, fai clic sul pulsante Esegui (produzione) per eseguire la query.

Scopri di più sulle mutazioni di Data Connect nella documentazione

Flusso locale: genera SDK

Le operazioni dello schema e del connettore vengono sincronizzate localmente.

Ora puoi utilizzare l'estensione VS Code per generare SDK client per iniziare a implementare chiamate a query e mutazioni in app iOS, Android, web e Flutter.

Nell'interfaccia utente dell'estensione, fai clic sul pulsante Aggiungi SDK all'app.
Nella finestra di dialogo visualizzata, seleziona una directory contenente il codice per la tua app. Data Connect Il codice SDK verrà generato e salvato qui.

Nota: se non hai ancora una directory di app, puoi creare e selezionare una nuova directory per il codice SDK per ora e collegarla alla tua app in un secondo momento.
Seleziona la piattaforma dell'app, quindi tieni presente che il codice SDK viene generato immediatamente nella directory selezionata.

Flusso locale: utilizza gli SDK per chiamare la query da un'app

In precedenza, hai eseguito il deployment dello schema e delle operazioni nella console Firebase. Per chiamare operazioni dalla tua app, puoi utilizzare l'SDK che Data Connect ha generato per implementare una chiamata alla tua query ListMovies.

Web

Aggiungi Firebase alla tua app web.

Nel file principale dell'app React:

importa l'SDK generato
chiama i metodi Data Connect.

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

Aggiungi Firebase alla tua app iOS.
Per utilizzare l'SDK generato, configuralo come dipendenza in Xcode.

Nella barra di navigazione superiore di Xcode, seleziona File > Add Package Dependencies > Add Local (File > Aggiungi dipendenze pacchetto > Aggiungi locale) e scegli la cartella contenente il file Package.swift generato.

Nel delegato principale della tua app:

importa l'SDK generato
chiama i metodi Data Connect.

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

Aggiungi Firebase alla tua app Android.

Per utilizzare l'SDK generato, configura Data Connect come dipendenza in Gradle.

Aggiorna plugins e dependencies in 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")
}

Nell'attività principale della tua app:

importa l'SDK generato
chiama i metodi Data Connect.

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

Aggiungi Firebase alla tua app Flutter.
Installa l'interfaccia a riga di comando FlutterFire dart pub global activate flutterfire_cli.
Esegui flutterfire configure.
Nella funzione principale dell'app:
- importa l'SDK generato
- chiama i metodi Data Connect.

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();
            }),
      )
    ])));
  }
}

Passaggi successivi

Esamina il progetto di cui è stato eseguito il deployment e scopri altri strumenti:

Aggiungi dati al tuo database, esamina e modifica gli schemi e monitora il servizio Data Connect nella console Firebase.

Accedi a ulteriori informazioni nella documentazione. Ad esempio, dato che hai completato la guida rapida:

Scopri altri strumenti e indicazioni di assistenza AI per aiutarti a generare schemi, query e mutazioni. La guida all'assistenza AI spiega come configurare e utilizzare il nostro server MCP con i tuoi IDE e le best practice per scrivere prompt.
Scopri di più sullo sviluppo di schema, query e mutazione
Scopri di più sulla generazione di SDK client e sulle chiamate di query e mutazioni dal codice client per web, Android, iOS e Flutter.