1. Einführung

Betrügerische Aktivitäten umfassen oft versteckte Netzwerke verbundener Entitäten, z. B. mehrere Konten, die dieselbe E-Mail-Adresse, Telefonnummer oder Postanschrift verwenden. Herkömmliche relationale Datenbanken können diese komplexen Beziehungen mit mehreren Hops nur schwer effizient abfragen.
Mit BigQuery Graph können Sie diese Netzwerke mithilfe von Graphdatenbanken in großem Umfang analysieren. Sie können einen Eigenschaftsgraphen über Ihren vorhandenen BigQuery-Tabellen definieren und die Graph Query Language (GQL) verwenden, um Muster in Ihren Daten zu finden.
Eine gängige Anwendung von Graphnetzwerken zur Betrugserkennung ist das Stoppen von Bestellungen, deren Lieferadresse mit einem Betrugsnetzwerk in Verbindung steht, oder das Stoppen von Zahlungen, die zu einem Betrugsnetzwerk gehören .
In diesem Codelab erstellen Sie eine Lösung zur Betrugserkennung mit BigQuery Graph. Sie laden Daten aus Cloud Storage, erstellen einen Eigenschaftsgraphen und verwenden Graphabfragen, um verdächtige Verbindungen zu identifizieren.
Lerninhalte
- BigQuery-Dataset erstellen und Daten laden
- Eigenschaftsgraphen mit DDL definieren
- Wie Sie den Graphen mit GQL abfragen.
- So verwenden Sie die Graphanalyse, um Betrug zu erkennen.
Voraussetzungen
- Google Cloud-Projekt mit aktivierter Abrechnungsfunktion.
- Eine BigQuery-Notebook-Umgebung (BigQuery Studio oder Colab Enterprise).
Kosten
In diesem Lab werden kostenpflichtige Google Cloud-Ressourcen verwendet. Die geschätzten Kosten liegen unter 5 $, sofern Sie die Ressourcen nach Abschluss löschen.
2. Hinweis
Google Cloud-Projekt auswählen oder erstellen
- Wählen Sie in der Google Cloud Console auf der Seite zur Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie ein Google Cloud-Projekt.
- Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung aktiviert ist
Umgebung auswählen
Für dieses Lab benötigen Sie eine Notebook-Umgebung. Sie können BigQuery Studio oder Colab Enterprise verwenden.
- Rufen Sie in der Google Cloud Console die Seite BigQuery auf.
- Sie verwenden das Python-Notebook, um die Graphabfragen auszuführen.
Cloud Shell starten
- Klicken Sie oben in der Google Cloud Console auf Cloud Shell aktivieren.
- Authentifizierung prüfen:
gcloud auth list
- Bestätigen Sie Ihr Projekt:
gcloud config get project
- Legen Sie sie bei Bedarf fest:
export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID
APIs aktivieren
Führen Sie den folgenden Befehl aus, um die erforderliche BigQuery API zu aktivieren:
gcloud services enable bigquery.googleapis.com
3. Daten laden
In diesem Schritt erstellen Sie ein BigQuery-Dataset und laden die Beispieldaten aus Cloud Storage.
Die Beispieldaten bestehen aus mehreren CSV-Dateien, die eine simulierte Einzelhandelsumgebung darstellen:
customers.csv: Informationen zum Kundenkonto.emails.csv: E-Mail-Adressen.phones.csv: Telefonnummern.addresses.csv: Physische Adressen.customer_emails.csv,customer_phones.csv,customer_addresses.csv: Tabellen verknüpfen.orders.csv: Bestellverlauf, einschließlich Betrugs-Flags.
Dataset erstellen
Erstellen Sie ein Dataset mit dem Namen fraud_demo, um die Tabellen zu speichern.
- In diesem Codelab führen wir SQL-Befehle aus. Sie können diese Befehle in BigQuery Studio > SQL-Editor ausführen oder den Befehl
bq queryin Cloud Shell verwenden.
Wir gehen davon aus, dass Sie den BigQuery SQL-Editor verwenden, um mehrzeilige Erstellungsanweisungen besser zu verarbeiten.
CREATE SCHEMA IF NOT EXISTS `fraud_demo` OPTIONS(location="US");
Tabellen laden
Führen Sie die folgenden SQL-Anweisungen aus, um Daten aus Cloud Storage in Ihr Dataset zu laden.
LOAD DATA OVERWRITE `fraud_demo.customers`
FROM FILES (
format = 'CSV',
uris = ['gs://sample-data-and-media/fraud-demo-data/customers.csv'],
skip_leading_rows = 1
);
LOAD DATA OVERWRITE `fraud_demo.emails`
FROM FILES (
format = 'CSV',
uris = ['gs://sample-data-and-media/fraud-demo-data/emails.csv'],
skip_leading_rows = 1
);
LOAD DATA OVERWRITE `fraud_demo.phones`
FROM FILES (
format = 'CSV',
uris = ['gs://sample-data-and-media/fraud-demo-data/phones.csv'],
skip_leading_rows = 1
);
LOAD DATA OVERWRITE `fraud_demo.addresses`
FROM FILES (
format = 'CSV',
uris = ['gs://sample-data-and-media/fraud-demo-data/addresses.csv'],
skip_leading_rows = 1
);
LOAD DATA OVERWRITE `fraud_demo.customer_emails`
FROM FILES (
format = 'CSV',
uris = ['gs://sample-data-and-media/fraud-demo-data/customer_emails.csv'],
skip_leading_rows = 1
);
LOAD DATA OVERWRITE `fraud_demo.customer_phones`
FROM FILES (
format = 'CSV',
uris = ['gs://sample-data-and-media/fraud-demo-data/customer_phones.csv'],
skip_leading_rows = 1
);
LOAD DATA OVERWRITE `fraud_demo.customer_addresses`
FROM FILES (
format = 'CSV',
uris = ['gs://sample-data-and-media/fraud-demo-data/customer_addresses.csv'],
skip_leading_rows = 1
);
LOAD DATA OVERWRITE `fraud_demo.orders`
FROM FILES (
format = 'CSV',
uris = ['gs://sample-data-and-media/fraud-demo-data/orders.csv'],
skip_leading_rows = 1
);
4. Property Graph erstellen
Nachdem die Daten geladen wurden, können Sie den Property Graph definieren. Ein Eigenschaftsgraph besteht aus Knoten (Entitäten) und Kanten (Beziehungen).
In diesem Lab sind die Knoten:
- Kunde: Der Kontoinhaber.
- Telefon: Steht für eine Telefonnummer.
- E-Mail-Adresse: Steht für eine E-Mail-Adresse.
- Adresse: Stellt eine physische Adresse dar.
Die Kanten sind:
- OwnsPhone: Verbindet einen Kunden mit einem Smartphone.
- OwnsEmail: Verknüpft einen Kunden mit einer E-Mail-Adresse.
- LinkedToAddress: Verknüpft einen Kunden mit einer Adresse.

