La fonctionnalité Importation de projet locale est une fonctionnalité expérimentale qui permet d'importer des fichiers à partir de projets LookML locaux. Les fonctionnalités expérimentales ne sont pas entièrement développées et peuvent être considérablement modifiées ou complètement supprimées.
L'importation de fichiers à partir de projets LookML distants ou locaux n'est actuellement pas compatible avec la localisation de modèles.
Vous pouvez importer des fichiers d'autres projets LookML et des dépôts externes dans votre projet actuel. Vous pouvez ainsi utiliser des fichiers de modèle, afficher des fichiers et d'autres fichiers dans plusieurs projets.
Il existe plusieurs cas d'utilisation. Quelques exemples :
Créer sur un bloc Looker installé sans avoir à le modifier directement Si Looker modifie le bloc, vous pouvez facilement l'intégrer, car tous les LookML que vous y avez ajoutés sont conservés dans un dépôt distinct.
Gérer un projet de base généré automatiquement en fonction du schéma de la base de données Vous pouvez placer l'ensemble de vos dimensions, mesures et autres éléments personnalisés dans un projet distinct qui importe tous les LookML à partir du projet généré automatiquement. Vous pouvez générer à nouveau le projet de base à mesure que le schéma de la base de données change sans écraser tous vos LookML personnalisés.
Encapsuler des objets partagés dans un seul projet, puis les importer dans plusieurs autres projets Par exemple, si vous disposez d'une table commune à plusieurs bases de données, vous pouvez placer la vue pour celle-ci dans un projet et la conserver à cet endroit. Ensuite, faites en sorte que plusieurs autres projets l'utilisent en important la table dans ces projets.
Pour importer des fichiers à partir d'un autre projet, procédez comme suit:
- Créez un fichier manifeste de projet.
- Spécifiez les projets local ou à distance que vous souhaitez importer.
- Affichez les fichiers d'un projet importé.
- Incluez les fichiers d'un projet importé.
Vous pourrez ensuite référencer des champs dans les fichiers du projet importé et remplacer les valeurs des constantes définies dans le projet importé, si celles-ci autorisent le remplacement.
Créer un fichier manifeste de projet
Tout projet qui importe des fichiers d'autres projets doit disposer d'un fichier manifeste de projet. Si votre projet ne comporte pas encore de fichier manifeste, vous pouvez en créer un à l'aide de l'icône + située en haut de l'explorateur de fichiers dans l'IDE Looker.
Pour importer des projets, spécifiez-les dans le fichier manifeste. Vous pouvez spécifier des projets local ou à distance, comme décrit dans les sections suivantes.
Importer des projets locaux
Votre administrateur Looker doit activer la fonctionnalité expérimentale Importation de projet locale pour que les fichiers locaux puissent être importés dans votre projet.
L'importation de projets locaux ne peut être utilisée que si le projet importé est présent sur la même instance Looker. Il est également recommandé aux développeurs de disposer des autorisations de modèle pour les modèles importés du projet. Si vos développeurs disposent d'autorisations pour le modèle importé, la gestion des versions est dynamique, ce qui signifie que les modifications apportées au projet importé ont un impact immédiat sur le projet qui l'importe. Les développeurs peuvent ainsi valider les modifications dans les deux projets avant de passer en production. De plus, pour les développeurs disposant d'autorisations de modèle dans les deux projets, les fichiers de projet importés reflètent l'état du mode de développement du développeur. Ainsi, si le développeur est en mode de développement, l'IDE Looker affiche le mode de développement des fichiers du projet importé. Si le développeur est en mode production, l'IDE Looker affiche le mode production du projet importé.
Pour importer localement, spécifiez le projet actuel à l'aide du paramètre project_name
. Utilisez un ou plusieurs paramètres local_dependency
pour spécifier le ou les projets à importer:
# This project
project_name: "my_project"
# The project to import
local_dependency: {
project: "my_other_project"
}
Dans les scénarios suivants, il est préférable d'utiliser l'importation de projet à distance plutôt que l'importation de projets en local:
- Vos développeurs ne disposent pas des autorisations nécessaires dans les modèles importés du projet. Dans ce cas, Looker crée un clone du mode de production du projet importé et affiche cette version statique des fichiers dans l'IDE. Cette version statique n'affiche jamais la version en mode développement des fichiers. Elle peut aussi être obsolète par rapport au mode production actuel sans avertir le développeur. Il est préférable d'utiliser l'importation de produits à distance et de fournir un
ref
qui spécifie une branche Git ou une version Git dans le projet distant. Dans ce cas, Looker détecte automatiquement les nouveaux commits dans le projet distant afin que vos développeurs soient avertis et puissent importer la dernière version des fichiers de projet distant. - Vos développeurs doivent toujours travailler avec la version de production d'un projet importé.
- Vos développeurs doivent travailler avec une version statique des fichiers importés du projet.
Importer des projets distants
Dans une importation à distance, le projet importé n'a pas besoin d'être sur la même instance. Le projet est importé via son dépôt Git distant.
Pour importer un dépôt distant, utilisez le paramètre remote_dependency
afin de fournir les informations concernant le dépôt distant. Le paramètre remote_dependency
utilise les informations et sous-paramètres suivants:
- Nom du projet importé. Vous pouvez utiliser le nom de votre choix. Dans l'exemple ci-dessous, le nom du projet est
ga_360_block
. Vous l'utilisez dans les instructionsinclude
pour référencer les fichiers importés dans les projets LookML. Ce nom est également utilisé comme nom de dossier dans le dossierimported_projects
de l'IDE Looker. - Sous-paramètre
url
, dans lequel vous spécifiez l'adresse du dépôt Git externe. Utilisez l'URL principale du dépôt. - Sous-paramètre
ref
, dans lequel vous spécifiez une branche Git, un tag de version Git ou l'algorithme SHA d'un commit dans le dépôt Git. Vous pouvez spécifier un commit SHA si vous souhaitez utiliser la gestion des versions statique, de sorte que les modifications apportées au projet importé ne soient pas automatiquement répercutées dans votre projet (une bonne option pour les blocs Looker). Vous pouvez également spécifier une branche Git ou un tag de version Git si vous souhaitez que Looker détecte automatiquement les nouveaux commits dans le projet distant. Pour en savoir plus, consultez la section Détecter automatiquement les nouvelles versions d'un projet distant de cette page. - Le sous-paramètre facultatif
override_constant
est un sous-paramètre facultatif qui permet de remplacer la valeur d'une constante définie dans un projet importé.
Voici un exemple de paramètre remote_dependency
dans un fichier manifeste de projet. Cet exemple utilise une connexion HTTPS:
remote_dependency: ga360_block {
url: "https://github.com/llooker/google_ga360"
ref: "master"
override_constant: connection {
value: "importing_project_connection"
}
}
Vous pouvez également utiliser SSH:
remote_dependency: ga360_block {
url: "git@github.com:llooker/google_ga360.git"
ref: "master"
override_constant: connection {
value: "importing_project_connection"
}
}
Une fois la dépendance distante ajoutée, vous devrez peut-être configurer les identifiants d'importation pour le projet distant. Consultez la section Configurer les identifiants d'authentification pour les dépôts distants privés de cette page.
Détecter automatiquement les nouvelles versions d'un projet distant
Looker peut détecter automatiquement les nouveaux commits dans le projet distant si vous spécifiez une branche Git ou un tag de version Git dans le sous-paramètre ref
de remote_dependency
dans votre fichier manifeste.
Par exemple, voici une dépendance distante où la branche master
est spécifiée dans le sous-paramètre ref
:
remote_dependency: exchange_rate {
url: "https://github.com/llooker/datablocks-exchangerate.git"
ref: "master"
}
Ensuite, lorsque la branche master
est mise à jour avec de nouveaux commits, Looker détecte automatiquement les modifications.
Voici un exemple dans lequel la balise de version v1.0
est spécifiée:
remote_dependency: e_faa_original {
url: "https://github.com/llooker/google_ga360"
ref: "v1.0"
}
Quel que soit le type de ref
spécifié, même un commit SHA, l'IDE affiche le bouton Update Dependencies (Mettre à jour les dépendances) lorsque vous ajoutez un paramètre remote_dependency
à votre projet:
Cliquez sur le bouton pour importer les fichiers du projet distant. S'il s'agit de la première dépendance à distance que vous avez ajoutée à votre projet, la mise à jour des dépendances invitera également Looker à créer un fichier de verrouillage du fichier manifeste. Looker utilise le fichier de verrouillage du fichier manifeste pour suivre la version du ou des projets distants.
Si vous spécifiez une branche Git ou un tag de version Git dans le sous-paramètre ref
, Looker vérifie les nouveaux commits chaque fois que l'IDE Looker est actualisé, ce qui se produit lorsqu'un développeur Looker passe en mode développement, effectue une action Git dans l'IDE ou actualise le navigateur.
En cas de nouveaux commits, Looker affichera l'option Update Dependencies (Mettre à jour les dépendances) dans le panneau des actions Git de l'IDE:
Sélectionnez l'option Mettre à jour les dépendances pour importer les derniers fichiers de projet distants dans votre projet.
Une fois que vous avez les derniers fichiers, vous pouvez valider votre LookML pour vérifier que toutes les références de votre projet fonctionnent avec les fichiers de projet distant mis à jour. Vous pouvez ensuite corriger les références défaillantes et déployer vos modifications sans entraîner de temps d'arrêt pour vos utilisateurs.
Fichier de verrouillage du fichier manifeste
Looker utilise le fichier de verrouillage du fichier manifeste pour suivre les versions des projets importés à distance:
Les développeurs Looker n'ont pas besoin de créer ni de modifier le fichier manifeste de verrouillage, car ils sont gérés automatiquement par Looker.
Le fichier manifeste de verrouillage affiche chaque projet distant, représenté par une entrée remote_dependency
avec les sous-paramètres url
et ref
:
- Le paramètre
remote_dependency
indique le nom du projet distant spécifié par un développeur Looker dans le fichier manifeste. - Le sous-paramètre
url
indique l'adresse du dépôt Git externe spécifié par un développeur Looker dans le fichier manifeste. - Le sous-paramètre
ref
indique la version du projet (indiquée par un commit SHA) que Looker utilise dans votre projet :- Si le projet distant a été défini dans le fichier manifeste avec un élément
ref
d'une branche Git ou un tag de publication Git, le paramètreref
indique la version des fichiers (ID de commit du projet distant) que votre projet utilise actuellement. Si le projet distant comporte de nouveaux commits, Looker affiche le bouton Update Dependencies (Mettre à jour les dépendances) afin que vous puissiez importer les derniers fichiers du projet distant. La valeurref
du fichier manifeste de verrouillage sera alors mise à jour pour afficher le dernier SHA de commit pour cette branche ou ce tag de version. - Si le projet distant a été défini dans le fichier manifeste avec un
ref
d'un SHA de commit spécifique, le paramètreref
du fichier manifeste de verrouillage sera le même SHA de commit.
- Si le projet distant a été défini dans le fichier manifeste avec un élément
Configurer des identifiants d'authentification pour des dépôts distants privés
Le paramètre Identifiants d'importation affiche la liste des URL pour chaque dépôt distant défini dans le fichier manifeste du projet, le type d'authentification utilisé pour le dépôt (https
ou ssh
) et indique si Looker peut s'y connecter.
Ajouter des identifiants d'authentification
Pour ajouter des identifiants d'authentification à un dépôt:
Pointez sur le nom d'un dépôt pour afficher les boutons Tester et Configurer, puis cliquez sur Configurer.
Looker affiche une boîte de dialogue vous permettant de configurer les identifiants du dépôt distant. La boîte de dialogue indique le type d'identifiants requis pour ce dépôt.
Si le dépôt nécessite un nom d'utilisateur et un mot de passe (ou un jeton d'accès personnel) pour l'authentification, saisissez votre nom d'utilisateur et votre mot de passe ou votre jeton, puis cliquez sur Enregistrer les modifications.
Si le dépôt nécessite une clé SSH, comme dans cet exemple ci-dessus, Looker affiche une boîte de dialogue affichant votre clé SSH locale. Cliquez sur Copier la clé pour copier la clé SSH dans le presse-papiers, puis ajoutez-la à la liste de clés de votre dépôt.
Si votre projet distant est un dépôt LookML, il est possible qu'il existe déjà des clés SSH, telles qu'une clé SSH ajoutée au dépôt lorsque son projet LookML a été initialement connecté à Git. Conservez les clés SSH existantes lorsque vous ajoutez votre nouvelle clé SSH au dépôt.
Après avoir enregistré les identifiants, cliquez sur le bouton Tester pour tester l'accès de Looker au dépôt:
Une fois que vous avez réussi les tests de connexion et que vous vous êtes connecté au dépôt, la section Import Credentials (Importer les identifiants) affiche une coche verte à côté du nom du dépôt.
Modifier les identifiants d'authentification
Pour modifier les identifiants d'authentification d'un dépôt:
Pointez sur un dépôt déjà configuré pour afficher les boutons Tester et Modifier, puis cliquez sur Modifier :
Si le dépôt nécessite un nom d'utilisateur et un mot de passe (ou un jeton d'accès personnel) pour l'authentification, cliquez sur Effacer les identifiants, puis, dans la fenêtre de confirmation, cliquez sur Oui, effacer les identifiants.
Saisissez les nouveaux identifiants dans le pop-up Configure Git Authentication (Configurer l'authentification Git), puis cliquez sur Save Changes (Enregistrer les modifications).
Afficher les fichiers d'un projet importé
L'IDE Looker affiche les fichiers de projet importés dans le dossier imported_projects
du volet de navigation de gauche. Vous pouvez cliquer sur un fichier de projet importé pour afficher son contenu:
Les fichiers de projets locaux et de projets distants sont répertoriés dans le dossier imported_projects
.
Étant donné qu'ils ne peuvent pas être modifiés, les fichiers de projets importés ne sont pas visibles lorsque vous modifiez de manière groupée des fichiers dans l'IDE.
Vous pouvez également afficher les objets de fichiers de projet importés qui sont inclus dans le projet actif à partir du navigateur d'objets. Accédez au navigateur d'objets depuis la barre de navigation de l'IDE Looker:
De plus, les utilisateurs disposant de l'autorisation develop
peuvent utiliser le panneau des métadonnées pour afficher des informations sur les objets de projets importés, y compris des liens permettant d'accéder au fichier importé dans lequel l'objet est défini. Pour en savoir plus, consultez la page de documentation Métadonnées pour les objets LookML.
Inclure les fichiers d'un projet importé
Le paramètre include
d'un fichier de modèle spécifie les fichiers de projet qui seront disponibles pour ce modèle. Une fois que vous avez spécifié un projet importé local ou à distance dans le fichier manifeste, vous pouvez utiliser le paramètre include
dans un fichier de modèle pour spécifier les fichiers du projet importé. Seuls les fichiers dont le projet est répertorié dans le fichier manifeste peuvent être inclus.
Pour include
un fichier à partir d'un autre projet, utilisez le nom du fichier avec deux barres obliques (//
) et le nom du projet importé. Suivez le nom du projet importé avec une seule barre oblique (/
) et le chemin d'accès complet au fichier que vous souhaitez inclure.
Par exemple, ces commandes include
indiquent le fichier de vue users
du projet importé e_flights
et la vue orders
du projet importé e_commerce
:
include: "//e_flights/views/users.view.lkml"
include: "//e_commerce/public/orders.view.lkml"
Consultez la section Syntaxe du chemin d'accès de la page de documentation Utiliser des dossiers dans l'IDE pour en savoir plus sur la spécification des chemins d'accès avec les dossiers IDE activés.
Vous pouvez utiliser des caractères génériques pour inclure plusieurs fichiers. Par exemple, pour inclure tous les fichiers de vue dans le répertoire /views/
du projet importé e_flights
:
include: "//e_flights/views/*.view"
De plus, vous pouvez utiliser des caractères génériques pour limiter la portée à des niveaux de répertoire spécifiques ou à des répertoires récursifs dans un projet importé:
include: "//e_flights/**/*.view.lkml"
include: "//e_commerce/*/*.view.lkml"
Consultez la section Exemples génériques de la page de documentation Utiliser des dossiers dans l'IDE pour en savoir plus sur l'utilisation des caractères génériques lorsque les dossiers IDE sont activés.
Inclure des fichiers de modèle
Vous ne pouvez pas inclure de fichier de modèle d'un autre projet. Si vous souhaitez les réutiliser, affiner ou étendre l'ensemble des projets, vous pouvez créer un fichier Explorer distinct dans le projet importé, puis inclure ce fichier Explorer. Pour en savoir plus, consultez la section Inclure des explorations dans un modèle de la page de documentation sur les paramètres include
.
Inclure les fichiers contenant d'autres fichiers
Lorsque vous incluez un fichier qui contient d'autres fichiers, tous les problèmes sont résolus avant que le fichier ne soit transféré vers le projet suivant.
Par exemple, si vous importez un fichier (A
) dans un autre projet (proj_A
) et que le fichier importé contient un paramètre include
incluant le fichier B
du projet proj_B
, le fichier B
sera inclus dans le fichier A
avant que le fichier A
ne soit importé dans le projet actuel.
Importer des fichiers de données
Les fichiers stockés dans la section Données d'un projet ne sont pas importés. Pour référencer un fichier de données à partir d'un projet importé (dans le paramètre map_layer
, par exemple), utilisez le chemin d'accès complet et le nom du fichier. Exemple :
map_layer: json_from_imported_project {
file: "//path_to_imported_project/folder/filename.topojson"
...
}
Référencer des fichiers à partir d'un projet importé
Après avoir importé un fichier de vue dans votre projet, vous pouvez utiliser la syntaxe ${view_name.field_name}
pour référencer les champs de la vue importée comme si le fichier de vue était natif pour ce projet. Par exemple, supposons que vous avez importé le projet ga_360_block
dans le fichier manifeste de votre projet et que votre fichier de modèle contient l'instruction include
suivante:
include: "//ga_360_block/ga_block.view"
Vous devez utiliser la syntaxe ${ga_block.hits_total}
pour référencer le champ hits_total
dans la vue ga_block
incluse.
Utiliser des constantes dans les fichiers d'un projet importé
Les constantes LookML vous permettent de définir une valeur dans le fichier manifeste de votre projet qui peut être réutilisée dans l'ensemble du projet. Le sous-paramètre export
du paramètre constant
indique si une valeur de constante peut être remplacée lorsque des fichiers faisant référence à cette constante sont importés dans un autre projet.
Le paramètre export
peut avoir les valeurs suivantes:
none
: valeur par défaut pourexport
. La valeur de la constante ne peut pas être remplacée dans votre projet d'importation. Le projet d'importation utilise la valeur constante spécifiée dans le fichier manifeste du projet importé.override_optional
: la valeur de la constante peut éventuellement être remplacée dans votre projet d'importation. Si aucune valeur n'est indiquée dans le fichier manifeste du projet d'importation, la valeur d'origine du projet importé est utilisée.override_required
: le projet d'importation doit remplacer la valeur constante initialement spécifiée dans le fichier manifeste du projet importé. Si une nouvelle valeur constante n'est pas fournie dans le projet d'importation, Looker affiche une erreur.
Lorsque vous importez des fichiers qui font référence à une constante dans votre projet, vous pouvez utiliser le sous-paramètre override_constant
de local_dependency
ou remote_dependency
dans le fichier manifeste de votre projet afin de fournir une nouvelle valeur pour cette constante, à condition que export
soit défini sur override_optional
ou override_required
dans le projet d'origine. Lorsque vous remplacez la valeur d'une constante d'un projet importé, celui-ci utilise la valeur que vous avez spécifiée avec le paramètre override_constant
.
Les constantes ne sont disponibles que pour les fichiers du projet dans lequel elles ont été définies à l'origine. Par conséquent, les constantes définies dans un projet dont vous avez importé les fichiers ne peuvent être utilisées que par les fichiers importés, et non par les fichiers définis dans le projet d'importation.
Si vous souhaitez utiliser une constante dans les fichiers du projet d'importation, vous devez utiliser le paramètre
constant
pour définir une nouvelle constante dans le fichier manifeste du projet d'importation. Une constante définie de cette manière ne sera disponible que pour les fichiers définis dans le projet d'importation.
Par exemple, supposons que vous gériez plusieurs bases de données sur une seule instance Looker, avec un projet distinct pour chaque base de données. Dans cet exemple, supposons également que les schémas de données sont identiques pour chaque base de données, et que votre objectif est de définir une analyse une fois et de l'appliquer à chaque ensemble de données.
Dans cet exemple, supposons que proj_core
est le projet de base dans lequel vous avez défini des vues que vous souhaitez importer dans d'autres projets. De plus, l'une des vues que vous souhaitez importer est la vue orders
, qui est définie comme suit:
view: orders {
sql_table_name: "@{schema_name}.orders"
}
Le schéma sur lequel la vue orders
est basée est spécifié dans le paramètre sql_table_name
à l'aide de la constante schema_name
, qui est définie dans le fichier manifeste proj_core
. Dans l'exemple ci-dessous, comme la constante schema_name
est définie sur export: override_required
, tout projet qui importe schema_name
doit remplacer sa valeur à l'aide du paramètre override_constant
:
constant: schema_name {
value: "proj_core_schema"
export: override_required
}
Pour cet exemple, supposons que vous souhaitiez importer la vue orders
dans un projet local appelé proj_a
. Il existe également une table appelée orders
dans la base de données pour proj_a
, avec une structure identique à celle de la table orders
dans le projet de base, proj_core
.
Étant donné que proj_core
et proj_a
se trouvent sur la même instance, vous pouvez importer la vue orders
dans proj_a
à l'aide de local_dependency
. À l'aide du sous-paramètre override_constant
de local_dependency
, vous pouvez ensuite mettre à jour la constante schema_name
pour qu'elle pointe vers le schéma proj_a_schema
dans le fichier manifeste de proj_a
:
project_name: "proj_a"
local_dependency: {
project: "proj_core"
override_constant: schema_name {
value: "proj_a_schema"
}
}
Dans cet exemple, la constante schema_name
étant définie sur export: override_required
dans project_core
, Looker affichera une erreur si vous ne remplacez pas sa valeur dans proj_a
(le projet d'importation).
Remplacer la constante schema_name
dans proj_a
vous permet d'utiliser les champs que vous avez définis dans la vue orders
dans proj_core
, plutôt que de créer un fichier de vue et de définir vos champs à partir de zéro. Dans cet exemple, la vue orders
correspond à une table différente pour chaque projet:
- Dans
proj_core
, la vueorders
est basée sur la tableproj_core_schema.orders
de votre base de données. - Dans
proj_a
, la vueorders
est basée sur la tableproj_a_schema.orders
de votre base de données.