# Intégrer ou éjecter

« Mettre mon tableau de bord dans ma propre application » a deux réponses ici, et ce sont réellement deux produits différents plutôt que deux réglages d'un seul.

* **Intégrer** — nous rendons le tableau de bord ; vous le mettez dans une `<iframe>`. Vous n'écrivez aucun code de tableau de bord et ne possédez aucun build. [Intégrer un tableau de bord](/fr/api/embedding-the-share-iframe.md).
* **Éjecter** — nous vous remettons la source React et SQL ; c'est vous qui la rendez. Nous quittons entièrement le chemin de rendu et ne gardons que le moteur de données en dessous. [Éjecter votre tableau de bord](/fr/guides/eject-your-dashboard.md).

Les deux gardent la moitié plateforme — connexions, jeux de données, actualisations, planifications, le moteur de requêtes, la gouvernance — maintenue de notre côté. La seule question est de savoir qui dessine les pixels.

## La réponse courte[​](#la-réponse-courte "Lien direct vers La réponse courte")

**Intégrez** s'il vous faut un filtrage des lignes par visionneur, ou si vous voulez que la publication soit tout le déploiement. **Éjectez** s'il faut que le tableau de bord ait l'apparence et le comportement du reste de votre application, ou s'il doit tourner là où nous n'allons pas.

## Côte à côte[​](#côte-à-côte "Lien direct vers Côte à côte")

|                                                           | Intégrer                                                                                  | Éjecter                                                                                   |
| --------------------------------------------------------- | ----------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
| Qui rend                                                  | nous                                                                                      | vous                                                                                      |
| Ce que vous intégrez                                      | une URL (plus un jeton de courte durée sur la voie protégée)                              | un arbre source que vous construisez et hébergez                                          |
| Qui déploie un changement                                 | personne — republiez et la frame le sert                                                  | vous, sur votre propre build et votre propre release                                      |
| Filtrage des lignes par visionneur                        | **oui**, appliqué côté serveur depuis un jeton signé — c'est le seul endroit où il existe | pas sur la voie sans identifiant ; demande votre propre serveur dans le chemin            |
| Contrôle visuel et d'interaction                          | notre moteur de rendu, notre habillage                                                    | complet — ce sont vos composants                                                          |
| État des filtres partagé avec votre propre interface      | non, dans aucun des deux sens                                                             | oui, c'est votre état                                                                     |
| Routage, authentification, intégration de la mise en page | frontière de l'iframe                                                                     | native à votre application                                                                |
| Identifiant que vous devez détenir                        | aucun sur la voie publique ; une clé d'API sur votre backend pour la voie protégée        | aucun sur la voie sans identifiant ; une clé d'API sur votre serveur pour la voie backend |
| Nécessite un backend à vous                               | seulement pour la voie protégée, afin de générer les jetons                               | seulement si vous voulez une restriction par lignes ou des requêtes vivantes              |
| Fraîcheur des données                                     | requêtes vivantes à chaque chargement                                                     | vivantes sur la voie backend ; l'instantané publié sur la voie sans identifiant           |

## Choisissez l'intégration quand[​](#choisissez-lintégration-quand "Lien direct vers Choisissez l'intégration quand")

* **Des visionneurs différents doivent voir des lignes différentes.** C'est le critère décisif. Le filtrage au niveau des lignes vit dans la voie d'intégration à jeton signé et nulle part ailleurs : votre backend génère un jeton de courte durée portant les filtres, la plateforme réécrit chaque référence de jeu de données en une relation filtrée, et la page ne peut que restreindre davantage. Rien de ce que vous construisez sur un arbre éjecté ne le reproduit sans mettre votre propre serveur devant chaque requête.
* **Vous voulez que la publication soit le déploiement.** Une republication change ce que servent toutes les intégrations. Aucune release de votre côté, aucune version du tableau de bord épinglée dans votre bundle.
* **Vous ne voulez pas posséder de code de tableau de bord.** Pas de build, pas de mises à jour de dépendances, pas de valse des bibliothèques de graphiques.
* **Le tableau de bord est un panneau, pas le produit.** Un onglet de reporting, un relevé destiné aux clients, une vue d'administration.

## Choisissez l'éjection quand[​](#choisissez-léjection-quand "Lien direct vers Choisissez l'éjection quand")

