Importar archivos de otros proyectos

Puedes importar archivos de otros proyectos de LookML y repositorios externos a tu proyecto actual, lo que te permite usar archivos de modelo, archivos de vista y otros archivos en más de un proyecto. Los proyectos importados son de solo lectura. Si quieres editar los archivos, debes hacerlo desde su propio proyecto de LookML (o desde otro editor que esté conectado al repositorio de Git de los archivos).

Hay varios casos prácticos para importar archivos a tu proyecto de LookML. A continuación, se muestran algunos ejemplos:

• Crear un bloque de Looker instalado sin tener que hacer cambios directamente en él. Si Looker hace cambios en el bloque, puedes incorporar los cambios porque todo el LookML que hayas añadido se guarda en un repositorio independiente.

• Mantener un proyecto base que se genera automáticamente a partir del esquema de la base de datos. Puede colocar todas sus dimensiones y medidas personalizadas, entre otros elementos, en un proyecto independiente que importe todo el LookML del proyecto generado automáticamente. Puede regenerar periódicamente el proyecto base a medida que cambie el esquema de la base de datos sin sobrescribir todo su LookML personalizado.

• Encapsular objetos compartidos en un solo proyecto e importarlos en varios proyectos. Por ejemplo, si tienes una tabla que es común a varias bases de datos, puedes colocar la vista en un proyecto y mantenerla en ese lugar. Después, haz que varios proyectos más lo utilicen importando la tabla en esos proyectos.

Para importar archivos de otro proyecto, sigue estos pasos:

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

Después, 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 la anulación.

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 aún no tiene un archivo de manifiesto, puedes crear uno desde el icono + situado en la parte superior del explorador de archivos del IDE de Looker.

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

Importar 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 modelo 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 que se hagan en el proyecto importado afectarán inmediatamente al proyecto que lo importe. De esta forma, los desarrolladores pueden validar los cambios en ambos proyectos antes de enviarlos a producción. Además, en el caso de los desarrolladores que tengan permisos de modelo en ambos proyectos, los archivos del proyecto importado reflejarán el estado del modo Desarrollo del desarrollador. Por lo tanto, si el desarrollador está en modo Desarrollo, el IDE de Looker mostrará el modo Desarrollo de los archivos del proyecto importado. Si el desarrollador está en modo Producción, el IDE de Looker mostrará el modo Producción del proyecto importado.

En el archivo de manifiesto, el parámetro project_name especifica el nombre del proyecto actual (Looker rellena automáticamente este parámetro cuando creas el archivo de manifiesto del proyecto). Para importar un proyecto local al proyecto actual, usa uno o varios parámetros local_dependency para especificar el proyecto o los proyectos que quieras importar:

# This project
project_name: "my_project"

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

En los siguientes casos, debes usar la importación de proyectos remotos en lugar de la importación de proyectos locales:

• Tus desarrolladores no tienen permisos de modelo en los modelos del proyecto importado. En ese caso, Looker crea un clon 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ía la versión de los archivos del modo Desarrollo y también podría estar obsoleta con respecto al modo Producción actual sin alertar al desarrollador. Es mejor usar la importación de proyectos remotos y proporcionar un ref que especifique una rama o una versión de Git en el proyecto remoto. Si lo haces, Looker detectará automáticamente las nuevas confirmaciones del proyecto remoto, por lo que tus desarrolladores recibirán una alerta y podrán 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.
• Tus desarrolladores deben trabajar con una versión estática de los archivos del proyecto importado.

Importar proyectos remotos

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

Para importar un repositorio remoto, usa el parámetro remote_dependency para proporcionar la información del repositorio remoto. El parámetro remote_dependency toma la siguiente información y subparámetros:

• El nombre del proyecto importado, que puede ser el que quieras. En el siguiente ejemplo, el nombre del proyecto es ga_360_block. Este nombre se usa en las instrucciones include para hacer referencia a los archivos importados en proyectos de LookML. El nombre también se usa como nombre de la carpeta imported_projects del IDE de Looker.
• El subparámetro url, donde se especifica la dirección del repositorio de Git externo. Usa la URL principal del repositorio.
• El subparámetro ref, donde 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 quieres usar el control de versiones estático para que los cambios del proyecto importado no se reflejen automáticamente en tu proyecto (esta es una buena opción para los bloques de Looker). También puedes especificar una rama de Git o una etiqueta de lanzamiento de Git si quieres que Looker detecte automáticamente las nuevas confirmaciones del proyecto remoto. Consulta más información en la sección Detectar automáticamente nuevas versiones de un proyecto remoto de esta página.
• El subparámetro override_constant, que es un subparámetro opcional que le permite anular el valor de una constante definida en un proyecto importado.

A continuación, se muestra un ejemplo de un parámetro remote_dependency en un archivo de manifiesto de 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 hayas añadido la dependencia remota, puede que tengas que configurar las credenciales de importación del proyecto remoto. Consulta la sección Configurar las credenciales de autenticación de repositorios remotos privados de esta página.

