Importa archivos de otros proyectos

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:

  • Compilar sobre un bloque de Looker instalado sin tener que realizar cambios directos en él Si Looker realiza cambios en el bloque, puedes extraerlos con facilidad, ya que todo el LookML que le agregaste se mantiene en un repositorio independiente.

  • Mantener un proyecto base que se genera automáticamente con base en el esquema de la base de datos Puedes colocar todas tus dimensiones y medidas personalizadas, etc., en un proyecto separado que importe todo LookML del proyecto generado automáticamente. Puedes volver a generar 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 varios proyectos Por ejemplo, si tienes una tabla que es común a varias bases de datos, puedes colocar la vista de ella en un proyecto y mantenerla en ese solo lugar. Luego, haz que varios otros proyectos la aprovechen importando la tabla a esos proyectos.

Para importar archivos de otro proyecto, realiza las siguientes tareas:

  1. Crea un archivo de manifiesto del proyecto.
  2. Especifica los proyectos locales o remotos que quieres importar.
  3. Ver archivos de un proyecto importado
  4. Incluye archivos de un proyecto importado.

Luego, podrás hacer referencia a los campos de los archivos del proyecto importado y anular los valores de las constantes definidas en el proyecto importado si las constantes permiten anulación.

Creación de un archivo de manifiesto del proyecto

Cualquier proyecto que importe archivos de otros proyectos debe tener un archivo de manifiesto del proyecto. Si tu proyecto aún no tiene un archivo de manifiesto, puedes crear uno desde el ícono + que se encuentra en la parte superior del navegador de archivos en el IDE de Looker.

Para importar proyectos, especifícalos en el manifiesto. Puedes especificar proyectos locales o remotos, como se describe en las siguientes secciones.

Importa proyectos locales

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 desarrolladores tengan permisos de modelos para los modelos del proyecto importado. Si tus 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 de inmediato el proyecto que lo importa. Esto permite que los desarrolladores validen los cambios en ambos proyectos antes de enviarlos a producción. Además, en el caso de los desarrolladores con permisos de modelo en ambos proyectos, los archivos del proyecto importados reflejarán el estado de Development Mode 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 del proyecto importados. Si el desarrollador está en Modo de producción, el IDE de Looker mostrará el Modo de producción del proyecto importado.

Si quieres importar de forma local, usa el parámetro project_name para especificar el proyecto actual. Usa uno o más parámetros local_dependency para especificar los proyectos que se importarán:

# This project
project_name: "my_project"

# The project to import
local_dependency: {
  project: "my_other_project"
}

Debes usar la importación remota de proyectos en lugar de la importación de proyectos locales en los siguientes casos:

  • Tus desarrolladores no tienen permisos de modelo en los modelos del proyecto importado. Cuando esto sucede, Looker clona el 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ía la versión de Modo de desarrollo de los archivos y también 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 en el proyecto remoto para que tus desarrolladores reciban una alerta y puedan obtener 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.
  • Tus desarrolladores deben trabajar con una versión estática de los archivos del proyecto importado.

Importa proyectos remotos

En una importación remota, el proyecto importado no necesita estar en la misma instancia. En su lugar, el proyecto se importa a través de su repositorio remoto de Git.

Si quieres importar un repositorio remoto, usa el parámetro remote_dependency para proporcionar la información correspondiente. El parámetro remote_dependency toma la información y los subparámetros que se indican a continuación:

  • 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 declaraciones include para hacer referencia a los archivos importados en proyectos de LookML. El nombre también se usa como el nombre de la carpeta en la carpeta imported_projects del IDE de Looker.
  • El subparámetro url, en el que especificas la dirección del repositorio de Git externo Usa la URL principal del repositorio.
  • El subparámetro ref, en el que especificas 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 quieres 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 Bloqueos de Looker). También puedes especificar una rama de Git o una etiqueta de actualización 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 Detección automática de versiones nuevas de un proyecto remoto en esta página.
  • 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

A continuación, se muestra 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 para el proyecto remoto. Consulta la sección Cómo configurar credenciales de autenticación para repositorios remotos privados en esta página.

