Rastreabilidad de la cadena de suministro con BigQuery Graph

1. Introducción

En este codelab, aprenderás a aprovechar BigQuery Graph para resolver problemas complejos de logística y cadena de suministro.

Crearás un modelo de una red de cadena de suministro de restaurantes centrado en la seguridad alimentaria y el control de calidad. Cuando surge un problema de seguridad alimentaria, como un ingrediente contaminado de un proveedor, el tiempo es esencial. Identificar el "radio de explosión" y ejecutar una recuperación quirúrgica rápidamente puede ahorrar costos y proteger a los clientes.

Alarma por comida en restaurante

Los modelos relacionales tradicionales requieren operaciones JOIN complejas de varios pasos para rastrear elementos a través de múltiples etapas (proveedor -> centro de distribución -> cocina -> tienda -> artículo terminado). Con BigQuery Graph, modelamos estas conexiones directamente, lo que permite realizar consultas intuitivas y rápidas con el estándar ISO GQL (Graph Query Language).

Qué aprenderás

  • Cómo definir un modelo de grafo sobre tablas de BigQuery existentes
  • Cómo crear un gráfico de propiedades en BigQuery
  • Cómo ejecutar consultas de recorrido para rastrear los impactos upstream y downstream

Requisitos

  • Un proyecto de Google Cloud con facturación habilitada
  • Google Cloud Shell.

Estimación de costos

Se espera que este lab cueste menos de USD 5 en cargos de análisis de BigQuery, lo que se encuentra dentro de las asignaciones del nivel gratuito para usuarios nuevos.

2. Configuración y requisitos

Abre Cloud Shell

La mayor parte del trabajo la realizarás en Cloud Shell, un entorno cargado que incluye todo lo que necesitas para usar Google Cloud.

  1. Ve a Google Cloud Console.
  2. Haz clic en el ícono de Activar Cloud Shell en la barra de herramientas superior derecha.
  3. Haz clic en Continuar si se te solicita.

Configura las variables de entorno

En Cloud Shell, establece tu ID del proyecto para simplificar los comandos futuros.

export PROJECT_ID=$(gcloud config get-value project)

Habilita la API de BigQuery

Asegúrate de que la API de BigQuery esté habilitada. Por lo general, está habilitada de forma predeterminada, pero es mejor prevenir.

gcloud services enable bigquery.googleapis.com

3. Cómo crear el esquema y las tablas

Crearás un conjunto de datos y tablas que representarán los componentes de tu cadena de suministro:

  • item: Es la definición genérica del elemento (p.ej., tomate, pollo).
  • location: Instalaciones (proveedores, centros de distribución, cafeterías).
  • itemlocation: Es la tabla de intersección que representa las ubicaciones del inventario.
  • bom: Lista de materiales (define relaciones de peso, p.ej., el artículo A se incluye en el artículo B).
  • makes: Asigna itemlocation a item.
  • stored_at: Maps itemlocation to location.

Crear conjunto de datos

Puedes ejecutar los comandos SQL de este lab con Cloud Shell o la consola de BigQuery.

Para usar la consola de BigQuery, haz lo siguiente:

  1. Abre la consola de BigQuery en una pestaña nueva.
  2. Pega cada fragmento de código SQL de este lab en el editor y, luego, haz clic en el botón Ejecutar para ejecutarlo.

Editor de BigQuery

Ejecuta el siguiente comando en Cloud Shell o usa la consola de BigQuery para crear el esquema. Usarás variables de nodo en tu código SQL.

Esquema de datos de BigQuery

Nota: (1) Para ejecutar esto en Google Colab, también puedes usar los comandos mágicos de BigQuery: %%bigquery. El siguiente fragmento crea el esquema del restaurante en tu proyecto para alojar los datos del gráfico. (2) Deberás usar %%bigquery –project <PROJECT_ID> si ejecutas el código desde Google Colab. Asegúrate de que el campo PROJECT_ID esté asignado al proyecto adecuado que deseas usar: PROJECT_ID = "argolis-project-340214" # @param {"type":"string"} (3) Si usas Colab, deberás instalar algunas bibliotecas según tus requisitos. Si vas a usar la visualización de gráficos, asegúrate de instalar la biblioteca con pip: spanner-graph-notebook==1.1.5

