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.

Modelarás una red de cadena de suministro de un restaurante que se enfoca 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 fundamental. Identificar el "radio de impacto" y ejecutar un retiro preciso con rapidez puede ahorrar costos y proteger a los clientes.

Alerta de seguridad alimentaria en un restaurante

Los modelos relacionales tradicionales requieren operaciones JOIN complejas de varios pasos para rastrear los artículos a través de varias etapas (proveedor -> centro de distribución -> comisariato -> tienda -> artículo terminado). Con BigQuery Graph, modelamos estas conexiones directamente, lo que permite realizar consultas rápidas e intuitivas 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 grafo de propiedades en BigQuery
  • Cómo ejecutar consultas de recorrido para rastrear los impactos ascendentes y descendentes

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 tarifas de análisis de BigQuery, lo que está dentro de las asignaciones del nivel gratuito para usuarios nuevos.

2. Configuración y requisitos

Abre Cloud Shell

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

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

Configura las variables de entorno

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

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

Habilita las APIs

Ejecuta este comando para habilitar la API de BigQuery requerida:

gcloud services enable bigquery.googleapis.com

3. Crea el esquema y las tablas

Crearás un conjunto de datos y tablas que representen 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 las relaciones de peso, p.ej., el artículo A va en el artículo B).
  • makes: Asigna itemlocation a item.
  • stored_at: Asigna itemlocation a location.

Crear conjunto de datos

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

Para usar la consola de BigQuery, sigue estos pasos:

  1. Abre la consola de BigQuery en una pestaña nueva.
  2. Pega cada fragmento de 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 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 de restaurante dentro de tu proyecto para alojar tus datos de grafo. (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 quieras usar: PROJECT_ID = "argolis-project-340214" # @param {"type":"string"} (3) Si usas Colab, según tus requisitos, deberás instalar algunas bibliotecas. Si vas a usar la visualización de grafos, 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 ;

Crea tablas

Ejecuta el siguiente código de 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. Carga datos de muestra

Para que este lab sea completamente independiente, propagarás las tablas con datos de muestra usando sentencias de SQL LOAD DATA puras. Esto representa una red que comienza con un proveedor, pasa por un centro de distribución (CD) y una cocina central, y llega a una cafetería minorista.

Ejecuta las siguientes consultas en SQL para cargar los datos:

Carga de datos de 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. Agrega restricciones y define el gráfico

Antes de compilar el grafo, debes declarar las relaciones semánticas con las restricciones de clave primaria y clave externa de SQL estándar. Estas guían a BigQuery para que comprenda los identificadores de nodos y conecte las tablas de bordes a las tablas de nodos.

Crea un grafo de propiedades

Ahora, une estas tablas en una sola estructura de Graph cohesiva llamada restaurant.bombod.

Debes definir 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. Visualiza 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 o una IU estándar que lo admita (como %%bigquery --graph), se devuelve un mapa visual.

Usa consultas de grafos absolutos para configurar nodos y bordes.

Nota: Como se mencionó antes, para ejecutar esto en Google Colab o en los notebooks de Colab Enterprise, también puedes usar los comandos mágicos de BigQuery: %%bigquery. Además, para visualizar el gráfico en Google Colab o en los notebooks de 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 upstream

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 recorrido de grafo. Esto analiza las aristas de consists_of que relacionan los ensamblajes descendentes con 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 bordes de consists_of (Ingredient -> Finished), una búsqueda que fluye hacia arriba 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 de Columbus, Ohio. Necesitas saber qué preparaciones o artículos terminados de la cadena de suministro 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 lo 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 downstream

Situación: Un proveedor te notifica sobre un lote específico de productos contaminados: Tomates madurados en la planta del proveedor. Debes encontrar todos los elementos finales del menú que se ven 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 ubica todos los elementos que coinciden con el patrón "Tomato" y que están entrelazados con la relación ascendente, 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 Bad Tomatoes

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. Declara relaciones relacionales centradas en grafos con claves primarias y externas.
  2. Crea un gráfico de propiedades unificado.
  3. Navegar por 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, visita la documentación de Google Cloud.