Detectar automáticamente versiones nuevas de un proyecto remoto

Puedes hacer que Looker detecte automáticamente las confirmaciones nuevas 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"
}

Posteriormente, 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"
}

Sin importar el tipo de valor que especifiques para el parámetro ref, incluso un SHA de confirmación, el IDE mostrará el botón Update Dependencies en la barra de navegación superior del proyecto cuando agregues un parámetro remote_dependency a tu proyecto.

Haz clic en Update Dependencies para incorporar los archivos del proyecto remoto. Si esta es la primera dependencia remota que agregas a tu proyecto, cuando actualices las dependencias, también se solicitará a Looker que cree un archivo de bloqueo de manifiesto. Looker usa el archivo de bloqueo de manifiesto para hacer un seguimiento de la versión de los proyectos remotos.

Si especificas una rama de Git o una etiqueta de versión de Git en el subparámetro ref, Looker verificará si hay confirmaciones nuevas cada vez que se actualice el IDE de Looker, 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 existen confirmaciones nuevas, Looker mostrará la opción Update Dependencies (Actualizar dependencias) en el panel de acciones de Git del IDE.

Selecciona la opción Update Dependencies para incorporar los archivos de proyectos remotos más recientes a tu proyecto.

Una vez que tengas los archivos más recientes, puedes validar tu LookML para verificar que todas las referencias de tu proyecto funcionen con los archivos de proyecto remoto actualizados. Luego, puedes corregir las referencias rotas y, luego, implementar los cambios sin tiempo de inactividad para los usuarios.

Archivo de bloqueo de manifiesto

Looker usa el archivo de bloqueo de manifiesto con el nombre de archivo manifest_lock.lkml para hacer un seguimiento de las versiones de los proyectos importados de forma remota. El archivo de bloqueo de manifiesto aparece en el panel del navegador de archivos del IDE de Looker.

Los desarrolladores de Looker no necesitan crear ni editar el archivo de bloqueo del manifiesto, ya que Looker administra automáticamente los archivos de bloqueo.

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 tu 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ámetro ref muestra qué versión de los archivos (el SHA de confirmación del proyecto remoto) usa actualmente tu proyecto. Si hay confirmaciones nuevas en el proyecto remoto, Looker mostrará el botón Update Dependencies en el IDE para que puedas incorporar los archivos del proyecto remoto más recientes. El valor ref en el archivo de bloqueo de manifiesto se actualizará para mostrar el SHA de confirmación más reciente 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ámetro ref en el archivo de bloqueo de manifiesto será el mismo SHA de confirmación.

Configura credenciales de autenticación para repositorios remotos privados

Si quieres configurar las credenciales de autenticación para los repositorios remotos privados, navega a la página Import Credentials (Importar credenciales) seleccionando Settings en el panel de navegación izquierdo del IDE.

En la configuración de Importar credenciales, se muestra una lista de las URLs 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:

  1. En la página Import Credentials del encabezado URL, coloca el cursor sobre el nombre de un repositorio para mostrar los botones Test y Configure, y haz clic en Configure.

  2. Looker muestra el cuadro de diálogo Configurar la autenticación de Git para que puedas configurar las credenciales del repositorio remoto. El cuadro de diálogo indicará el tipo de credenciales que se requieren 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 clave SSH, como en el ejemplo de cómo usar SSH para importar un proyecto remoto que se explicó anteriormente en esta página, Looker mostrará un cuadro de diálogo con tu clave SSH local. Haz clic en Copiar clave para copiar la clave SSH al portapapeles y agregarla a la lista de claves del repositorio.

  3. Después de guardar las credenciales, haz clic en 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) mostrará 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:

  1. Para que aparezcan los botones Probar y Editar, desplázate sobre un repositorio que ya tenga credenciales de autenticación configuradas y haz clic en Editar.

  2. Si el repositorio requiere un nombre de usuario y una contraseña (o token de acceso personal) para la autenticación, haz clic en Borrar credenciales y, en la ventana emergente de confirmación, haz clic en Sí, borrar credenciales.

  3. Ingresa las credenciales nuevas en la ventana emergente Configurar la autenticación de Git y haz clic en Guardar cambios.