Detectar automáticamente nuevas versiones de un proyecto remoto

Puedes hacer que Looker detecte automáticamente las nuevas confirmaciones del proyecto remoto si especificas una rama de Git o una etiqueta de lanzamiento de Git en el subparámetro ref de remote_dependency en el archivo de manifiesto.

Por ejemplo, aquí tienes una dependencia remota en la que se especifica la rama master 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 nuevas confirmaciones, Looker detectará los cambios automáticamente.

Aquí tienes 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 valor que especifiques para el parámetro ref, incluso un SHA de confirmación, el IDE mostrará el botón Actualizar dependencias en la barra de navegación superior del proyecto cuando añadas un parámetro remote_dependency al proyecto.

Haz clic en Actualizar dependencias para importar los archivos del proyecto remoto. Si es la primera dependencia remota que añades a tu proyecto, al actualizar las dependencias, Looker también te pedirá que crees un archivo de bloqueo de manifiesto. Looker usa el archivo de bloqueo de manifiesto para monitorizar la versión de los proyectos remotos.

Si especifica una rama de Git o una etiqueta de versión de Git en el subparámetro ref, Looker buscará nuevas confirmaciones cada vez que se actualice el IDE de Looker, lo que ocurre cuando un desarrollador de Looker activa el modo Desarrollo, realiza una acción de Git en el IDE o actualiza el navegador.

Si hay nuevas confirmaciones, Looker mostrará la opción Actualizar dependencias en el panel de acciones de Git del IDE.

Selecciona la opción Actualizar dependencias para importar los archivos del proyecto remoto más recientes a tu proyecto.

Una vez que tengas los archivos más recientes, puedes validar tu LookML para comprobar que todas las referencias de tu proyecto funcionan con los archivos del proyecto remoto actualizados. Después, puedes corregir las referencias rotas e implementar los cambios sin que tus usuarios sufran interrupciones.

Archivo de bloqueo de manifiesto

Looker usa el archivo de bloqueo de manifiesto con el nombre de archivo manifest_lock.lkml para monitorizar las versiones de los proyectos importados de forma remota. El archivo de bloqueo de manifiesto se muestra en el panel del explorador de archivos del IDE de Looker.

Los desarrolladores de Looker no tienen que crear ni editar el archivo de bloqueo del manifiesto, ya que Looker gestiona 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 ha especificado en el archivo de manifiesto.
• El subparámetro url indica la dirección del repositorio Git externo que un desarrollador de Looker ha especificado en el archivo de manifiesto.
• El subparámetro ref muestra la versión del proyecto (indicada por un SHA de confirmación) que Looker está usando en tu proyecto:
  • Si el proyecto remoto se ha definido 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 la confirmación del proyecto remoto) está usando tu proyecto. Si hay nuevas confirmaciones en el proyecto remoto, Looker mostrará el botón Actualizar dependencias en el IDE para que puedas incorporar los archivos del proyecto remoto más recientes. El valor ref del archivo de bloqueo del manifiesto se actualizará para mostrar el SHA de la confirmación más reciente de esa rama o etiqueta de lanzamiento.
  • Si el proyecto remoto se ha definido en el archivo de manifiesto con un ref de un SHA de commit específico, el parámetro ref del archivo de bloqueo de manifiesto será el mismo SHA de commit.

Configurar las credenciales de autenticación para repositorios remotos privados

Para configurar las credenciales de autenticación de repositorios remotos privados, ve a la página Import Credentials (Importar credenciales). Para ello, selecciona Settings (Configuración) tune en el panel de navegación de la izquierda del IDE.

La configuración Importar credenciales muestra una lista de las URLs de cada repositorio remoto que se ha definido en el archivo de manifiesto del proyecto, el tipo de autenticación que se usa en el repositorio (https o ssh) y si Looker puede conectarse correctamente al repositorio.

Añadir credenciales de autenticación

Para añadir credenciales de autenticación a un repositorio, sigue estos pasos:

1. En la página Import Credentials (Importar credenciales), en el encabezado URL, coloca el puntero sobre el nombre de un repositorio para que se muestren los botones Test (Probar) y Configure (Configurar), y haz clic en Configure.

   

2. Looker muestra el cuadro de diálogo Configurar autenticación de Git para que puedas configurar las credenciales del repositorio remoto. En el cuadro de diálogo se indicará el tipo de credenciales que se necesitan para ese repositorio concreto.

   • Si el repositorio requiere un nombre de usuario y una contraseña (o un token de acceso personal) para la autenticación, introduce 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 uso de SSH para importar un proyecto remoto que se ha explicado anteriormente en esta página, Looker muestra un cuadro de diálogo que muestra tu clave SSH local. Haz clic en Copiar clave para copiar la clave SSH en el portapapeles y añádela a la lista de claves de tu repositorio.

