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 de la cadena de suministro.

Modelarás una red de cadena de suministro de restaurantes enfocada 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 del impacto" y ejecutar un retiro quirúrgico rápidamente puede ahorrar costos y proteger a los clientes.

Alerta alimentaria en un restaurante

Los modelos relacionales tradicionales requieren operaciones JOIN complejas y de varios pasos para rastrear elementos a través de varias etapas (proveedor -> centro de distribución -> cocina central -> 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 gráfico sobre las tablas de BigQuery existentes
  • Cómo crear un gráfico 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, muy por debajo 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 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 las APIs

Ejecuta este comando para habilitar la API de BigQuery requerida:

gcloud services enable bigquery.googleapis.com \
  bigqueryreservation.googleapis.com

Crea una reserva y una asignación de BigQuery

Para ejecutar consultas de GQL, debes tener una reserva que use la edición Enterprise o Enterprise Plus, y crear una reserva de la edición Enterprise con ajuste de escala automático en Cloud Shell:

# 1. Create a BigQuery Enterprise reservation with 0 baseline slots and 100 max autoscaling slots
bq mk --reservation \
  --project_id=${GCP_PROJECT} \
  --location=US \
  --edition=ENTERPRISE \
  --slots=0 \
  --autoscale_max_slots=100 \
  --ignore_idle_slots=true \
  supplychaingraph-reservation

# 2. Assign your Cloud project to the newly created reservation for query execution
bq mk --reservation_assignment \
  --project_id=${GCP_PROJECT} \
  --location=US \
  --reservation_id=supplychaingraph-reservation \
  --job_type=QUERY \
  --assignee_type=PROJECT \
  --assignee_id=${GCP_PROJECT}

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: La definición genérica del artículo (p. ej., tomate, pollo)
  • location: Instalaciones (proveedores, centros de distribución, cafeterías)
  • itemlocation: 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 al artículo B)
  • makes: Asigna itemlocation a item
  • stored_at: Asigna itemlocation a location.

Crear conjunto de datos

Puedes ejecutar los comandos de SQL en 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 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 del restaurante en tu proyecto para alojar los datos del gráfico. (2) Deberás usar %%bigquery –project <PROJECT_ID> si ejecutas 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, según tus requisitos, deberás instalar algunas bibliotecas. 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 ;

Crea 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. Carga datos de muestra

Para que este lab sea completamente independiente, 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 (DC) y una cocina central, y llega a una cafetería minorista.

Ejecuta las siguientes consultas de SQL para cargar los datos:

Carga de datos en BigQuery

Nota: Puedes omitir %%bigquery si ejecutas 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 gráfico, declara las relaciones semánticas con las restricciones de clave externa y clave primaria de SQL estándar. Estas guían a BigQuery para comprender los identificadores de nodos y conectar las tablas de aristas a las tablas de nodos.

Crea un gráfico de propiedades

Ahora, une estas tablas en una sola estructura de gráfico cohesiva llamada restaurant.bombod.

Define lo siguiente:

  • Nodos: item, location, itemlocation
  • Aristas: 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 IU estándar que lo admita (como %%bigquery --graph), se muestra un mapa visual.

Usa consultas de gráficos absolutas para configurar nodos y aristas.

Nota: Como se mencionó anteriormente, para ejecutar esto en Google Colab o 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 notebooks de Colab Enterprise, incluye la marca –graph como: %%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: Rastrea una queja ascendente

Situación: Un cliente se queja de la calidad del pollo en 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 gráfico. Esto analiza las aristas 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 aristas 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 en Columbus, Ohio. Debes saber qué preparaciones descendentes o artículos terminados se ven afectados de inmediato.

Consulta de recorrido

Comienzas en la location específica 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: Retiro descendente

Situación: Un proveedor te notifica sobre un lote específico de producto contaminado: 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 salto de directorio que fluye hacia abajo para encontrar los elementos afectados definitivos.

%%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 los tomates malos

10. Limpieza

Borra los recursos una vez que completes los pasos del instructivo 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 gráficos con claves externas y primarias
  2. Crear un gráfico de propiedades unificado
  3. Navegar 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 gráficos, visita la documentación de Google Cloud.