Diagramm erstellen
Führen Sie die folgende DDL-Anweisung aus, um den Graphen mit dem Namen FraudDemo in Ihrem Dataset fraud_demo zu erstellen.
CREATE OR REPLACE PROPERTY GRAPH fraud_demo.FraudDemo
NODE TABLES(
fraud_demo.customers
KEY(account_id)
LABEL Customer PROPERTIES(
account_id,
name),
fraud_demo.emails
KEY(email)
LABEL Email PROPERTIES(
email,
email_type),
fraud_demo.phones
KEY(phone_number)
LABEL Phone PROPERTIES(
phone_number,
phone_type),
fraud_demo.addresses
KEY(address)
LABEL Address PROPERTIES(
address,
address_type)
)
EDGE TABLES(
fraud_demo.customer_emails
KEY(account_id, email)
SOURCE KEY(account_id) REFERENCES customers(account_id)
DESTINATION KEY(email) REFERENCES emails(email)
LABEL OwnsEmail PROPERTIES(
account_id,
email,
last_updated_ts),
fraud_demo.customer_phones
KEY(account_id, phone_number)
SOURCE KEY(account_id) REFERENCES customers(account_id)
DESTINATION KEY(phone_number) REFERENCES phones(phone_number)
LABEL OwnsPhone PROPERTIES(
account_id,
phone_number,
last_updated_ts),
fraud_demo.customer_addresses
KEY(account_id, address)
SOURCE KEY(account_id) REFERENCES customers(account_id)
DESTINATION KEY(address) REFERENCES addresses(address)
LABEL LinkedToAddress PROPERTIES(
account_id,
address,
last_updated_ts)
);
5. Netzwerke analysieren (2 Hops)
Öffnen Sie in BigQuery Studio ein neues Notebook.