Visualiza archivos de un proyecto importado

El IDE de Looker muestra los archivos de proyectos importados en la carpeta imported_projects del panel de navegación izquierdo. Puedes seleccionar un archivo de proyecto importado para ver su contenido.

Los archivos de proyectos locales y proyectos remotos se enumeran en la carpeta imported_projects.

También puedes ver objetos de archivos de proyectos 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 para navegar al archivo importado en el que se define el objeto. Consulta la página de documentación Metadatos para objetos de LookML a fin de obtener más información.

Incluye archivos de un proyecto importado

El parámetro include de un archivo de modelo especifica los archivos de 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 los archivos del proyecto importado. Solo se pueden incluir archivos cuyo proyecto se indica en el archivo de manifiesto.

Para include un archivo de otro proyecto, usa el nombre de 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 rutas 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 las carpetas del 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, haz lo siguiente:

include: "//e_flights/views/*.view"

Además, puedes usar comodines para definir el alcance de niveles de directorio específicos o directorios recursivos en un 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 Cómo trabajar con carpetas en el IDE para obtener información sobre el uso de comodines con las carpetas del IDE habilitadas.

Incluye archivos de modelo

No puedes incluir un archivo de modelo de otro proyecto. En cambio, si deseas reutilizar, definir mejor o extender las exploraciones entre proyectos, en el proyecto importado, puedes crear un archivo de exploración independiente y, luego, incluirlo en otros proyectos. Consulta la sección Cómo incluir exploraciones en un modelo de la página de documentación del parámetro include para obtener más información.

Incluye archivos que incluyan otros archivos

Cuando incluyes un archivo que incluye otros archivos, todas las inclusiones se resuelven antes de pasar el archivo al siguiente proyecto que lo incluye.

Por ejemplo, si importas un archivo (A) de otro proyecto (proj_A) en el proyecto actual y el 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 que se importe el archivo A al proyecto actual.

Cómo importar 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 del 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 al 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 sentencia include en el archivo de modelo:

include: "//ga_360_block/ga_block.view"

Usarías la sintaxis ${ga_block.hits_total} para hacer referencia al campo hits_total desde la vista ga_block incluida.

Cómo usar constantes en archivos de un proyecto importado

Las constantes de Looker te permiten definir un valor en el archivo de manifiesto de tu proyecto que se puede volver a usar en todo tu proyecto. El subparámetro export del parámetro constant especifica si se puede anular el valor de una constante cuando se importan archivos que hacen referencia a esa constante en otro proyecto.

El parámetro export tiene los siguientes valores posibles:

  • none: Es el valor predeterminado para export. El valor de la constante no se puede anular en el proyecto de importación. El proyecto importado usa el valor constante especificado en el archivo de manifiesto del proyecto importado.
  • override_optional: De manera opcional, el valor de la constante se puede anular en el proyecto de importación. Si no se proporciona un valor en el archivo de manifiesto del proyecto importado, 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 nuevo valor constante en el proyecto de importación, Looker mostrará un error.

Cuando importas archivos que hacen referencia a una constante al proyecto, puedes usar el subparámetro override_constant de local_dependency o remote_dependency en el archivo de manifiesto del proyecto para proporcionar un valor nuevo para esa constante, siempre que export se haya establecido en override_optional o override_required en su proyecto original. Cuando anules el valor de una constante de un proyecto importado, el proyecto usará el valor que especifiques con el parámetro override_constant.

Como ejemplo, supongamos que administras varias bases de datos en una sola instancia de Looker, con un proyecto diferente 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 definiste vistas que deseas 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 con 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 quieres 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.

Como 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 para 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 se establece en 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 nuevo archivo de vista y definir tus campos desde cero. En este ejemplo, la vista orders corresponde a una tabla diferente para cada proyecto:

  • En proj_core, la vista orders se basa en la tabla proj_core_schema.orders de tu base de datos.
  • En proj_a, la vista orders se basa en la tabla proj_a_schema.orders de tu base de datos.