Comando mágico de BigQuery en Colab

%%bigquery --project=$PROJECT_ID
CREATE SCHEMA IF NOT EXISTS restaurant ;

Crear tablas

Ejecuta el siguiente código SQL para compilar las tablas.

%%bigquery --project=$PROJECT_ID
-- 1. Item Table
DROP TABLE IF EXISTS `restaurant.item`;
CREATE TABLE `restaurant.item` (
  itemKey STRING,
  itemName STRING,
  itemCategory STRING,
  shelfLifeDays INT64,
  PRIMARY KEY (itemKey) NOT ENFORCED
);

-- 2. Location Table
DROP TABLE IF EXISTS `restaurant.location`;
CREATE TABLE `restaurant.location` (
  locationKey STRING,
  locationType STRING,
  locationCity STRING,
  locationState STRING,
  dunsNumber INT64,
  PRIMARY KEY (locationKey) NOT ENFORCED
);
-- 3. ItemLocation Table
DROP TABLE IF EXISTS `restaurant.itemlocation`;
CREATE TABLE `restaurant.itemlocation` (
  itemLocationKey STRING,
  itemKey STRING,
  locationKey STRING,
  variants INT64,
  PRIMARY KEY (itemLocationKey) NOT ENFORCED,
  -- Foreign Key Definitions
  FOREIGN KEY (itemKey) REFERENCES `restaurant.item`(itemKey) NOT ENFORCED,
  FOREIGN KEY (locationKey) REFERENCES `restaurant.location`(locationKey) NOT ENFORCED
);

-- 4. BOM Table
DROP TABLE IF EXISTS `restaurant.bom`;
CREATE TABLE `restaurant.bom` (
  bomKey INT64,
  parentItemLocation STRING,
  childItemLocation STRING,
  childQuantity FLOAT64,
  PRIMARY KEY (bomKey) NOT ENFORCED
);

-- 5. Makes Table
DROP TABLE IF EXISTS `restaurant.makes`;
CREATE TABLE `restaurant.makes` (
  itemLocationKey STRING,
  itemKey STRING,
  locationKey STRING,
  variants INT64,
  PRIMARY KEY (itemLocationKey) NOT ENFORCED
);

DROP TABLE IF EXISTS `restaurant.stored_at`;
CREATE TABLE `restaurant.stored_at` (
  itemLocationKey STRING,
  itemKey STRING,
  locationKey STRING,
  variants INT64,
  PRIMARY KEY (itemLocationKey) NOT ENFORCED
);

4. Cargando datos de muestra

Para que este lab sea completamente autónomo, propagarás las tablas con datos de muestra usando instrucciones LOAD DATA de SQL puro. Esto representa una red que comienza con un proveedor, atraviesa un centro de distribución (CD) y una cocina de concesionario, y llega a una cafetería minorista.

Ejecuta las siguientes consultas en SQL para cargar los datos:

Carga de datos en BigQuery

Nota: Puedes omitir %%bigquery si ejecutas la consulta directamente en BigQuery Studio.

%%bigquery --project=$PROJECT_ID
-- Load Item
LOAD DATA OVERWRITE `restaurant.item`
FROM FILES (format = 'CSV', uris = ['gs://supply_chain_demo/item2.csv'], skip_leading_rows = 1);

-- Load Location
LOAD DATA OVERWRITE `restaurant.location`
FROM FILES (format = 'CSV', uris = ['gs://supply_chain_demo/location.csv'], skip_leading_rows = 1);