Für die Visualisierung und die Empfehlungen in diesem Codelab verwenden wir ein Google Colab-Notebook in BigQuery Studio. So können wir die Diagrammergebnisse leicht visualisieren.
Fügen Sie Folgendes in eine Codezelle ein:
!pip install bigquery-magics==0.12.1
BigQuery Graph Notebook wird als IPython Magics implementiert. Wenn Sie den Magic-Befehl %%bigquery mit der Funktion TO_JSON hinzufügen, können Sie die Ergebnisse wie in den folgenden Abschnitten beschrieben visualisieren. In diesem Schritt führen Sie eine Graphabfrage aus, um einfache Verbindungen zwischen Konten zu finden. Dies ist eine „2-Hop“-Abfrage, da sie zwei Hops von einem Startknoten entfernt ist, um zugehörige Knoten zu finden (z.B. Kunde -> E‑Mail -> Kunde).
Wir beginnen mit der Untersuchung des Kontos von Nicole Wade. Wir möchten alle Konten finden, die über zwei Hops mit ihr in Verbindung stehen.
2-Hop-Abfrage ausführen
Führen Sie die folgende Abfrage in Ihrem Notebook aus.
%%bigquery --graph
GRAPH fraud_demo.FraudDemo
MATCH
p=(a:Customer)
( -[e:OwnsEmail|OwnsPhone|LinkedToAddress WHERE e.last_updated_ts < '2025-07-30']- (n) ){2}
WHERE a.account_id IN ("d2f1f992-d116-41b3-955b-6c76a3352657")
-- Verify the final node in the hop array is a Customer
AND 'Customer' IN UNNEST(LABELS(n[OFFSET(1)]))
RETURN TO_JSON(p) AS paths

Was bedeuten die Ergebnisse?
Diese Abfrage bewirkt Folgendes:
- Beginnt beim Knoten
Customermit deraccount_id„d2f1f992-d116-41b3-955b-6c76a3352657“ (Nicole Wade). - Folgt einer der Kanten
OwnsEmail,OwnsPhoneoderLinkedToAddresszu einem Verbindungsknoten (Phone,EmailoderAddress). - Folgt Kanten von diesem Verbindungsknoten zurück zu anderen
Customer-Knoten. - Filtert Kanten anhand eines Zeitstempels (
last_updated_ts), um den Status des Netzwerks zu einem bestimmten Zeitpunkt anzuzeigen.
Sie sollten sehen, dass Zachary Cordova und Brenda Brown über dieselbe Adresse mit Nicole verbunden sind.
6. Netzwerke analysieren (4 Hops)
In diesem Schritt erweitern Sie die Abfrage, um komplexere Beziehungen zu finden. Wir suchen nach 4-Hop-Verbindungen. So können wir Konten finden, die über mehrere Zwischenentitäten verbunden sind (z.B. Kunde A -> E-Mail -> Kunde B -> Telefon -> Kunde C).
Wir werden auch beobachten, wie sich dieses Netzwerk im Laufe der Zeit verändert.
Der Zustand „Vorher“
Sehen wir uns zuerst das Netzwerk am 30. Juli 2025 an.
Führen Sie die folgende Abfrage aus:
%%bigquery --graph
GRAPH fraud_demo.FraudDemo
MATCH p= ANY SHORTEST (a:Customer)
( -[e:OwnsEmail|OwnsPhone|LinkedToAddress WHERE e.last_updated_ts < '2025-07-30']- (n) ){3, 5}(reachable_a:Customer)
WHERE a.account_id IN ("d2f1f992-d116-41b3-955b-6c76a3352657")
-- Ensure the final node in the dynamic chain is actually a Customer
AND 'Customer' IN UNNEST(LABELS(n[OFFSET(ARRAY_LENGTH(n) - 1)]))
RETURN
TO_JSON(p) AS paths, -- Array of all traversed edges
ARRAY_LENGTH(e) AS hop_count