3. Después de guardar las credenciales, haz clic en Probar para probar el acceso de Looker al repositorio.

   

   Una vez que hayas superado las pruebas de conexión y te hayas conectado al repositorio, en la sección Import Credentials (Importar credenciales) aparecerá una marca de verificación verde junto al nombre del repositorio.

Editar credenciales de autenticación

Para editar las credenciales de autenticación de un repositorio, sigue estos pasos:

1. Para que se muestren los botones Probar y Editar, mantén el puntero sobre un repositorio que ya tenga configuradas las credenciales de autenticación y haz clic en Editar.

   

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

3. Introduce las nuevas credenciales en el cuadro de diálogo Configurar autenticación de Git y haz clic en Guardar cambios.

Ver 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 de la izquierda. Puedes seleccionar un archivo de proyecto importado para ver su contenido.

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

También puedes ver los objetos de los archivos de proyecto importados que se incluyen en el proyecto activo desde el explorador de objetos. Accede al explorador 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 los proyectos importados, incluidos los enlaces para ir al archivo importado en el que se define el objeto. Para obtener más información, consulta la página de documentación Metadatos de objetos LookML.

Incluir 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 haya especificado un proyecto importado local o remoto en el archivo de manifiesto, puede usar el parámetro include en un archivo de modelo para especificar archivos del proyecto importado. Solo se pueden incluir los archivos cuyo proyecto figure 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. Después del nombre del proyecto importado, escribe una barra inclinada (/) y la ruta completa del archivo que quieras 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 la página del parámetro include para obtener información sobre cómo especificar rutas con carpetas de IDE habilitadas.

Puede usar comodines para incluir varios archivos. Por ejemplo, para incluir todos los archivos de vista del directorio /views/ del proyecto importado e_flights, haga lo siguiente:

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

Además, puedes usar comodines para acotar niveles de directorios específicos o directorios recursivos 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 del parámetro include para obtener información sobre cómo usar comodines con las carpetas de IDE habilitadas.

Incluidos los archivos de modelo

No puedes incluir un archivo de modelo de otro proyecto. En su lugar, si quieres reutilizar, acotar o ampliar Exploraciones en varios proyectos, puedes crear un archivo de Exploración independiente en el proyecto importado e incluirlo en otros proyectos. Para obtener más información, consulta la sección Incluir Exploraciones en un modelo de la página de documentación del parámetro include.

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 transfiera al siguiente proyecto que lo incluya.

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

Importar archivos de datos

Los archivos almacenados en la sección Datos de un proyecto no se importan. Para hacer referencia a un archivo de datos de un proyecto importado, como en el parámetro map_layer, usa la ruta completa y el nombre del archivo. Por ejemplo:

map_layer: json_from_imported_project {
  file: "//path_to_imported_project/folder/filename.topojson"
  ...
}

Hacer referencia a archivos de un proyecto importado

Después de importar un archivo de vista en 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 formara parte de ese proyecto. Por ejemplo, supongamos que has importado el proyecto ga_360_block en el archivo de manifiesto de tu proyecto y que tienes la siguiente instrucción 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 de la vista ga_block incluida.

Usar 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 todo el proyecto. El subparámetro export del parámetro constant especifica si se puede anular el valor de una constante cuando se importan a otro proyecto archivos que hacen referencia a esa constante.

El parámetro export puede tener los siguientes valores:

• none: el valor predeterminado de export. El valor de la constante no se puede anular en el 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 en el proyecto de importación. Si no se proporciona ningún valor en el archivo de manifiesto del proyecto de importación, se usará 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 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 nuevo valor a esa constante, siempre que tenga export definido como override_optional o override_required en su proyecto original. Cuando sustituyes el valor de una constante de un proyecto importado, tu proyecto usará el valor que especifiques con el parámetro override_constant.

Por ejemplo, supongamos que gestionas varias bases de datos en una sola instancia de Looker, con un proyecto independiente para cada base de datos. También debe suponer que los esquemas de datos son idénticos en todas las bases de datos y que su 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 ha definido vistas que quiere importar a otros proyectos. Además, una de las vistas que quiere 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, como la constante schema_name se ha definido como 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
}

Por ejemplo, supongamos que quiere importar la vista orders a un proyecto local llamado proj_a. También hay una tabla llamada orders en la base de datos de proj_a con una estructura idéntica a la de la tabla orders del 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 de proj_a:

project_name: "proj_a"

local_dependency: {
  project: "proj_core"
  override_constant: schema_name {
    value: "proj_a_schema"
  }
}

En este ejemplo, como la constante schema_name se ha definido como export: override_required en project_core, Looker mostrará un error si no anula su valor en proj_a (el proyecto de importación).

Si anulas la constante schema_name en proj_a, puedes usar los campos que has definido en la vista orders en proj_core, en lugar de crear un archivo de vista y definir los 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.