# Incorporare o espellere

"Metti la mia dashboard dentro la mia app" qui ha due risposte, e sono davvero due prodotti diversi più che due impostazioni di uno solo.

* **Incorporare** — la dashboard la renderizziamo noi; tu la metti in un `<iframe>`. Non scrivi codice di dashboard e non possiedi nessuna build. [Incorporare una dashboard](/it/api/embedding-the-share-iframe.md).
* **Espellere** — ti consegniamo i sorgenti React e SQL; li renderizzi tu. Esciamo del tutto dal percorso di rendering e manteniamo solo il motore dati sottostante. [Espelli la tua dashboard](/it/guides/eject-your-dashboard.md).

Entrambe lasciano la metà piattaforma — connessioni, dataset, aggiornamenti, pianificazioni, il motore di query, la governance — gestita dalla nostra parte. La domanda è solo chi disegna i pixel.

## La risposta breve[​](#la-risposta-breve "Link diretto a La risposta breve")

**Incorpora** se ti serve il filtraggio per riga per singolo visualizzatore, o se vuoi che pubblicare sia tutto il deploy. **Espelli** se la dashboard deve avere l'aspetto e il comportamento del resto della tua app, o se deve girare dove noi non arriviamo.

## A confronto[​](#a-confronto "Link diretto a A confronto")

|                                                  | Incorporare                                                                          | Espellere                                                                                   |
| ------------------------------------------------ | ------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------- |
| Chi renderizza                                   | noi                                                                                  | tu                                                                                          |
| Cosa integri                                     | un URL (più un token di breve durata sulla corsia protetta)                          | un albero di sorgenti che costruisci e ospiti                                               |
| Chi distribuisce una modifica                    | nessuno — ripubblichi e il frame la serve                                            | tu, con la tua build e la tua release                                                       |
| Filtraggio per riga per singolo visualizzatore   | **sì**, applicato lato server da un token firmato — è il solo posto in cui esiste    | no sulla corsia senza credenziali; richiede un tuo server nel percorso                      |
| Controllo visivo e di interazione                | il nostro renderer, la nostra cornice                                                | completo — sono i tuoi componenti                                                           |
| Stato dei filtri condiviso con la tua UI         | no, in nessuna delle due direzioni                                                   | sì, è il tuo stato                                                                          |
| Routing, autenticazione, integrazione del layout | il confine dell'iframe                                                               | nativa nella tua app                                                                        |
| Credenziale che devi custodire                   | nessuna sulla corsia pubblica; una chiave API nel tuo backend per la corsia protetta | nessuna sulla corsia senza credenziali; una chiave API sul tuo server per la corsia backend |
| Richiede un backend tuo                          | solo per la corsia protetta, per emettere i token                                    | solo se vuoi la restrizione per riga o query dal vivo                                       |
| Freschezza dei dati                              | query dal vivo a ogni caricamento                                                    | dal vivo sulla corsia backend; lo snapshot pubblicato sulla corsia senza credenziali        |

## Scegli incorporare quando[​](#scegli-incorporare-quando "Link diretto a Scegli incorporare quando")

* **Visualizzatori diversi devono vedere righe diverse.** È il criterio decisivo. Il filtraggio a livello di riga vive nella corsia di incorporazione a token firmato e in nessun altro posto: il tuo backend emette un token di breve durata che porta i filtri, la piattaforma riscrive ogni riferimento a un dataset in una relazione filtrata, e la pagina può solo restringere ulteriormente. Nulla di ciò che costruisci su un albero espulso lo riproduce senza mettere un tuo server davanti a ogni query.
* **Vuoi che pubblicare sia il deploy.** Una ripubblicazione cambia ciò che ogni incorporazione serve. Nessuna release dalla tua parte, nessuna versione della dashboard fissata dentro il tuo bundle.
* **Non vuoi possedere codice di dashboard.** Nessuna build, nessun aggiornamento di dipendenze, nessun valzer delle librerie di grafici.
* **La dashboard è un riquadro, non il prodotto.** Una scheda di reportistica, un estratto conto per il cliente, una vista di amministrazione.

## Scegli espellere quando[​](#scegli-espellere-quando "Link diretto a Scegli espellere quando")