Der Zustand „Danach“
Sehen wir uns nun an, wie das Netzwerk zwei Wochen später aussieht. Wir führen dieselbe Abfrage aus, aber ohne die Datumseinschränkungen.
Führen Sie die folgende Abfrage aus:
%%bigquery --graph
GRAPH fraud_demo.FraudDemo
MATCH p= ANY SHORTEST (a:Customer)
( -[e:OwnsEmail|OwnsPhone|LinkedToAddress]- (n) ){3, 5}(reachable_a:Customer)
WHERE a.account_id IN ("d2f1f992-d116-41b3-955b-6c76a3352657")
-- Ensure the final node in the dynamic chain is actually a Customer
AND 'Customer' IN UNNEST(LABELS(n[OFFSET(ARRAY_LENGTH(n) - 1)]))
RETURN
TO_JSON(p) AS paths, -- Array of all traversed edges
ARRAY_LENGTH(e) AS hop_count

Was bedeuten die Ergebnisse?
Wenn Sie die Datumsfilter entfernen, wird die Abfrage für das gesamte Dataset ausgeführt. Sie werden feststellen, dass das Netzwerk erheblich gewachsen ist. Nicole Wade ist jetzt Teil einer viel größeren, stark vernetzten Gruppe. Diese schnelle Erweiterung eines verbundenen Netzwerks ist ein starker Indikator für potenziell betrügerische Aktivitäten, z. B. einen Betrugsring, der im Laufe der Zeit Ressourcen teilt.
7. Betrugsbericht erstellen
In diesem Schritt kombinieren Sie die Graphanalyse mit herkömmlichen Geschäftsdaten (Bestellungen), um einen umfassenden Betrugsbericht zu erstellen. Sie identifizieren gefährdete Konten und potenziell betrügerische Bestellungen.
Diese Abfrage ist komplexer. Dabei wird GRAPH_TABLE verwendet, um die Graphabfrage in Standard-SQL auszuführen, und die Änderung der Netzwerkgröße (diff) zwischen dem „Vorher“- und dem „Nachher“-Zustand berechnet, den wir im vorherigen Schritt beobachtet haben.
Abfrage für den Betrugsbericht ausführen
Führen Sie die folgende Abfrage in Ihrem Notebook aus.
%%bigquery --graph
WITH num_orders AS (
SELECT account_id, COUNT(1) AS num_order
FROM fraud_demo.orders
WHERE order_time > '2025-07-30'
GROUP BY account_id
),
orders AS (
SELECT account_id, order_id, fraud, order_total
FROM fraud_demo.orders
WHERE order_time > '2025-07-30'
),
-- Use Quantified Path Patterns to find connections up to 4 hops away
latest_connect AS (
SELECT
account_id,
ARRAY_LENGTH(ARRAY_AGG(DISTINCT connected_id)) AS size
FROM GRAPH_TABLE(
fraud_demo.FraudDemo
MATCH (a:Customer)-[:OwnsEmail|OwnsPhone|LinkedToAddress]-{4}(connected:Customer)
RETURN a.account_id AS account_id, connected.account_id AS connected_id
)
GROUP BY account_id
),
prev_connect AS (
SELECT
account_id,
ARRAY_LENGTH(ARRAY_AGG(DISTINCT connected_id)) AS size
FROM GRAPH_TABLE(
fraud_demo.FraudDemo
-- Apply the timestamp filter to EVERY edge in the 4-hop chain
MATCH (a:Customer)
(-[e:OwnsEmail|OwnsPhone|LinkedToAddress WHERE e.last_updated_ts < '2025-07-30']-(n)){4}
WHERE 'Customer' IN UNNEST(LABELS(n[OFFSET(3)]))
RETURN a.account_id AS account_id, n[OFFSET(3)].account_id AS connected_id
)
GROUP BY account_id
),
edge_changes AS (
SELECT account_id, MAX(last_updated_ts) AS max_last_updated_ts
FROM fraud_demo.customer_addresses
GROUP BY account_id
)
SELECT
la.account_id,
o.order_id,
la.size AS latest_size,
COALESCE(pa.size, 0) AS previous_size,
la.size - COALESCE(pa.size, 0) AS diff,
nos.num_order,
o.fraud AS reported_as_fraud,
o.order_total,
CASE
WHEN (la.size - COALESCE(pa.size, 0)) > 10 AND nos.num_order IS NULL THEN "CUSTOMER AT RISK"
WHEN (la.size - COALESCE(pa.size, 0)) > 10 AND nos.num_order IS NOT NULL AND o.fraud THEN "CONFIRMED FRAUD ORDER"
WHEN (la.size - COALESCE(pa.size, 0)) > 10 AND nos.num_order IS NOT NULL AND NOT o.fraud THEN "POTENTIAL FRAUD ORDER"
ELSE ""
END AS notes
FROM latest_connect la
LEFT JOIN prev_connect pa ON la.account_id = pa.account_id
LEFT JOIN num_orders nos ON la.account_id = nos.account_id
LEFT JOIN orders o ON la.account_id = o.account_id
INNER JOIN edge_changes ec ON la.account_id = ec.account_id
WHERE nos.num_order > 1 OR (la.size - COALESCE(pa.size, 0)) > 10
ORDER BY diff DESC
Was bedeuten die Ergebnisse?
Dieser Bericht enthält Folgendes:
account_id: Die ID des analysierten Kontos.order_id: Eine aktuelle Bestell-ID.latest_size: Die aktuelle Größe des verbundenen Netzwerks.previous_size: Die Größe des Netzwerks vor zwei Wochen.diff: Das Wachstum der Netzwerkgröße.num_order: Die Anzahl der letzten Bestellungen.reported_as_fraud: Gibt an, ob die Bestellung als Betrug gekennzeichnet wurde.order_total: Der Gesamtbetrag der Bestellung.notes: Ein berechneter Risikostatus, der auf dem Netzwerkwachstum und dem Bestellverlauf basiert.
Sie sehen Konten mit hohen diff-Werten und hohen Bestellsummen, die sich für weitere Untersuchungen anbieten. Die Hinweise „CUSTOMER AT RISK“ (Kunde gefährdet) und „POTENTIAL FRAUD ORDER“ (Potenziell betrügerische Bestellung) helfen bei der Priorisierung dieser Konten.

