Beim Abgleich der von Nutzern bereitgestellten Daten (user-provided data matching, UPDM) werden selbst erhobene Daten zu einem bestimmten Nutzer, etwa Informationen von Websites, aus Apps oder aus Geschäften, mit den Aktivitäten genau dieses angemeldeten Nutzers in allen Google-Anzeigendaten zusammengeführt, einschließlich Daten, die Google gehören und von Google betrieben werden. Dazu gehören Daten, die über Google Marketing Platform-Produkte (GMP) gekauft wurden, z. B. YouTube-Inventar, das über Display & Video 360 gekauft wurde. Andere GMP-Produkte, die nicht von Google betrieben werden, werden nicht unterstützt.
Damit von Nutzern bereitgestellte Daten abgeglichen werden können, muss das Anzeigenereignis mit einem angemeldeten Nutzer in Google-Anzeigendaten verknüpft sein.
In diesem Dokument wird die Funktion zum Abgleichen von nutzerbereitgestellten Daten beschrieben. Außerdem finden Sie hier eine Anleitung zur Einrichtung und Verwendung.
Tab „Verbindungen“ – Übersicht
Um wertvolle Werbeinformationen zu erhalten, müssen oft Daten aus verschiedenen Quellen zusammengeführt werden. Die Entwicklung einer eigenen Lösung für dieses Datenpipeline-Problem erfordert einen erheblichen Zeit- und Entwicklungsaufwand. Die Seite „Verbindungen“ in Ads Data Hub vereinfacht diesen Prozess. Sie bietet eine Schritt-für-Schritt-Anleitung zum Importieren, Transformieren und Abgleichen Ihrer Anzeigen-Daten in BigQuery, damit Sie sie in Ihren Ads Data Hub-Abfragen oder anderen Produkten verwenden können, die Daten aus BigQuery lesen. Wenn Sie selbst erhobene Daten für Ihre Abfragen verwenden, können Sie Kunden noch mehr bieten. Außerdem sind Sie dann besser auf branchenweite Änderungen beim Anzeigen-Tracking vorbereitet.
Die Seite „Verbindungen“ basiert auf Tools, mit denen Sie personenidentifizierbare Informationen verschlüsseln und datenschutzorientiert mit Partnern teilen können. Nachdem Sie ausgewählt haben, welche Spalten personenbezogene Daten enthalten, verschlüsselt Ads Data Hub die Daten. So wird sichergestellt, dass Ihre selbst erhobenen Daten nur von Personen exportiert oder gelesen werden können, die dazu berechtigt sind. Es kann schwierig sein, herauszufinden, welche selbst erhobenen Daten für Ihren Mess- oder Aktivierungsanwendungsfall erforderlich sind. Daher bietet Ads Data Hub eine umfassende Liste vordefinierter Anwendungsfälle und führt Sie durch den gesamten Prozess des Extrahierens, Transformierens und Ladens Ihrer Daten. Sie können zwar mehrere Arten von Verbindungen erstellen, in diesem Dokument wird jedoch davon ausgegangen, dass Sie die Seite „Verbindungen“ für den Abgleich von nutzerbezogenen Daten verwenden.
Unterstützte Quellen für selbst erhobene Daten
Sie können Daten aus den folgenden Datenquellen importieren:
- BigQuery
- Cloud Storage
- Secure FTP (SFTP)
- Snowflake
- MySQL
- PostgreSQL
- Amazon Redshift
- Amazon S3
Da der Abgleich der von Nutzern bereitgestellten Daten nur für Nutzer verfügbar ist, die in Inventar angemeldet sind, das Google gehört und von Google betrieben wird, ist er nicht von der bevorstehenden Einstellung von Drittanbieter-Cookies betroffen. Da sie widerstandsfähiger gegen branchenbezogene Änderungen als Drittanbieterdaten sind, können sie umfassendere Informationen liefern, die zu mehr Kundeninteraktionen führen können.
Wichtige Begriffe
- Verbindung für von Nutzern bereitgestellte Daten:Richten Sie eine Verbindung für von Nutzern bereitgestellte Daten ein, um Ihre Daten zu importieren und abzugleichen, Datenimporte zu planen, Daten zu transformieren und Ihre Anzeigen-Daten anhand einer Nutzer-ID abzugleichen. Das Anzeigenereignis muss mit einem angemeldeten Nutzer in Google-Anzeigendaten verknüpft sein. Erfordert mehrere Google Cloud-Projekte.
- Verbindung für selbst erhobene Daten:Richten Sie eine Verbindung für selbst erhobene Daten als Tool zur Datenaufbereitung ein, um Datenimporte zu planen und Daten ohne die erweiterten Funktionen von UPDM zu transformieren. Für diese Art von Verbindung ist nur ein Google Cloud-Projekt erforderlich.
- Datenquelle:Ein verknüpftes Produkt, eine importierte Datei oder eine Drittanbieterintegration, z. B. BigQuery.
- Ziel:Ein Anwendungsfall, in der Regel ein Google-Produkt oder eine entsprechende Funktion, für das bzw. die importierte Daten verwendet werden, z. B. der Abgleich der von Nutzern bereitgestellten Daten in Ads Data Hub.
- Administratorprojekt:Das Google Cloud-Projekt, das Ihre proprietären Werbedaten im Rohformat enthält.
- Ausgabe-Dataset:Das BigQuery-Dataset, in das Ads Data Hub schreibt. Standardmäßig ist das ein Dataset in Ihrem Administratorprojekt. Wenn Sie das Projekt in ein anderes Google Cloud-Projekt ändern möchten, lesen Sie den Abschnitt Dienstkonten konfigurieren.
Zusammenfassung des Prozesses
- Einrichtung von Datenaufnahme und ‑abgleich
- Sie gewähren die erforderlichen Berechtigungen für die Dienstkonten in Ihrem Administratorprojekt. Weitere Informationen finden Sie unter Datenaufnahme einrichten.
- Aufnahme und Abgleich selbst erhobener Daten
- Sie formatieren Ihre selbst erhobenen Daten und laden sie in Ihr BigQuery-Dataset hoch. Für die einfachste Einrichtung verwenden Sie Ihr Administratorprojekt. Sie können jedoch jedes BigQuery-Dataset verwenden, dessen Inhaber Sie sind.
- Sie starten eine Anfrage zum Datenabgleich, indem Sie eine Verbindung erstellen und einen Importzeitplan festlegen.
- Google führt Daten aus Ihrem Projekt und Google-eigene Daten mit der Google-Nutzer-ID und gehashten, von Nutzern bereitgestellten Daten zusammen, um Abgleichstabellen zu erstellen und zu aktualisieren.
- Weitere Informationen
- Laufende Abfragen in Ads Data Hub auf Grundlage abgeglichener Daten
- Sie führen Abfragen für die Match-Tables auf dieselbe Weise aus wie reguläre Abfragen in Ads Data Hub. Weitere Informationen finden Sie unter Abgleichsdaten abfragen.
Datenschutzanforderungen
Kundendaten erheben
Wenn Sie den Abgleich der von Nutzern bereitgestellten Daten verwenden, müssen Sie selbst erhobene Daten hochladen. Das können Daten sein, die Sie auf Ihren Websites, in Ihren Apps oder in Ihren Geschäften erhoben haben, oder Daten, die ein Kunde direkt mit Ihnen geteilt hat.
Die folgenden Anforderungen müssen erfüllt sein:
- Legen Sie in Ihrer Datenschutzerklärung offen, dass Sie Kundendaten an Dritte weitergeben, damit diese in Ihrem Auftrag Dienstleistungen erbringen können. Holen Sie außerdem, soweit gesetzlich erforderlich, die Einwilligung des entsprechenden Kunden für die Weitergabe der Daten ein.
- Laden Sie Kundendaten nur über APIs oder Schnittstellen hoch, die von Google zugelassen sind.
- Alle anwendbaren Gesetze und Bestimmungen einhalten, einschließlich aller eventuellen Selbstregulierungs- und Branchenkodizes
Einholen der Einwilligung für selbst erhobene Daten bestätigen
Damit Sie Ihre selbst erhobenen Daten in Ads Data Hub nutzen können, müssen Sie bestätigen, dass Sie die entsprechende Einwilligung zur Weitergabe von Daten von Endnutzern im EWR an Google gemäß der Richtlinie zur Einwilligung der Nutzer in der EU und den Ads Data Hub-Richtlinien eingeholt haben. Die Bestätigung ist für jedes Ads Data Hub-Konto und bei jedem Upload neuer selbst erhobener Daten erforderlich. Jeder Nutzer kann die Bestätigung für das gesamte Konto abgeben.
Hinweis: Für UPDM-Abfragen gelten dieselben Regeln für Google-Dienst-Abfragen wie für Analyseabfragen. So sind z. B. keine dienstübergreifenden Abfragen für Nutzer im EWR möglich, wenn Sie eine Match-Table erstellen.
Informationen dazu, wie Sie in Ads Data Hub bestätigen, dass Sie die Einwilligung eingeholt haben, finden Sie unter Einwilligungsanforderungen für den Europäischen Wirtschaftsraum.
Datengröße
Zum Schutz der Privatsphäre von Endnutzern gelten für den Abgleich von von Nutzern bereitgestellten Daten die folgenden Anforderungen an die Größe Ihrer Daten:
- Sie müssen mindestens 1.000 Datensätze in Ihre Nutzerliste hochladen.
- Jede erfolgreiche Aktualisierung Ihrer Abgleichstabelle muss eine Mindestanzahl neu abgeglichener Nutzer enthalten. Dieses Verhalten ähnelt Differenzprüfungen.
- Ihre Liste darf die maximale Anzahl von Datensätzen nicht überschreiten. Weitere Informationen zum maximalen Datenlimit erhalten Sie von Ihrem Google-Ansprechpartner.
Datenaufnahme einrichten
Bevor Sie beginnen, müssen Sie Ihr Ads Data Hub-Konto so konfigurieren, dass Datenverbindungen erstellt werden können. So richten Sie Ihre Pipeline für den Datenabgleich ein. Sie müssen diese Schritte nur einmal ausführen.
Klicken Sie auf der Seite Connections (Verbindungen) auf Begin setup (Einrichtung starten), um den Einrichtungsassistenten für Konten in der Phase der UPDM-Aktivierung zu öffnen.
Welche Berechtigungen werden für BigQuery und Cloud Storage gewährt?
Wenn Sie UPDM für die Verwendung mit BigQuery oder Cloud Storage einrichten, können Sie anhand dieser Referenz die Berechtigungen nachvollziehen, die den Ads Data Hub-Dienstkonten gewährt werden.
BigQuery
| Data Fusion-Dienstkonto | |||||||||
| Zweck | Mit dem Data Fusion-Dienstkonto wird eine Liste von Datenquellenfeldern in der Ads Data Hub-Benutzeroberfläche angezeigt. | ||||||||
| Format | service-some-number@gcp-sa-datafusion.iam.gserviceaccount.com |
||||||||
| Erforderlicher Zugriff |
|
||||||||
| Dataproc-Dienstkonto | |||||||||
| Zweck | Das Dataproc-Dienstkonto ist für das Ausführen der Datenpipelines im Hintergrund zuständig. | ||||||||
| Format | some-number-compute@developer.gserviceaccount.com |
||||||||
| Erforderlicher Zugriff |
|
||||||||
| UPDM-Dienstkonto | |||||||||
| Zweck | Das UPDM-Dienstkonto wird zum Ausführen des Abgleichsjobs verwendet. | ||||||||
| Format | service-some-number@gcp-sa-adsdataconnector.iam.gserviceaccount.com |
||||||||
| Erforderlicher Zugriff |
|
||||||||
Cloud Storage
| Data Fusion-Dienstkonto | |||||||
| Zweck | Mit dem Data Fusion-Dienstkonto wird eine Liste von Datenquellenfeldern in der Ads Data Hub-Benutzeroberfläche angezeigt. | ||||||
| Format | service-some-number@gcp-sa-datafusion.iam.gserviceaccount.com |
||||||
| Erforderlicher Zugriff |
|
||||||
| Dataproc-Dienstkonto | |||||||
| Zweck | Das Dataproc-Dienstkonto ist für das Ausführen der Datenpipelines im Hintergrund zuständig. | ||||||
| Format | some-number-compute@developer.gserviceaccount.com |
||||||
| Erforderlicher Zugriff |
|
||||||
| UPDM-Dienstkonto | |||||||
| Zweck | Das UPDM-Dienstkonto wird zum Ausführen des Abgleichsjobs verwendet. | ||||||
| Format | service-some-number@gcp-sa-adsdataconnector.iam.gserviceaccount.com |
||||||
| Erforderlicher Zugriff |
|
||||||
Sonstige Datenquellen
Für andere Datenquellen nicht erforderlich
Selbst erhobene Daten aufnehmen und abgleichen
Daten für die Eingabe formatieren
Ihre Daten müssen die folgenden Formatierungsanforderungen erfüllen, damit sie richtig zugeordnet werden können:
- Wie in den folgenden Beschreibungen der Eingabefelder angegeben, müssen Sie SHA256-Hashing verwenden.
- Eingabefelder müssen als Strings formatiert sein. Wenn Sie beispielsweise die SHA256-Hash-Funktion von BigQuery mit der Base16-Codierungsfunktion (TO_HEX) verwenden, nutzen Sie die folgende Transformation:
TO_HEX(SHA256(user_data)). - UPDM unterstützt sowohl die Base16- als auch die Base64-Codierung. Die Codierung Ihrer selbst erhobenen Daten muss mit der Decodierung in Ihrer Ads Data Hub-Abfrage übereinstimmen. Wenn Sie die Codierung Ihrer selbst erhobenen Daten ändern, müssen Sie Ihre Ads Data Hub-Abfrage aktualisieren, damit sie aus derselben Basis decodiert. In den folgenden Beispielen wird die Base16-Codierung verwendet.
Nutzer-ID
- Nur Text
- Hashing: Keine
- Entfernen von voran- und nachgestellten Leerzeichen
- Alle Zeichen kleinschreiben
- Geben Sie einen Domainnamen für alle E-Mail-Adressen an, z. B. gmail.com oder hotmail.de.
- Akzente entfernen, z. B. è, é, ê oder ë in e ändern
- Entfernen Sie alle Punkte (.) vor dem Domainnamen in
gmail.com- undgooglemail.com-E-Mail-Adressen. - Hashing: Base16-codierter SHA256-Hash
Gültig:TO_HEX(SHA256("jeffersonloveshiking@gmail.com"))
Ungültig:TO_HEX(SHA256("JéffersonLôvesHiking@gmail.com"))
Telefon
- Leerzeichen entfernen
- Format im E.164-Format, z. B. +14155552671 für die USA oder +442071838750 für das Vereinigte Königreich
- Entfernen Sie alle Sonderzeichen mit Ausnahme des „+“ vor dem Ländercode.
- Hashing: Base16-codierter SHA256-Hash
Gültig:TO_HEX(SHA256("+18005550101"))
Ungültig:TO_HEX(SHA256("(800) 555-0101"))
Vorname
- Leerzeichen entfernen
- Alle Zeichen kleinschreiben
- Entfernen Sie alle Präfixe, z. B. „Frau“. Herr Frau, Dr.
- Entfernen Sie keine Akzente, z. B. è, é, ê oder ë.
- Hashing: Base16-codierter SHA256-Hash
Gültig:TO_HEX(SHA256("daní"))
Ungültig:TO_HEX(SHA256("Daní"))
Nachname
- Leerzeichen entfernen
- Alle Zeichen kleinschreiben
- Entfernen Sie alle Suffixe, z. B. „Jr.“ Sr., 2., 3., II, III, PHD, MD
- Entfernen Sie keine Akzente, z. B. è, é, ê oder ë.
- Hashing: Base16-codierter SHA256-Hash
Gültig:TO_HEX(SHA256("delacruz"))
Ungültig:TO_HEX(SHA256("de la Cruz, Jr."))
Land
- Geben Sie den Ländercode auch dann an, wenn Ihre gesamten Kundendaten aus demselben Land stammen.
- Länderdaten nicht hashen
- Verwenden Sie ISO 3166-1 Alpha-2-Ländercodes.
- Hashing: Keine
Gültig:US
Ungültig:United States of America oder USA
Postleitzahl
- Postleitzahlen nicht hashen
- Sowohl US-amerikanische als auch internationale Postleitzahlen sind zulässig
- Für die USA:
- 5-stellige Codes sind zulässig, z. B. 94043
- Fünf Ziffern, gefolgt von einer 4-stelligen Erweiterung, sind ebenfalls zulässig, z. B. 94043-1351 oder 940431351.
- Für alle anderen Länder:
- Keine Formatierung erforderlich (keine Kleinbuchstaben, keine Leerzeichen und keine Sonderzeichen)
- Lassen Sie Postleitzahlerweiterungen weg.
- Hashing: Keine
Hash-Validierung und Datenverschlüsselung
Mit den folgenden Hash-Validierungsskripts können Sie prüfen, ob Ihre Daten richtig formatiert sind.
JavaScript
Base16
/**
* @fileoverview Provides the hashing algorithm for User-Provided Data Match, as
* well as some valid hashes of sample data for testing.
*/
async function hash(token) {
// Removes leading or trailing spaces and converts all characters to lowercase.
const formattedToken = token.trim().toLowerCase();
// Hashes the formatted string using the SHA-256 hashing algorithm.
const hashArrayBuffer = await crypto.subtle.digest(
'SHA-256', (new TextEncoder()).encode(formattedToken));
// Converts the hash buffer to a hexadecimal string.
return Array.from(new Uint8Array(hashArrayBuffer))
.map((b) => b.toString(16).padStart(2, '0'))
.join('');
}
function main() {
// Expected hash for test@gmail.com:
// 87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674
hash('test@gmail.com').then(result => console.log(result));
// Expected hash for +18005551212:
// 61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44
hash('+18005551212').then(result => console.log(result));
// Expected hash for John:
// 96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a
hash('John').then(result => console.log(result));
// Expected hash for Doe:
// 799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f
hash('Doe').then(result => console.log(result));
}
main()
Base64
/**
* @fileoverview Provides the hashing algorithm, as well as some valid hashes of
* sample data for testing.
*/
async function hash(token) {
// Removes leading or trailing spaces and converts all characters to lowercase.
const formattedToken = token.trim().toLowerCase();
// Hashes the formatted string using the SHA-256 hashing algorithm.
const hashBuffer = await crypto.subtle.digest(
'SHA-256', (new TextEncoder()).encode(formattedToken));
// Converts the hash buffer to a base64-encoded string and returns it.
const base64Str = btoa(String.fromCharCode(...new Uint8Array(hashBuffer)));
return base64Str;
}
function main() {
// Expected hash for test@gmail.com:
// h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
hash('test@gmail.com').then(result => console.log(result));
// Expected hash for +18005551212:
// YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
hash('+18005551212').then(result => console.log(result));
// Expected hash for John: ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
hash('John').then(result => console.log(result));
// Expected hash for Doe: eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
hash('Doe').then(result => console.log(result));
}
main()
Python
Base16
"""Provides the hashing algorithm, as well as some valid hashes of sample data for testing.
Supports: Python 2, Python 3
Sample hashes:
- Email 'test@gmail.com': 87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674
- Phone '+18005551212': 61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44
- First name 'John': 96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a
- Last name 'Doe': 799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f
"""
import base64
import hashlib
def updm_hash(token):
# Generates a SHA-256 hash of the input token after normalization.
return hashlib.sha256(token.strip().lower().encode('utf-8')).hexdigest()
def print_updm_hash(token):
# Prints the SHA-256 hash and the original token.
print('Hash: "{}"\t(Token: {})'.format(updm_hash(token), token))
def main():
# Hashes and prints sample tokens.
print_updm_hash('test@gmail.com')
print_updm_hash('+18005551212')
print_updm_hash('John')
print_updm_hash('Doe')
if __name__ == '__main__':
main()
Base64
"""Provides the hashing algorithm, as well as some valid hashes of sample data for testing.
Supports: Python 2, Python 3
Sample hashes:
- Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
- Phone '+18005551212': YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
- First name 'John': ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
- Last name 'Doe': eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
"""
import base64
import hashlib
def hash(token):
# Generates a base64-encoded SHA-256 hash of a normalized input string.
return base64.b64encode(
hashlib.sha256(
token.strip().lower().encode('utf-8')).digest()).decode('utf-8')
def print_hash(token, expected=None):
# Computes and displays the hash of a token, with optional validation.
hashed = hash(token)
if expected is not None and hashed != expected:
print(
'ERROR: Incorrect hash for token "{}". Expected "{}", got "{}"'.format(
token, expected, hashed))
return
print('Hash: "{}"\t(Token: {})'.format(hashed, token))
def main():
# Tests the hash function with sample tokens and expected results.
print_hash(
'test@gmail.com', expected='h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=')
print_hash(
'+18005551212', expected='YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=')
print_hash('John', expected='ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=')
print_hash('Doe', expected='eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=')
if __name__ == '__main__':
main()
Ok
Base16
/*
Provides the hashing algorithm, as well as some valid hashes of sample data for testing.
Sample hashes:
- Email 'test@gmail.com': 87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674
- Phone '+18005551212': 61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44
- First name 'John': 96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a
- Last name 'Doe': 799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f
*/
package main
import (
"crypto/sha256"
"fmt"
"strings"
)
// Hash hashes an email, phone, first name, or last name into the correct format.
func Hash(token string) string {
formatted := strings.TrimSpace(strings.ToLower(token))
hashed := sha256.Sum256([]byte(formatted))
encoded := fmt.Sprintf("%x", hashed[:])
return encoded
}
// PrintHash prints the hash for a token.
func PrintHash(token string) {
fmt.Printf("Hash: \"%s\"\t(Token: %s)\n", Hash(token), token)
}
func main() {
PrintHash("test@gmail.com")
PrintHash("+18005551212")
PrintHash("John")
PrintHash("Doe")
}
Base64
/*
Provides the hashing algorithm, as well as some valid hashes of sample data for testing.
Sample hashes:
- Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
- Phone '+18005551212': YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
- First name 'John': ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
- Last name 'Doe': eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
*/
package main
import (
"crypto/sha256"
"encoding/base64"
"fmt"
"strings"
)
// Hash hashes an email, phone, first name, or last name into the correct format.
func Hash(token string) string {
formatted := strings.TrimSpace(strings.ToLower(token))
hashed := sha256.Sum256([]byte(formatted))
encoded := base64.StdEncoding.EncodeToString(hashed[:])
return encoded
}
// PrintHash prints the hash for a token.
func PrintHash(token string) {
fmt.Printf("Hash: \"%s\"\t(Token: %s)\n", Hash(token), token)
}
func main() {
PrintHash("test@gmail.com")
PrintHash("+18005551212")
PrintHash("John")
PrintHash("Doe")
}
Java
Base16
package updm.hashing;
import static java.nio.charset.StandardCharsets.UTF_8;
import com.google.common.base.Ascii;
import com.google.common.hash.Hashing;
/**
* Example of the UPDM hashing algorithm using hex-encoded SHA-256.
*
* <p>This uses the Guava Hashing to generate the hash: https://github.com/google/guava
*
* <p>Sample valid hashes:
*
* <ul>
* <li>Email "test@gmail.com": "87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674"
* <li>Phone "+18005551212": "61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44"
* <li>First name "John": "96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a"
* <li>Last name "Doe": "799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f"
* </ul>
*/
public final class HashExample {
private HashExample() {}
public static String hash(String token) {
// Normalizes and hashes the input token.
String formattedToken = Ascii.toLowerCase(token).strip();
return Hashing.sha256().hashString(formattedToken, UTF_8).toString();
}
public static void printHash(String token) {
// Calculates and prints the token's hash.
System.out.printf("Hash: \"%s\"\t(Token: %s)\n", hash(token), token);
}
public static void main(String[] args) {
// Executes hash calculations and prints results for sample tokens.
printHash("test@gmail.com");
printHash("+18005551212");
printHash("John");
printHash("Doe");
}
}
Base64
package updm.hashing;
import static java.nio.charset.StandardCharsets.UTF_8;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;
/**
* Example of the hashing algorithm.
*
* <p>Sample hashes:
*
* <ul>
* <li>Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
* <li>Phone '+18005551212': YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
* <li>First name 'John': ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
* <li>Last name 'Doe': eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
* </ul>
*/
public final class HashExample {
private HashExample() {}
public static String hash(String token) {
// Normalizes and hashes the input token using SHA-256 and Base64 encoding.
String formattedToken = token.toLowerCase().strip();
byte[] hash;
try {
hash = MessageDigest.getInstance("SHA-256").digest(formattedToken.getBytes(UTF_8));
} catch (NoSuchAlgorithmException e) {
throw new IllegalStateException("SHA-256 not supported", e);
}
return Base64.getEncoder().encodeToString(hash);
}
public static void printHash(String token) {
// Calculates and prints the hash for the given token.
System.out.printf("Hash: \"%s\"\t(Token: %s)\n", hash(token), token);
}
public static void main(String[] args) {
// Executes hash calculations and prints results for sample tokens.
printHash("test@gmail.com");
printHash("+18005551212");
printHash("John");
printHash("Doe");
}
}
SQL
Base16
/*
Provides the hashing algorithm, as well as some valid hashes of sample data for testing.
The following code uses Google Standard SQL and can be run on BigQuery to generate match tables from unhashed data.
Sample hashes:
- Email 'test@gmail.com': 87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674
- Phone '+18005551212': 61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44
- First name 'John': 96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a
- Last name 'Doe': 799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f
The unhashed input table schema is assumed to be:
- Column name: UserID, Type: String
- Column name: Email, Type: String
- Column name: Phone, Type: String
- Column name: FirstName, Type: String
- Column name: LastName, Type: String
- Column name: PostalCode, Type: String
- Column name: CountryCode, Type: String
*/
-- Creates a new table with hashed versions of specified columns from the input table.
CREATE TABLE `your_project_name.your_dataset_name.output_hashed_table_name`
AS
SELECT
UserID,
TO_HEX(SHA256(LOWER(Email))) AS Email,
TO_HEX(SHA256(Phone)) AS Phone,
TO_HEX(SHA256(LOWER(FirstName))) AS FirstName,
TO_HEX(SHA256(LOWER(LastName))) AS LastName,
PostalCode,
CountryCode,
FROM
`your_project_name.your_dataset_name.input_unhashed_table_name`;
Base64
/*
Provides the hashing algorithm, as well as some valid hashes of sample data for testing.
The following code uses Google Standard SQL and can be run on BigQuery to generate match tables from unhashed data.
Sample hashes:
- Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
- Phone '+18005551212': YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
- First name 'John': ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
- Last name 'Doe': eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
The unhashed input table schema is assumed to be:
- Column name: UserID, Type: String
- Column name: Email, Type: String
- Column name: Phone, Type: String
- Column name: FirstName, Type: String
- Column name: LastName, Type: String
- Column name: PostalCode, Type: String
- Column name: CountryCode, Type: String
*/
-- Creates a new table with Base64-encoded SHA-256 hashes of specified columns.
CREATE TABLE `your_project_name.your_dataset_name.output_hashed_table_name`
AS
SELECT
UserID,
TO_BASE64(SHA256(LOWER(Email))) AS Email,
TO_BASE64(SHA256(Phone)) AS Phone,
TO_BASE64(SHA256(LOWER(FirstName))) AS FirstName,
TO_BASE64(SHA256(LOWER(LastName))) AS LastName,
PostalCode,
CountryCode,
FROM
`your_project_name.your_dataset_name.input_unhashed_table_name`;
JOIN-Schlüssel
Einige Kombinationen von von Nutzern bereitgestellten Daten sind aussagekräftiger als andere. Im Folgenden finden Sie eine Liste mit verschiedenen Kombinationen von von Nutzern bereitgestellten Daten, sortiert nach relativer Stärke. Wenn Sie eine Adresse verwenden, müssen Sie Folgendes angeben: Vorname, Nachname, Land und Postleitzahl.
- E-Mail-Adresse, Telefonnummer, Adresse (am stärksten)
- Telefon, Adresse
- E‑Mail-Adresse, Adresse
- E‑Mail, Telefon
- Adresse
- Telefon
- E‑Mail-Adresse (am wenigsten sicher)
Match-Table erstellen
- Klicken Sie auf Verbindungen > Verbindung erstellen > Abgleich der von Nutzern bereitgestellten Daten.
- Wählen Sie eine Datenquelle aus und klicken Sie auf Verbinden.
- Authentifizieren Sie sich, wenn Sie dazu aufgefordert werden, und klicken Sie dann auf Weiter:
BigQuery
Klicken Sie auf „Übernehmen“, um Zugriff auf BigQuery zu gewähren.
Cloud Storage
Klicken Sie auf „Übernehmen“, um den Zugriff auf Cloud Storage zu gewähren.
MySQL
Geben Sie den Speicherort Ihrer MySQL-Datenbank, den Port, Ihren Nutzernamen und Ihr Passwort ein.
S3
Geben Sie Ihren geheimen Zugriffsschlüssel für Amazon S3 ein.
PostgreSQL
Geben Sie den Speicherort Ihrer PostgreSQL-Datenbank, den Port, den Nutzernamen, das Passwort und die Datenbank ein.
Redshift
Geben Sie den Speicherort Ihrer Redshift-Datenbank, den Port, den Nutzernamen, das Passwort und die Datenbank ein.
SFTP
Geben Sie den Speicherort, den Nutzernamen und das Passwort für Ihren sFTP-Server ein.
Snowflake
Geben Sie Ihre Snowflake-Konto-ID, Ihren Nutzernamen und Ihr Passwort ein.
- Konfigurieren Sie die Datenquelle und klicken Sie auf Weiter:
BigQuery
Wählen Sie die BigQuery-Tabelle aus, die Sie importieren möchten.
Cloud Storage
Geben Sie den gsutil-Pfad ein, z. B.
gs://my-bucket/folder/, und wählen Sie die Formatierung Ihrer Datei aus.Wenn Sie diese Ressource zum ersten Mal verbinden, wird eine Benachrichtigung angezeigt. Klicken Sie auf „Übernehmen“, um Zugriff zu gewähren, und dann auf „Weiter“. Hinweis: Sie benötigen eine Rolle mit der Berechtigung zum Delegieren von
storage.buckets.setIamPolicyfür den entsprechenden Bucket.MySQL
Wählen Sie die gewünschte MySQL-Datenbank und ‑Tabelle aus.
S3
Geben Sie den URI zu der Datei ein, die Sie hochladen möchten. Er muss relativ zur Hostadresse sein.
PostgreSQL
Geben Sie das PostgreSQL-Schema und den Namen der Tabelle (oder Ansicht) ein.
Redshift
Geben Sie das Redshift-Schema und den Namen der Tabelle (oder Ansicht) ein. Standardmäßig verwendet Redshift Datenbank-URLs, die wie in diesem Beispiel strukturiert sind:
cluster-identifier.account-number.aws-region.redshift.amazonaws.com.SFTP
Geben Sie den Dateipfad und den Namen im Format
/PATH/FILENAME.csvein.Snowflake
Geben Sie die gewünschte Snowflake-Datenbank sowie das Schema und die Tabelle (oder Ansicht) ein, die Sie verwenden möchten.
- Wählen Sie ein BigQuery-Dataset aus, das als Zwischenziel verwendet werden soll, und klicken Sie dann auf Weiter. Dadurch wird sichergestellt, dass die Daten richtig formatiert sind.
- Optional: Ändern Sie das Format Ihrer Daten. Transformationen umfassen das Berechnen von Hashwerten, die Formatierung in Klein-/Großbuchstaben und das Zusammenführen/Aufteilen von Feldern.
- Klicken Sie auf Aktion > > Transformieren.
- Klicken Sie im Pop-up-Fenster auf Transformation hinzufügen oder Weitere Transformation hinzufügen.
- Wählen Sie im Drop-down-Menü einen Transformationstyp aus und geben Sie die Anforderungen ein.
- Klicken Sie auf Speichern.
- Wählen Sie mindestens einen Join-Schlüssel aus und ordnen Sie die Felder zu, die Sie verwenden möchten. Felder mit identischen Namen werden in Ads Data Hub automatisch zugeordnet. Das wird durch ein angezeigt. Nehmen Sie gegebenenfalls Änderungen vor und klicken Sie auf Weiter.
- Zeitplan festlegen:
- Geben Sie der Verbindung einen Namen.
- Legen Sie eine Häufigkeit fest, die bestimmt, wie oft Daten in das Dataset importiert werden, das Sie im vorherigen Schritt ausgewählt haben. Bei jeder Ausführung werden Daten in der Zieltabelle überschrieben.
- Geben Sie an, wie Kollisionen von Nutzer-IDs behandelt werden sollen. Sie können auswählen, ob Sie den vorhandenen Abgleich beibehalten oder mit neuen Daten überschreiben möchten.
- Klicken Sie auf Fertig. Match-Tables können in der Regel 12 Stunden nach ihrer Erstellung abgefragt werden.
Verbindungsdetails ansehen
Auf der Seite mit den Verbindungsdetails finden Sie Informationen zu den letzten Ausführungen und Fehlern einer bestimmten Verbindung. So rufen Sie Details zu einer bestimmten Verbindung auf:
- Klicken Sie auf Verbindungen.
- Klicken Sie auf den Namen der Verbindung, um die Details aufzurufen.
- Sie können sich jetzt die Details der Verbindung und die letzten Ausführungen ansehen. In beiden werden zwei mögliche Fehlertypen angezeigt: Fehler auf Verbindungsebene (die Verbindung wurde nicht ausgeführt) und Fehler auf Zeilenebene (eine Zeile wurde nicht importiert).
- Der Status Fehler gibt an, dass die gesamte Verbindung nicht ausgeführt werden konnte, z.B. aufgrund eines Problems mit der Dienstkontoberechtigung. Klicken Sie auf den Fehlerstatus, um zu sehen, welche Fehler sich auf die Verbindung ausgewirkt haben.
- Der Status Abgeschlossen gibt an, dass die Verbindung erfolgreich hergestellt wurde. Es können jedoch weiterhin Fehler auf Zeilenebene auftreten, die durch einen Wert ungleich null in der Spalte „Zeilen mit Fehlern“ angegeben werden. Klicken Sie auf den Wert, um weitere Informationen zu den fehlgeschlagenen Datensätzen zu erhalten.
Verbindung bearbeiten
Die folgenden Angaben können bearbeitet werden:
- Verbindungsname
- Zeitplan
- Zieltabelle
- Feldzuordnung
Das Bearbeiten von Datenquellen wird nicht unterstützt. Wenn Sie eine Datenquelle ändern möchten, erstellen Sie eine neue Verbindung und löschen Sie die alte.
So bearbeiten Sie Verbindungsdetails:
- Klicken Sie auf Verbindungen.
- Klicken Sie auf den Namen der Verbindung, die Sie bearbeiten möchten.
- Bearbeiten Sie die Details, die Sie ändern möchten:
- Verbindungsname: Klicken Sie auf Bearbeiten, geben Sie den neuen Namen ein und drücken Sie die Eingabetaste.
- Zeitplan: Klicken Sie auf Bearbeiten, legen Sie den neuen Zeitplan fest und klicken Sie dann auf Speichern.
- Zieltabelle: Klicken Sie auf Bearbeiten, geben Sie den neuen Zielnamen ein und klicken Sie dann auf Speichern.
- Feldzuordnung: Klicken Sie auf , nehmen Sie Änderungen an den Feldern vor und klicken Sie dann auf Speichern.
- Klicken Sie auf .
Abfrage von abgeglichenen Daten
Match-Tabellen abfragen
Wenn die Match-Tables genügend Daten enthalten, um die Datenschutzprüfungen zu bestehen, können Sie Abfragen dafür ausführen.
Die Originaltabelle für selbst erhobene Daten wird durch my_data dargestellt.
Dazu gehören sowohl personenidentifizierbare Informationen als auch nicht personenidentifizierbare Daten.
Wenn Sie die Originaltabelle verwenden, können Sie Ihre Berichte mit zusätzlichen Statistiken verbessern, da sie im Vergleich zu einer Match-Table alle selbst erhobenen Daten im entsprechenden Umfang enthält.
Für jede Tabelle im Ads Data Hub-Schema, die ein user_id-Feld enthält, gibt es eine entsprechende Match-Tabelle. Beispielsweise wird für die Tabelle adh.google_ads_impressions in Ads Data Hub auch eine Match-Table mit dem Namen adh.google_ads_impressions_updm erstellt, die Ihre Nutzer-IDs enthält.
Für richtlinienkonform isolierte Netzwerk-Tabellen werden separate Match-Tables erstellt. Beispielsweise wird für die Tabelle adh.google_ads_impressions_policy_isolated_network in Ads Data Hub auch eine Match-Table mit dem Namen adh.google_ads_impressions_policy_isolated_network_updm erstellt, die Ihre Nutzer-IDs enthält.
Diese Tabellen enthalten eine Teilmenge der in den ursprünglichen Tabellen verfügbaren Nutzer, bei denen es eine Übereinstimmung mit der user_id gibt. Wenn die ursprüngliche Tabelle beispielsweise Daten für Nutzer A und Nutzer B enthält, aber nur Nutzer A abgeglichen werden kann, ist Nutzer B nicht in der Match-Table enthalten.
Die Match-Tables enthalten die zusätzliche Spalte customer_data_user_id, in der die Nutzer-ID als BYTES gespeichert wird.
Beim Erstellen von Abfragen ist es wichtig, den Feldtyp zu berücksichtigen. Für SQL-Vergleichsoperatoren ist es erforderlich, dass die zu vergleichenden Literale denselben Typ haben. Je nachdem, wie die user_id in der Tabelle mit selbst erhobenen Daten gespeichert wird, müssen Sie die Werte in der Tabelle möglicherweise codieren, bevor die Daten abgeglichen werden.
Für erfolgreiche Übereinstimmungen müssen Sie den Join-Schlüssel in BYTES umwandeln:
JOIN ON
adh.google_ads_impressions_updm.customer_data_user_id = CAST(my_data.user_id AS BYTES)
Außerdem wird bei Stringvergleichen in SQL die Groß- und Kleinschreibung berücksichtigt. Eventuell müssen Sie also Strings auf beiden Seiten des Vergleichs entsprechend codieren, damit sie richtig verglichen werden können.
Beispielabfragen
Anzahl der übereinstimmenden Nutzer
Mit dieser Abfrage wird die Anzahl der übereinstimmenden Nutzer in Ihrer Google Ads-Tabelle „Impressionen“ gezählt.
/* Count matched users in Google Ads impressions table */
SELECT COUNT(DISTINCT user_id)
FROM adh.google_ads_impressions_updm
Abgleichsrate berechnen
Nicht alle Nutzer kommen für den Abgleich infrage. Abgemeldete Nutzer, Kinder und Nutzer, die keine Einwilligung erteilt haben, werden beispielsweise nicht über UPDM abgeglichen. Mit dem Feld is_updm_eligible lassen sich genauere Abgleichsraten für von Nutzern bereitgestellte Daten berechnen. Das Feld is_updm_eligible ist seit dem 1. Oktober 2024 verfügbar. Vor diesem Datum können Sie dieses Feld nicht verwenden, um Abgleichsraten zu berechnen.
/* Calculate the UPDM match rate */
CREATE TEMP TABLE total_events OPTIONS(privacy_checked_export=TRUE) AS
SELECT
customer_id,
COUNT(*) AS n
FROM adh.google_ads_impressions
WHERE is_updm_eligible
GROUP BY 1;
CREATE TEMP TABLE matched_events OPTIONS(privacy_checked_export=TRUE) AS
SELECT
customer_id,
COUNT(*) AS n
FROM adh.google_ads_impressions_updm
GROUP BY 1;
SELECT
customer_id,
SAFE_DIVIDE(matched_events.n, total_events.n) AS match_rate
FROM total_events
LEFT JOIN matched_events
USING (customer_id)
Selbst erhobene Daten und Google Ads-Daten zusammenführen
In dieser Abfrage wird gezeigt, wie Sie selbst erhobene Daten mit Google Ads-Daten verknüpfen:
/* Join first-party data with Google Ads data. The customer_data_user_id field
contains your ID as BYTES. You need to cast your join key into BYTES for
successful matches. */
SELECT
inventory_type,
COUNT(*) AS impressions
FROM
adh.yt_reserve_impressions_updm AS google_data_imp
LEFT JOIN
`my_data`
ON
google_data_imp.customer_data_user_id = CAST(my_data.user_id AS BYTES)
GROUP BY
inventory_type
Häufig gestellte Fragen zu UPDM
Eine Liste mit häufig gestellten Fragen zu UPDM finden Sie unter Häufig gestellte Fragen zu UPDM.