-- Load ItemLocation
LOAD DATA OVERWRITE `restaurant.itemlocation`
FROM FILES (format = 'CSV', uris = ['gs://supply_chain_demo/itemlocation.csv'], skip_leading_rows = 1);

-- Load BOM
LOAD DATA OVERWRITE `restaurant.bom`
FROM FILES (format = 'CSV', uris = ['gs://supply_chain_demo/bom2.csv'], skip_leading_rows = 1);

-- Load Makes
LOAD DATA OVERWRITE `restaurant.makes`
FROM FILES (format = 'CSV', uris = ['gs://supply_chain_demo/makes.csv'], skip_leading_rows = 1);

-- Load StoredAt
LOAD DATA OVERWRITE `restaurant.stored_at`
FROM FILES (format = 'CSV', uris = ['gs://supply_chain_demo/itemlocation.csv'], skip_leading_rows = 1);

5. Cómo agregar restricciones y definir el gráfico

Antes de compilar el gráfico, debes declarar las relaciones semánticas con las restricciones de clave primaria y clave externa de SQL estándar. Estos ayudan a BigQuery a comprender los identificadores de nodos y a conectar las tablas de borde con las tablas de nodos.

Crea un gráfico de propiedad

Ahora, une estas tablas en una sola estructura de grafo coherente llamada restaurant.bombod.

Tú defines lo siguiente:

  • Nodos: item, location, itemlocation
  • Bordes: makes, stored_at y consists_of (BOM)
%%bigquery --project=$PROJECT_ID

CREATE OR REPLACE PROPERTY GRAPH `restaurant.bombod`
NODE TABLES (
  `restaurant.item` KEY (itemKey) LABEL item PROPERTIES ALL COLUMNS,
  `restaurant.location` KEY (locationKey) LABEL location PROPERTIES ALL COLUMNS,
  `restaurant.itemlocation` KEY (itemLocationKey) LABEL itemlocation PROPERTIES ALL COLUMNS
)
EDGE TABLES (
  `restaurant.makes`
    KEY (itemLocationKey)
    SOURCE KEY (itemLocationKey) REFERENCES `restaurant.itemlocation`(itemLocationKey)
    DESTINATION KEY (itemKey) REFERENCES `restaurant.item`(itemKey)
    LABEL makes PROPERTIES ALL COLUMNS,
    
  `restaurant.bom`
    KEY (bomKey)
    SOURCE KEY (childItemLocation) REFERENCES `restaurant.itemlocation`(itemLocationKey)
    DESTINATION KEY (parentItemLocation) REFERENCES `restaurant.itemlocation`(itemLocationKey)
    LABEL consists_of PROPERTIES ALL COLUMNS,
    
  `restaurant.stored_at`
    KEY (itemLocationKey)
    SOURCE KEY (itemLocationKey) REFERENCES `restaurant.itemlocation`(itemLocationKey)
    DESTINATION KEY (locationKey) REFERENCES `restaurant.location`(locationKey)
    LABEL stored_at PROPERTIES ALL COLUMNS
);

6. Visualización de la cadena de suministro

Puedes ejecutar una consulta de recorrido de arriba hacia abajo para ver toda la red de la cadena de suministro. En un notebook estándar o en una IU que lo admita (como %%bigquery --graph), se muestra un mapa visual.

Usa consultas de gráficos absolutos para configurar nodos y bordes.

Nota: Como se mencionó anteriormente, para ejecutar esto en notebooks de Google Colab o Colab Enterprise, también puedes usar los comandos mágicos de BigQuery: %%bigquery. Además, para visualizar el gráfico en notebooks de Google Colab o Colab Enterprise, incluye la marca –graph de la siguiente manera: %%bigquery –graph

%%bigquery  --project=$PROJECT_ID --graph output

Graph restaurant.bombod

match p=(a:itemlocation)-[c:consists_of]->(b:itemlocation)
match q=(a)-[d:stored_at]->(e:location)
optional match z=(f)-[g:makes]-(b)

return to_json(p) as ppath, to_json(q) as qpath, to_json(z) as zpath

