La función Importación de proyectos locales es una función experimental de Labs que importa archivos de proyectos locales de LookML. Las funciones experimentales no están completamente desarrolladas y pueden cambiar o quitarse de manera significativa.
Actualmente, la importación de archivos desde proyectos remotos o locales de LookML no es compatible con la localización de modelos.
Puedes importar archivos de otros proyectos de LookML y repositorios externos a tu proyecto actual. Esto te permite usar archivos de modelo, ver archivos y otros archivos en más de un proyecto.
Existen varios casos de uso para esto. Estos son algunos ejemplos:
Realizar compilaciones sobre un bloque de Looker instalado sin tener que realizar cambios directos Si Looker realiza cambios en el bloque, puede incorporarlos con facilidad, ya que todo el LookML que agregó se guarda en un repositorio independiente.
Mantener un proyecto base que se genere automáticamente en función del esquema de la base de datos Puede colocar todas sus dimensiones, medidas, etc. personalizadas, en un proyecto separado que importe todo el LookML del proyecto generado automáticamente. Puedes regenerar con regularidad el proyecto base a medida que cambia el esquema de la base de datos sin reemplazar todo tu LookML personalizado.
Encapsular objetos compartidos en un solo proyecto y, luego, importarlos a otros proyectos Por ejemplo, si tienes una tabla que es común en varias bases de datos, puedes ubicarla en un proyecto y mantenerla en ese lugar. Luego, haz que otros proyectos la usen mediante la importación de la tabla a esos proyectos.
Para importar archivos de otro proyecto, realiza las siguientes tareas:
- Crea un archivo de manifiesto del proyecto.
- Especifica los proyectos locales o remotos que deseas importar.
- Visualiza archivos de un proyecto importado.
- Incluye archivos de un proyecto importado.
Luego, podrás hacer referencia a los campos de los archivos importados del proyecto y anular los valores de las constantes definidas en el proyecto importado si las constantes permiten la anulación.
Cómo crear un archivo de manifiesto del proyecto
Cualquier proyecto que importe archivos de otros proyectos debe tener un archivo de manifiesto de proyecto. Si tu proyecto todavía no tiene un archivo de manifiesto, puedes crear uno desde el ícono + ubicado en la parte superior del navegador de archivos del IDE de Looker.
Para importar proyectos, debes especificarlos en el manifiesto. Puedes especificar proyectos locales o remotos, como se describe en las siguientes secciones.
Importa proyectos locales
Tu administrador de Looker debe habilitar la función Importación de proyectos locales para permitir que se importen archivos locales a tu proyecto.
La importación de proyectos locales solo se puede usar si el proyecto importado está presente en la misma instancia de Looker. También se recomienda que los programadores tengan permisos de modelo para los modelos importados. Si sus desarrolladores tienen permisos de modelo en el proyecto importado, el control de versiones será dinámico, lo que significa que los cambios en el proyecto importado afectarán inmediatamente al proyecto que lo importa. Esto permite que los desarrolladores validen los cambios en ambos proyectos antes de pasar a producción. Además, en el caso de los desarrolladores con permisos de modelo en ambos proyectos, los archivos importados del proyecto reflejarán el estado del modo de desarrollo del desarrollador. Por lo tanto, si el desarrollador está en modo de desarrollo, el IDE de Looker mostrará el modo de desarrollo de los archivos importados del proyecto. Si el desarrollador está en modo de producción, el IDE de Looker mostrará el modo de producción del proyecto importado.
Para importar de manera local, usa el parámetro project_name
a fin de especificar el proyecto actual. Usa uno o más parámetros local_dependency
para especificar el proyecto o los proyectos que se importarán:
# This project
project_name: "my_project"
# The project to import
local_dependency: {
project: "my_other_project"
}
En las siguientes situaciones, debes usar la importación remota de proyectos en lugar de la importación local:
- Los programadores no tienen permisos de modelo en los modelos importados del proyecto. Cuando este es el caso, Looker realiza una clonación del modo de producción del proyecto importado y muestra esa versión estática de los archivos en el IDE. Esta versión estática nunca mostrará la versión del modo de desarrollo de los archivos y, además, podría estar desactualizada con el modo de producción actual sin alertar al desarrollador. Sería mejor usar la importación remota de productos y proporcionar un
ref
que especifique una rama de Git o una versión de Git en el proyecto remoto. Si lo haces, Looker detectará automáticamente las confirmaciones nuevas del proyecto remoto para que tus desarrolladores reciban una alerta y puedan incorporar la versión más reciente de los archivos del proyecto remoto. - Tus desarrolladores siempre deben trabajar con la versión de producción de un proyecto importado.
- Los desarrolladores deben trabajar con una versión estática de los archivos importados del proyecto.
Importa proyectos remotos
En una importación remota, no es necesario que el proyecto importado esté en la misma instancia. Más bien, el proyecto se importa a través de su repositorio remoto de Git.
Para importar un repositorio remoto, usa el parámetro remote_dependency
a fin de proporcionar la información correspondiente. El parámetro remote_dependency
toma la siguiente información y los subparámetros:
- El nombre del proyecto importado, que puede ser el que desees. En el siguiente ejemplo, el nombre del proyecto es
ga_360_block
. Usa este nombre en las declaracionesinclude
para hacer referencia a los archivos importados en proyectos de LookML. El nombre también se usa como nombre de la carpeta en la carpetaimported_projects
del IDE de Looker. - El subparámetro
url
, en el que se especifica la dirección del repositorio de Git externo Usa la URL principal del repositorio. - El subparámetro
ref
, en el que se especifica una rama de Git, una etiqueta de lanzamiento de Git o el SHA de una confirmación en el repositorio de Git. Puedes especificar un SHA de confirmación si deseas un control de versiones estático, de modo que los cambios en el proyecto importado no se reflejen automáticamente en tu proyecto (esta es una buena opción para los bloques de Looker). O bien, puedes especificar una rama de Git o una etiqueta de lanzamiento de Git si quieres que Looker detecte automáticamente las confirmaciones nuevas en el proyecto remoto. Para obtener más información, consulta la sección Cómo detectar automáticamente versiones nuevas de un proyecto remoto. - El subparámetro
override_constant
, que es un subparámetro opcional que te permite anular el valor de una constante que se definió en un proyecto importado.
Aquí hay un ejemplo de un parámetro remote_dependency
en un archivo de manifiesto del proyecto. En este ejemplo, se usa una conexión HTTPS:
remote_dependency: ga360_block {
url: "https://github.com/llooker/google_ga360"
ref: "master"
override_constant: connection {
value: "importing_project_connection"
}
}
También puedes usar SSH:
remote_dependency: ga360_block {
url: "git@github.com:llooker/google_ga360.git"
ref: "master"
override_constant: connection {
value: "importing_project_connection"
}
}
Una vez que agregues la dependencia remota, es posible que debas configurar las credenciales de importación del proyecto remoto. Consulta la sección Configura credenciales de autenticación para repositorios remotos privados en esta página.
Detecta automáticamente versiones nuevas de un proyecto remoto
Puedes hacer que Looker detecte automáticamente nuevas confirmaciones en el proyecto remoto si especificas una rama de Git o una etiqueta de lanzamiento de Git en el subparámetro ref
de remote_dependency
en tu archivo de manifiesto.
Por ejemplo, esta es una dependencia remota en la que la rama master
se especifica en el subparámetro ref
:
remote_dependency: exchange_rate {
url: "https://github.com/llooker/datablocks-exchangerate.git"
ref: "master"
}
Luego, cuando la rama master
se actualice con confirmaciones nuevas, Looker detectará automáticamente los cambios.
Este es un ejemplo en el que se especifica la etiqueta de lanzamiento v1.0
:
remote_dependency: e_faa_original {
url: "https://github.com/llooker/google_ga360"
ref: "v1.0"
}
Independientemente del tipo de ref
que especifiques, incluso un SHA de confirmación, el IDE mostrará el botón Update Dependencies cuando agregues un parámetro remote_dependency
a tu proyecto:
Haz clic en el botón para incorporar los archivos del proyecto remoto. Si esta es la primera dependencia remota que agregaste a tu proyecto, actualizar las dependencias también hará que Looker cree un archivo de bloqueo de manifiesto. Looker usa el archivo de bloqueo de manifiesto para realizar un seguimiento de la versión de los proyectos remotos.
Si especificas una rama de Git o una etiqueta de actualización de Git en el subparámetro ref
, Looker buscará confirmaciones nuevas cada vez que el IDE de Looker se actualice, lo que sucede cuando un desarrollador de Looker ingresa en modo de desarrollo, realiza una acción de Git en el IDE o actualiza el navegador.
Si hay confirmaciones nuevas, Looker mostrará la opción Update Dependencies en el panel de acciones de Git del IDE:
Selecciona la opción Update Dependencies (Actualizar dependencias) para incorporar los últimos archivos del proyecto remoto en tu proyecto.
Una vez que tengas los archivos más recientes, puedes validar el LookML para verificar que todas las referencias del proyecto funcionen con los archivos del proyecto remotos actualizados. Luego, puede corregir las referencias dañadas e implementar los cambios sin tiempo de inactividad para sus usuarios.
Archivo de bloqueo del manifiesto
Looker usa el archivo de bloqueo de manifiesto para hacer un seguimiento de las versiones de los proyectos importados de forma remota:
Los desarrolladores de Looker no necesitan crear ni editar el archivo de bloqueo de manifiesto, ya que Looker los administra automáticamente.
El archivo de bloqueo de manifiesto muestra cada proyecto remoto, representado por una entrada remote_dependency
con los subparámetros url
y ref
:
- El parámetro
remote_dependency
indica el nombre del proyecto remoto que un desarrollador de Looker especificó en el archivo de manifiesto. - El subparámetro
url
indica la dirección del repositorio de Git externo que un desarrollador de Looker especificó en el archivo de manifiesto. - El subparámetro
ref
muestra la versión del proyecto (indicada por un SHA de confirmación) que Looker usa en su proyecto:- Si el proyecto remoto se definió en el archivo de manifiesto con un
ref
de una rama de Git o una etiqueta de lanzamiento de Git, el parámetroref
muestra la versión de los archivos (el SHA de confirmación del proyecto remoto) que usa el proyecto actualmente. Si hay confirmaciones nuevas en el proyecto remoto, Looker mostrará el botón Actualizar dependencias en el IDE para que puedas incorporar los últimos archivos del proyecto remoto. El valorref
en el archivo de bloqueo de manifiesto se actualizará para mostrar el último SHA de confirmación para esa rama o etiqueta de lanzamiento. - Si el proyecto remoto se definió en el archivo de manifiesto con un
ref
de un SHA de confirmación específico, el parámetroref
en el archivo de bloqueo del manifiesto será el mismo SHA de confirmación.
- Si el proyecto remoto se definió en el archivo de manifiesto con un
Configura credenciales de autenticación para repositorios remotos privados
La configuración de Import Credentials muestra una lista de las URL de cada repositorio remoto que se definió en el archivo de manifiesto del proyecto, el tipo de autenticación que se usó para el repositorio (https
o ssh
) y si Looker puede conectarse correctamente al repositorio.
Agrega credenciales de autenticación
Para agregar credenciales de autenticación a un repositorio, haz lo siguiente:
Desplaza el cursor sobre el nombre de un repositorio para mostrar los botones Test y Configure, y haz clic en Configure.
Looker muestra un cuadro de diálogo que le permite configurar las credenciales para el repositorio remoto. El cuadro de diálogo indicará el tipo de credenciales requeridas para ese repositorio en particular.
Si el repositorio requiere un nombre de usuario y una contraseña (o un token de acceso personal) para la autenticación, ingresa tu nombre de usuario y contraseña o token, y haz clic en Guardar cambios.
Si el repositorio requiere una Llave SSH, como en este ejemplo anterior, Looker muestra un cuadro de diálogo que muestra su Llave SSH local. Haz clic en Copiar clave para copiar la llave SSH en tu portapapeles y agregarla a tu lista de claves del repositorio.
Si tu proyecto remoto es un repositorio de LookML, es posible que ya haya llaves SSH existentes, como una clave SSH que se agregó al repositorio cuando su proyecto de LookML se conectó a Git. Deja cualquier Llave SSH existente en su lugar cuando agregues tu nueva Llave SSH al repositorio.
Después de guardar las credenciales, haz clic en el botón Probar para probar el acceso de Looker al repositorio:
Una vez que pases las pruebas de conexión y te conectes al repositorio, la sección Import Credentials (Importar credenciales) muestra una marca de verificación verde junto al nombre del repositorio.
Edita las credenciales de autenticación
Para editar las credenciales de autenticación de un repositorio, haz lo siguiente:
Desplácese sobre un repositorio que ya configuró credenciales de autenticación para mostrar los botones Probar y Editar y haga clic en Editar:
Si el repositorio requiere un nombre de usuario y una contraseña (o un token de acceso personal) para la autenticación, haga clic en Borrar credenciales y, en la ventana emergente de confirmación, haga clic en Sí, borrar credenciales.
Ingrese las credenciales nuevas en la ventana emergente Configure Git Authentication y haga clic en Save Changes.
Visualiza archivos de un proyecto importado
El IDE de Looker muestra los archivos de proyecto importados en la carpeta imported_projects
del panel de navegación izquierdo. Puedes hacer clic en un archivo de proyecto importado para ver su contenido:
Los archivos de proyectos locales y proyectos remotos se enumeran en la carpeta imported_projects
.
Dado que no se pueden editar, los archivos de proyectos importados no son visibles cuando editas archivos de forma masiva en el IDE.
También puedes ver objetos de archivos de proyecto importados que se incluyen en el proyecto activo desde el navegador de objetos. Accede al navegador de objetos desde la barra de navegación del IDE de Looker:
Además, los usuarios con el permiso develop
pueden usar el panel de metadatos para ver información sobre los objetos de proyectos importados, incluidos los vínculos a fin de navegar al archivo importado donde se define el objeto. Consulta la página de documentación Metadatos para objetos LookML a fin de obtener más información.
Incluir archivos de un proyecto importado
El parámetro include
en un archivo de modelo especifica los archivos del proyecto que estarán disponibles para ese modelo. Una vez que especifiques un proyecto importado local o remoto en el archivo de manifiesto, puedes usar el parámetro include
en un archivo de modelo para especificar archivos del proyecto importado. Solo se pueden incluir los archivos cuyo proyecto aparece en el archivo de manifiesto.
Para include
un archivo de otro proyecto, usa el nombre del archivo con dos barras diagonales (//
) y el nombre del proyecto importado. Sigue el nombre del proyecto importado con una sola barra diagonal (/
) y la ruta de acceso completa al archivo que deseas incluir.
Por ejemplo, estos comandos include
indican el archivo de vista users
del proyecto importado e_flights
y la vista orders
del proyecto importado e_commerce
:
include: "//e_flights/views/users.view.lkml"
include: "//e_commerce/public/orders.view.lkml"
Consulta la sección Sintaxis de la ruta de acceso de la página de documentación Cómo trabajar con carpetas en el IDE para obtener información sobre cómo especificar rutas con carpetas de IDE habilitadas.
Puedes usar comodines para incluir varios archivos. Por ejemplo, para incluir todos los archivos de vista en el directorio /views/
del proyecto importado e_flights
:
include: "//e_flights/views/*.view"
Además, puedes usar comodines para definir el alcance a niveles de directorio específicos o directorios recurrentes en el proyecto importado:
include: "//e_flights/**/*.view.lkml"
include: "//e_commerce/*/*.view.lkml"
Consulta la sección Ejemplos de comodines de la página de documentación Trabajar con carpetas en el IDE para obtener información sobre el uso de comodines con carpetas IDE habilitadas.
Incluye archivos de modelo
No puedes incluir un archivo de modelo de otro proyecto. En cambio, si desea reutilizar, definir mejor o extender las exploraciones entre proyectos, en el proyecto importado, puede crear un archivo Explorar independiente y, luego, incluirlo en otros proyectos. Consulta la sección Incluye exploraciones en un modelo de la página de documentación del parámetro include
para obtener más información.
Incluidos los archivos que incluyen otros archivos
Cuando incluyes un archivo que incluye otros archivos, todas las inclusiones se resuelven antes de que el archivo se pase al siguiente proyecto que lo incluya.
Por ejemplo, si importas un archivo (A
) de otro proyecto (proj_A
) y tu archivo importado contiene un parámetro include
que incluye el archivo B
del proyecto proj_B
, el archivo B
se incluirá en el archivo A
antes de importar el archivo A
al proyecto actual.
Importa archivos de datos
No se importan los archivos almacenados en la sección Datos de un proyecto. Para hacer referencia a un archivo de datos de un proyecto importado, como en el parámetro map_layer
, usa la ruta de acceso completa y el nombre de archivo. Por ejemplo:
map_layer: json_from_imported_project {
file: "//path_to_imported_project/folder/filename.topojson"
...
}
Haz referencia a archivos de un proyecto importado
Después de importar un archivo de vista a tu proyecto, puedes usar la sintaxis ${view_name.field_name}
para hacer referencia a los campos de la vista importada como si el archivo de vista fuera nativo de ese proyecto. Por ejemplo, supongamos que importaste el proyecto ga_360_block
en el archivo de manifiesto de tu proyecto y que tienes la siguiente declaración include
en tu archivo de modelo:
include: "//ga_360_block/ga_block.view"
Usa la sintaxis ${ga_block.hits_total}
para hacer referencia al campo hits_total
desde la vista ga_block
incluida.
Usa constantes en archivos de un proyecto importado
Las constantes de LookML te permiten definir un valor en el archivo de manifiesto de tu proyecto que se puede reutilizar en tu proyecto. El subparámetro export
del parámetro constant
especifica si un valor de constante se puede anular cuando los archivos que hacen referencia a esa constante se importan a otro proyecto.
El parámetro export
tiene los siguientes valores posibles:
none
: El valor predeterminado paraexport
. El valor de la constante no se puede anular en tu proyecto de importación. El proyecto de importación usa el valor constante especificado en el archivo de manifiesto del proyecto importado.override_optional
: El valor de la constante se puede anular de manera opcional en el proyecto de importación. Si no se proporciona un valor en el archivo de manifiesto del proyecto de importación, se usa el valor original del proyecto importado.override_required
: El proyecto de importación debe anular el valor constante especificado originalmente en el archivo de manifiesto del proyecto importado. Si no se proporciona un valor constante nuevo en el proyecto de importación, Looker mostrará un error.
Cuando importas archivos que hacen referencia a una constante en tu proyecto, puedes usar el subparámetro override_constant
de local_dependency
o remote_dependency
en el archivo de manifiesto de tu proyecto para proporcionar un valor nuevo, siempre y cuando la constante tenga export
establecido en override_optional
o override_required
en el proyecto original. Cuando anulas el valor de una constante de un proyecto importado, tu proyecto usará el valor que especifiques con el parámetro override_constant
.
Las constantes solo están disponibles para los archivos del proyecto en el que se definieron originalmente. Por lo tanto, las constantes que se definen en un proyecto cuyos archivos importaste solo pueden usarlas los archivos importados y no los archivos definidos en el proyecto de importación.
Si deseas usar una constante en los archivos de importación del proyecto, debes usar el parámetro
constant
para definir una nueva constante en el archivo de manifiesto del proyecto de importación. Una constante definida de esta manera estará disponible solo para los archivos definidos en el proyecto de importación.
A modo de ejemplo, supongamos que administras varias bases de datos en una sola instancia de Looker, con un proyecto independiente para cada base de datos. En este ejemplo, supongamos también que los esquemas de datos son idénticos para cada base de datos y que tu objetivo es definir un análisis una vez y aplicarlo a cada conjunto de datos.
En este ejemplo, supongamos que proj_core
es el proyecto base en el que tienes vistas definidas que te gustaría importar a otros proyectos. Además, una de las vistas que deseas importar es la vista orders
, que se define de la siguiente manera:
view: orders {
sql_table_name: "@{schema_name}.orders"
}
El esquema en el que se basa la vista orders
se especifica en el parámetro sql_table_name
mediante la constante schema_name
, que se define en el archivo de manifiesto proj_core
. En el siguiente ejemplo, debido a que la constante schema_name
se establece en export: override_required
, cualquier proyecto que importe schema_name
debe anular su valor mediante el parámetro override_constant
:
constant: schema_name {
value: "proj_core_schema"
export: override_required
}
Para este ejemplo, supongamos que deseas importar la vista orders
a un proyecto local llamado proj_a
. También hay una tabla llamada orders
en la base de datos para proj_a
con una estructura idéntica a la tabla orders
en el proyecto base, proj_core
.
Dado que proj_core
y proj_a
están en la misma instancia, puedes importar la vista orders
a proj_a
mediante local_dependency
. Con el subparámetro override_constant
de local_dependency
, puedes actualizar la constante schema_name
para que apunte al esquema proj_a_schema
en el archivo de manifiesto de proj_a
:
project_name: "proj_a"
local_dependency: {
project: "proj_core"
override_constant: schema_name {
value: "proj_a_schema"
}
}
En este ejemplo, debido a que la constante schema_name
está configurada como export: override_required
en project_core
, Looker mostrará un error si no anulas su valor en proj_a
(el proyecto de importación).
Anular la constante schema_name
en proj_a
te permite usar los campos que definiste en la vista orders
en proj_core
, en lugar de crear un archivo de vista nuevo y definir tus campos desde cero. En este ejemplo, la vista orders
corresponde a una tabla diferente para cada proyecto:
- En
proj_core
, la vistaorders
se basa en la tablaproj_core_schema.orders
de tu base de datos. - En
proj_a
, la vistaorders
se basa en la tablaproj_a_schema.orders
de tu base de datos.