* **Il faut que ça ressemble à votre application.** Votre design system, votre typographie, vos états vides, vos squelettes de chargement. Une iframe est un rectangle avec l'habillage de quelqu'un d'autre dedans.
* **Il faut que ça interagisse avec votre application.** Vos filtres pilotant ses graphiques, ses sélections pilotant votre page. La voie d'intégration ne transmet l'état des filtres dans aucun des deux sens, donc le filtrage croisé entre un tableau de bord et votre propre interface n'y est pas disponible.
* **Vous avez besoin de votre propre routage, authentification ou mise en page.** Des liens profonds vers une tuile, votre session, votre coquille applicative, vos fils d'Ariane.
* **Il faut que ça tourne là où nous ne sommes pas.** Votre propre hébergement, votre propre VPC, un CDN que vous contrôlez. La source est du React et du SQL ordinaires et elle se construit avec `npm install && npm run dev`. Notez que l'éjection déplace le *rendu* vers votre infrastructure, pas les données : un tableau de bord éjecté atteint toujours le moteur de requêtes de ce compte ou son extrait Parquet par le réseau. Si l'exigence est qu'aucune donnée ne sorte de votre environnement, c'est [Vibedasher Server](/fr/.md#vibedasher-cloud-or-vibedasher-server), pas l'éjection.
* **Vous ne voulez aucun identifiant et aucun backend du tout.** Un tableau de bord public et publié s'éjecte sur une voie qui télécharge un extrait Parquet et exécute chaque requête dans le navigateur du visiteur — pas de clé, pas de jeton, rien à vous à faire tourner ou à payer. Lisez ce que cela sacrifie dans [la voie de requête wasm](/fr/guides/the-wasm-query-lane.md).

## Trois différences difficiles à défaire[​](#trois-différences-difficiles-à-défaire "Lien direct vers Trois différences difficiles à défaire")

Sur tout ce qui précède, vous pouvez changer d'avis à peu de frais. Ces trois-là, décidez-les avant de construire.

### La restriction par lignes est un choix d'architecture, pas une case à cocher[​](#la-restriction-par-lignes-est-un-choix-darchitecture-pas-une-case-à-cocher "Lien direct vers La restriction par lignes est un choix d'architecture, pas une case à cocher")

Si vous expédiez un tableau de bord éjecté sur la voie sans identifiant et qu'il vous faut plus tard que le visionneur A voit moins de lignes que le visionneur B, il n'y a aucun réglage à activer. L'extrait dans le navigateur est le jeu de données entier, donc chaque visiteur a déjà toutes les lignes. Retrouver la restriction veut dire mettre un serveur à vous entre le visionneur et les données et réécrire la voie de requête du tableau de bord contre lui — ou passer à la voie d'intégration, qui est une intégration différente. Voir [qui peut voir quoi](/fr/guides/who-can-see-what.md#row-level-filtering-the-embed-lane-and-only-the-embed-lane).

### Dès que vous modifiez un arbre éjecté, l'application n'est plus la source de vérité[​](#dès-que-vous-modifiez-un-arbre-éjecté-lapplication-nest-plus-la-source-de-vérité "Lien direct vers Dès que vous modifiez un arbre éjecté, l'application n'est plus la source de vérité")

L'éjection est un vrai fork, et c'est tout son intérêt. Vous pouvez repousser un arbre modifié vers la branche de brouillon et continuer à travailler dans la boucle, mais si vous emportez la source dans votre propre dépôt et commencez à la changer là, les changements faits ensuite dans l'application ne remontent pas dans votre copie et les vôtres ne redescendent pas. Décidez quel côté possède le code.

### Les choix de visibilité sur la voie d'intégration ne sont pas symétriques[​](#les-choix-de-visibilité-sur-la-voie-dintégration-ne-sont-pas-symétriques "Lien direct vers Les choix de visibilité sur la voie d'intégration ne sont pas symétriques")

La voie protégée exige que la visibilité du tableau de bord soit `protected`, et refuse net un tableau de bord `public` — afin que vous ne puissiez pas croire avoir des filtres de lignes quand vous n'en avez pas. Un tableau de bord `private` n'est intégrable par aucune des deux voies. Et rendre un tableau de bord lisible par le monde entier est la seule étape irréversible du flux de publication ; voir [publier et partager](/fr/guides/publish-and-share.md).

## Vous pouvez faire les deux[​](#vous-pouvez-faire-les-deux "Lien direct vers Vous pouvez faire les deux")

Elles ne sont pas exclusives, et une forme courante utilise chacune pour ce qu'elle fait de mieux : intégrer la vue destinée aux clients là où le filtrage des lignes est toute l'exigence, et éjecter la vue interne qui doit s'installer dans votre propre coquille d'administration. Mêmes jeux de données, mêmes actualisations, même gouvernance en dessous.

## Ensuite[​](#ensuite "Lien direct vers Ensuite")

* **[Intégrer un tableau de bord](/fr/api/embedding-the-share-iframe.md)** — les deux voies d'intégration, la boucle de rafraîchissement de jeton, les messages que votre page reçoit réellement, et où se situe la frontière du cadre.
* **[Éjecter votre tableau de bord](/fr/guides/eject-your-dashboard.md)** — les trois appels, le contrat de pagination, et comment rebrancher les données.