* **Deve sembrare la tua app.** Il tuo design system, la tua tipografia, i tuoi stati vuoti, i tuoi scheletri di caricamento. Un iframe è un rettangolo con dentro la cornice di qualcun altro.
* **Deve interagire con la tua app.** I tuoi filtri che guidano i suoi grafici, le sue selezioni che guidano la tua pagina. La corsia di incorporazione non passa lo stato dei filtri in nessuna delle due direzioni, quindi il filtraggio incrociato tra una dashboard e la tua UI lì non è disponibile.
* **Ti serve il tuo routing, la tua autenticazione o il tuo layout.** Deep link su una tile, la tua sessione, il tuo guscio applicativo, i tuoi breadcrumb.
* **Deve girare dove noi non siamo.** Il tuo hosting, la tua VPC, una CDN che controlli tu. I sorgenti sono semplice React e SQL e si costruiscono con `npm install && npm run dev`. Nota che l'espulsione sposta il *rendering* sulla tua infrastruttura, non i dati: una dashboard espulsa raggiunge comunque in rete il motore di query di questo account o il suo estratto Parquet. Se il requisito è che nessun dato esca dal tuo ambiente, allora è [Vibedasher Server](/it/.md#vibedasher-cloud-or-vibedasher-server), non l'espulsione.
* **Non vuoi nessuna credenziale e nessun backend.** Una dashboard pubblica e pubblicata viene espulsa su una corsia che scarica un estratto Parquet ed esegue ogni query nel browser del visitatore — nessuna chiave, nessun token, nulla di tuo da far girare o da pagare. Leggi cosa si sacrifica in [la corsia di query wasm](/it/guides/the-wasm-query-lane.md).

## Tre differenze difficili da tornare indietro[​](#tre-differenze-difficili-da-tornare-indietro "Link diretto a Tre differenze difficili da tornare indietro")

Su tutto quello che precede puoi cambiare idea a basso costo. Queste tre conviene deciderle prima di costruire.

### La restrizione per riga è una scelta di architettura, non un interruttore[​](#la-restrizione-per-riga-è-una-scelta-di-architettura-non-un-interruttore "Link diretto a La restrizione per riga è una scelta di architettura, non un interruttore")

Se spedisci una dashboard espulsa sulla corsia senza credenziali e più tardi ti serve che il visualizzatore A veda meno righe del visualizzatore B, non c'è nessuna impostazione da attivare. L'estratto nel browser è l'intero dataset, quindi ogni visitatore ha già tutte le righe. Riavere la restrizione significa mettere un tuo server tra il visualizzatore e i dati e riscrivere su di esso la corsia di query della dashboard — oppure passare alla corsia di incorporazione, che è un'altra integrazione. Vedi [chi può vedere cosa](/it/guides/who-can-see-what.md#row-level-filtering-the-embed-lane-and-only-the-embed-lane).

### Appena modifichi un albero espulso, l'app non è più la fonte di verità[​](#appena-modifichi-un-albero-espulso-lapp-non-è-più-la-fonte-di-verità "Link diretto a Appena modifichi un albero espulso, l'app non è più la fonte di verità")

L'espulsione è un vero fork, ed è esattamente il suo scopo. Puoi rimandare un albero modificato sul branch di bozza e continuare a lavorare nel ciclo, ma se porti i sorgenti nel tuo repository e inizi a cambiarli lì, le modifiche fatte in seguito nell'app non arrivano alla tua copia e le tue non tornano indietro. Decidi quale lato possiede il codice.

### Le scelte di visibilità sulla corsia di incorporazione non sono simmetriche[​](#le-scelte-di-visibilità-sulla-corsia-di-incorporazione-non-sono-simmetriche "Link diretto a Le scelte di visibilità sulla corsia di incorporazione non sono simmetriche")

La corsia protetta richiede che la visibilità della dashboard sia `protected`, e rifiuta netto una dashboard `public` — così non puoi credere di avere filtri per riga quando non li hai. Una dashboard `private` non è incorporabile da nessuna delle due corsie. E rendere una dashboard leggibile da tutto il mondo è l'unico passo irreversibile del flusso di pubblicazione; vedi [pubblica e condividi](/it/guides/publish-and-share.md).

## Puoi fare entrambe[​](#puoi-fare-entrambe "Link diretto a Puoi fare entrambe")

Non sono esclusive, e una forma comune usa ciascuna per quello in cui è buona: incorporare la vista rivolta al cliente, dove il filtraggio per riga è tutto il requisito, ed espellere la vista interna che deve stare dentro il tuo guscio di amministrazione. Gli stessi dataset, gli stessi aggiornamenti, la stessa governance sotto.

## Prossimo[​](#prossimo "Link diretto a Prossimo")

* **[Incorporare una dashboard](/it/api/embedding-the-share-iframe.md)** — entrambe le corsie di incorporazione, il ciclo di rinnovo del token, i messaggi che la tua pagina riceve davvero, e dove si trova il confine del frame.
* **[Espelli la tua dashboard](/it/guides/eject-your-dashboard.md)** — le tre chiamate, il contratto di paginazione, e come ricollegare i dati.