8. Erkennung in großem Umfang
In diesem letzten Analyseschritt visualisieren Sie das Netzwerk in einem größeren Maßstab. Anstatt mit einem einzelnen Konto zu beginnen, fragen Sie nach Verbindungen zwischen einer Reihe verdächtiger Konten.
So können Sie feststellen, ob mehrere unabhängige Untersuchungen tatsächlich Teil desselben größeren Betrugsrings sind.
Skalierte Abfrage ausführen
Führen Sie die folgende Abfrage in Ihrem Notebook aus.
%%bigquery --graph
GRAPH fraud_demo.FraudDemo
MATCH
p= ANY SHORTEST (a:Customer)
( -[e:OwnsEmail|OwnsPhone|LinkedToAddress]- (n) ){3, 5}
(reachable_a:Customer)
-- these IDs are from the previous results
WHERE a.account_id in ( "845f2b14-cd10-4750-9f28-fe542c4a731b"
, "3ff59684-fbf9-40d7-8c41-285ade5002e6"
, "8887c17b-e6fb-4b3b-8c62-cb721aafd028"
, "03e777e5-6fb4-445d-b48c-cf42b7620874"
, "81629832-eb1d-4a0e-86da-81a198604898"
, "845f2b14-cd10-4750-9f28-fe542c4a731b",
"89e9a8fe-ffc4-44eb-8693-a711a3534849"
)
LIMIT 400
RETURN TO_JSON(p) as paths
Was bedeuten die Ergebnisse?
Diese Abfrage gibt ein komplexes Diagramm zurück, das zeigt, wie sich die angegebenen verdächtigen Konten überschneiden und Ressourcen gemeinsam nutzen. Sie sehen sich jetzt die Betrugserkennung im großen Maßstab an und identifizieren Aktivitätscluster, die eine koordinierte Reaktion erfordern könnten.

9. Bereinigen
Damit Ihrem Google Cloud-Konto die in diesem Codelab verwendeten Ressourcen nicht in Rechnung gestellt werden, sollten Sie das Dataset und den Property-Graphen löschen.
Führen Sie die folgenden SQL-Anweisungen aus, um Ihre Umgebung zu bereinigen.
DROP PROPERTY GRAPH IF EXISTS fraud_demo.FraudDemo;
DROP SCHEMA IF EXISTS fraud_demo CASCADE;
10. Glückwunsch
Glückwunsch! Sie haben mit BigQuery Graph eine Lösung zur Betrugserkennung erstellt.
Sie haben Folgendes gelernt:
- Daten aus Cloud Storage in BigQuery laden
- Eigenschaftsgraphen mit DDL definieren
- Fragen Sie den Graphen mit GQL ab, um einfache und komplexe Beziehungen zu finden.
- Kombinieren Sie Graphanalysen mit Geschäftsdaten, um Risiken zu identifizieren.
- Netzwerke in großem Umfang visualisieren