Resultado:

Gráfico de suministros para restaurantes

7. Caso de uso 1: Seguimiento de un reclamo ascendente

Situación: Un cliente se queja de la calidad del pollo de su sándwich en la tienda de Nueva York. Debes rastrear el artículo terminado hacia atrás para ver sus etapas de ensamblaje inmediatas.

Consulta de recorrido

Ejecuta la consulta con el formato de consulta de Graph Traversal. Esto analiza los bordes de consists_of que relacionan los ensamblados de forma descendente hasta los ingredientes ascendentes.

%%bigquery --project=$PROJECT_ID --graph

GRAPH restaurant.bombod
MATCH p=(a:itemlocation)-[c:consists_of]->(b:itemlocation)
OPTIONAL MATCH q=(b)-[d:stored_at]-(e)
return to_json(p) as ppath, to_json(q) as qpath

Debido a la dirección de la flecha en la tabla de borde consists_of (Ingredient -> Finished), una búsqueda que fluye de forma ascendente genera vínculos que aíslan rápidamente los materiales dependientes y las ubicaciones de almacenamiento.

Resultado: Navegación por la fuente de pollo

8. Caso de uso 2: Análisis de impacto

Situación: Una tormenta de nieve cerró el centro de distribución en Columbus, Ohio. Necesitas saber qué preparaciones posteriores o artículos terminados se ven afectados de inmediato.

Consulta de recorrido

Comienzas en el location específico que representa el centro de distribución, identificas el inventario almacenado allí y ves qué artículos terminados los requieren.

# @title Impact of a storm on a DC

%%bigquery  --project=$PROJECT_ID --graph
Graph restaurant.bombod
match path1=(z:itemlocation)-[m:stored_at]->(dc:location) where dc.locationKey like '%DC-Sysco-Columbus-OH%'
match path2=(z:itemlocation)-[c:consists_of]->(b:itemlocation)
match path3=(b:itemlocation)-[n:makes]->(item:item)
optional match path4=(b)-[p:stored_at]->(q:location)
return to_json(path1) as path1, to_json(path2) as path2,to_json(path3) as path3, to_json(path4) as path4

Resultado: Impacto de la tormenta

9. Caso de uso 3: Recuperación de datos posteriores

Situación: Un proveedor te notifica sobre un lote específico de productos contaminados: Tomates madurados en la vid del proveedor. Debes encontrar todos los elementos finales del menú afectados en las cafeterías.

Consulta de recorrido

Buscas la ubicación de la materia prima contaminada y, luego, realizas un recorrido de ruta que fluye hacia abajo para encontrar los elementos afectados finales.

%%bigquery  --project=$PROJECT_ID --graph
Graph restaurant.bombod
match path1=(a:itemlocation)-[c:consists_of]->(b:itemlocation)-[e:makes]->(f:item) where f.itemKey like '%Tomato%'
return to_json(path1) as result

Esta consulta localiza todos los elementos que coinciden con el patrón "Tomato" y que están entrelazados con la relación upstream, lo que la convierte en una asignación potente que se propaga para descubrir qué elementos de la cafetería se deben retirar.

Resultado: Impacto posterior de los tomates malos

10. Limpieza

Borra los recursos una vez que completes los pasos de la explicación para evitar cargos residuales en tu espacio de trabajo.

DROP SCHEMA `restaurant` CASCADE;

11. Conclusión

¡Felicitaciones! Modelaste una cadena de suministro y ejecutaste un análisis de impacto con BigQuery Graph.

Conclusión

Aprendiste a hacer lo siguiente:

  1. Declarar relaciones relacionales centradas en el grafo con claves primarias o externas
  2. Crea un gráfico de propiedad unificado.
  3. Navega por las relaciones de varios nodos de manera eficiente con la lógica de recorrido de Graph Query.

Para obtener más información sobre la arquitectura de grafos, consulta los documentos de Google Cloud.