Dopasowywanie danych przekazywanych przez użytkowników (UPDM) łączy zebrane przez Ciebie dane własne o użytkowniku (np. informacje z Twoich witryn, aplikacji lub sklepów stacjonarnych) z aktywnością tego samego zalogowanego użytkownika we wszystkich danych reklam Google, w tym w danych należących do Google i przez nią zarządzanych. Obejmuje to dane kupione w usługach Google Marketing Platform (GMP), np. dane YouTube kupione za pomocą Display & Video 360. Nie są obsługiwane inne usługi GMP, które nie są własnością Google ani nie są przez nią zarządzane.
Aby kwalifikować się do dopasowywania danych przekazywanych przez użytkowników, zdarzenie reklamy musi być powiązane z zalogowanym użytkownikiem w danych reklam Google.
W tym dokumencie opisujemy funkcję dopasowywania danych przekazywanych przez użytkowników oraz podajemy wskazówki dotyczące jej konfigurowania i używania.
Omówienie karty Połączenia
Aby uzyskać cenne statystyki dotyczące reklam, często trzeba łączyć dane z wielu źródeł. Stworzenie własnego rozwiązania tego problemu związanego z potokiem danych wymaga znacznych nakładów czasu i pracy inżynierskiej. Strona Połączenia w Centrum danych reklam upraszcza ten proces, ponieważ udostępnia interfejs z instrukcjami krok po kroku, który pomaga importować, przekształcać i dopasowywać dane reklam w BigQuery. Dzięki temu możesz używać ich w zapytaniach w Centrum danych reklam lub w innych usługach, które odczytują informacje z BigQuery. Wzbogacanie zapytań za pomocą danych własnych może zwiększać komfort klientów i jest bardziej odporne na ogólnobranżowe zmiany sposobów śledzenia reklam.
Strona Połączenia jest tworzona za pomocą narzędzi, które umożliwiają szyfrowanie i udostępnianie partnerom informacji umożliwiających identyfikację osób w sposób zapewniający ochronę prywatności. Po wybraniu kolumn zawierających informacje umożliwiające identyfikację użytkownika Centrum danych reklam szyfruje dane, dzięki czemu Twoje dane własne mogą być eksportowane lub odczytywane tylko przez osoby, które mają do tego uprawnienia. Określenie, które dane własne są potrzebne w przypadku pomiaru lub aktywacji, może być trudne, dlatego Centrum danych reklam udostępnia obszerną listę predefiniowanych przypadków użycia, a następnie przeprowadza Cię przez cały proces wyodrębniania, przekształcania i wczytywania danych. Możesz utworzyć wiele typów połączeń, ale w tym dokumencie zakładamy, że używasz strony Połączenia do dopasowywania danych przekazywanych przez użytkowników.
Obsługiwane źródła danych własnych
Możesz importować dane z tych źródeł:
- BigQuery
- Cloud Storage
- Secure FTP (sFTP)
- Płatek śniegu
- MySQL
- PostgreSQL
- Amazon Redshift
- Amazon S3
Dopasowywanie danych przekazywanych przez użytkowników jest dostępne tylko w przypadku zalogowanych użytkowników w zasobach reklamowych należących do Google i zarządzanych przez Google, więc zbliżające się wycofanie plików cookie innych firm nie będzie miało na nie wpływu. Jest bardziej odporne na zmiany zachodzące w branży niż dane innych firm, dzięki czemu może dostarczać bardziej szczegółowych statystyk, co może prowadzić do większego zaangażowania klientów.
Poznaj terminologię
- Połączenie z danymi przekazywanymi przez użytkowników: skonfiguruj połączenie z danymi przekazywanymi przez użytkowników, aby importować i dopasowywać dane, planować importowanie danych, przekształcać dane i dopasowywać dane reklam za pomocą identyfikatora użytkownika. Zdarzenie reklamy musi być powiązane z zalogowanym użytkownikiem w danych reklam Google. Wymaga kilku projektów Google Cloud.
- Połączenie z danymi własnymi: skonfiguruj połączenie z danymi własnymi jako narzędzie do przygotowywania danych, aby planować importowanie i przekształcanie danych bez zaawansowanych funkcji UPDM. Ten typ połączenia wymaga tylko jednego projektu Google Cloud.
- Źródło danych: połączona usługa, zaimportowany plik lub integracja z usługą innej firmy, np. BigQuery.
- Miejsce docelowe: przypadek użycia, czyli zwykle usługa Google lub jej funkcja, w której aktywowane są zaimportowane dane, np. dopasowywanie danych przekazywanych przez użytkowników w Centrum danych reklam.
- Projekt administracyjny: projekt Google Cloud, który zawiera Twoje dane reklamowe w formacie nieprzetworzonym.
- Wyjściowy zbiór danych: zbiór danych BigQuery, w którym Centrum danych reklam zapisuje dane. Domyślnie jest to zbiór danych w projekcie administracyjnym. Aby zmienić go na inny projekt Google Cloud, zobacz Konfigurowanie kont usług.
Podsumowanie procesu
- Konfigurowanie pozyskiwania i dopasowywania danych
- Przyznajesz kontom usługi wymagane uprawnienia w projekcie administracyjnym. Zobacz Konfigurowanie pozyskiwania danych.
- Pozyskiwanie i dopasowywanie danych własnych
- Ty formatujesz i przesyłasz dane własne do zbioru danych BigQuery. Aby uprościć konfigurację, użyj projektu administracyjnego. Możesz jednak użyć dowolnego własnego zbioru danych BigQuery.
- Ty inicjujesz prośbę o dopasowanie danych, tworząc połączenie i ustawiając harmonogram importu.
- Google łączy dane z Twojego projektu z danymi należącymi do Google, które zawierają identyfikator użytkownika Google i zaszyfrowane dane przekazane przez użytkowników, aby tworzyć i aktualizować tabele dopasowań.
- Zobacz Przesyłanie danych własnych
- Ciągłe zapytania w Centrum danych reklam na podstawie dopasowanych danych
- Zapytania do tabel odpowiedników wykonujesz w taki sam sposób jak zwykłe zapytania w Centrum danych reklam. Patrz sekcja Dane pasujące do zapytania.
Więcej informacji o wymaganiach dotyczących prywatności
Zbieranie danych o klientach
Jeśli korzystasz z dopasowywania danych przekazywanych przez użytkowników, musisz przesyłać dane własne. Mogą to być informacje zebrane przez Ciebie w Twoich witrynach, aplikacjach, sklepach stacjonarnych lub inne informacje, które klient udostępnił Ci bezpośrednio.
Musisz:
- zadbać o to, aby w polityce prywatności znalazła się informacja o tym, że dane klientów udostępniasz innym firmom, które świadczą usługi w Twoim imieniu, a jeśli wymaga tego prawo, uzyskać zgodę na udostępnianie danych w ten sposób;
- do przesyłania danych klientów używać wyłącznie interfejsów lub API zatwierdzonych przez Google;
- przestrzegać wszystkich obowiązujących przepisów i regulacji prawnych, w tym wszelkich regulacji wewnętrznych i wytycznych branżowych;
Potwierdzenie samodzielnie uzyskanej zgody użytkowników
Aby móc używać w Centrum danych reklam danych własnych, musisz potwierdzić, że masz uzyskaną prawidłową zgodę użytkowników z Europejskiego Obszaru Gospodarczego na udostępnianie danych Google, która została otrzymana w sposób określony przez politykę w zakresie zgody użytkownika z UE i zasady Centrum danych reklam. To wymaganie obowiązuje w przypadku każdego konta Centrum danych reklam, a swoje potwierdzenie uzyskania zgody użytkowników musisz aktualizować za każdym razem, gdy przesyłasz nowe dane własne. Potwierdzenie to może przekazać w imieniu całego konta dowolny jego użytkownik.
Pamiętaj, że te same reguły dotyczące zapytań kierowanych do usług Google, które obowiązują w przypadku zapytań analitycznych, mają zastosowanie do zapytań UPDM. Na przykład, gdy tworzysz tabelę odpowiedników, nie możesz wykonywać zapytań dotyczących użytkowników z Europejskiego Obszaru Gospodarczego i obejmujących różne usługi.
Aby dowiedzieć się, jak potwierdzić w Centrum danych reklam uzyskanie zgody użytkowników, zapoznaj się z artykułem Wymagania dotyczące uzyskiwania zgody użytkowników w Europejskim Obszarze Gospodarczym.
Rozmiar danych
Aby chronić prywatność użytkowników, dopasowywanie danych przekazywanych przez użytkowników wymaga spełnienia tych warunków dotyczących rozmiaru danych:
- Musisz przesłać co najmniej 1000 rekordów na liście użytkowników.
- Każda aktualizacja tabeli dopasowań musi zawierać minimalną liczbę nowo dopasowanych użytkowników. Działanie to jest podobne do sprawdzania różnic.
- Lista nie może przekraczać maksymalnej liczby rekordów. Aby dowiedzieć się więcej o maksymalnym limicie danych, skontaktuj się z przedstawicielem Google.
Konfigurowanie pozyskiwania danych
Zanim zaczniesz, musisz skonfigurować konto Centrum danych reklam, aby utworzyć połączenia danych. W ten sposób utworzysz potok dopasowywania danych. Wystarczy, że tylko raz wykonasz te kroki.
Na stronie Połączenia kliknij Rozpocznij konfigurację, aby otworzyć kreator konfiguracji konta na etapie włączania UPDM.
Jakie uprawnienia są przyznawane w przypadku BigQuery i Cloud Storage?
Jeśli skonfigurujesz UPDM do używania z BigQuery lub Cloud Storage, skorzystaj z tego dokumentu, aby dowiedzieć się, jakie uprawnienia są przyznawane kontom usługi Centrum danych reklam.
BigQuery
| Konto usługi Data Fusion | |||||||||
| Cel | Konto usługi Data Fusion służy do wyświetlania listy pól źródłowych w interfejsie Centrum danych reklam. | ||||||||
| Format | service-some-number@gcp-sa-datafusion.iam.gserviceaccount.com |
||||||||
| Wymagany dostęp |
|
||||||||
| Konto usługi Dataproc | |||||||||
| Cel | Konto usługi Dataproc odpowiada za uruchamianie potoków danych w tle. | ||||||||
| Format | some-number-compute@developer.gserviceaccount.com |
||||||||
| Wymagany dostęp |
|
||||||||
| Konto usługi UPDM | |||||||||
| Cel | Konto usługi UPDM jest używane do uruchamiania pasującego zadania. | ||||||||
| Format | service-some-number@gcp-sa-adsdataconnector.iam.gserviceaccount.com |
||||||||
| Wymagany dostęp |
|
||||||||
Cloud Storage
| Konto usługi Data Fusion | |||||||
| Cel | Konto usługi Data Fusion służy do wyświetlania listy pól źródłowych w interfejsie Centrum danych reklam. | ||||||
| Format | service-some-number@gcp-sa-datafusion.iam.gserviceaccount.com |
||||||
| Wymagany dostęp |
|
||||||
| Konto usługi Dataproc | |||||||
| Cel | Konto usługi Dataproc odpowiada za uruchamianie potoków danych w tle. | ||||||
| Format | some-number-compute@developer.gserviceaccount.com |
||||||
| Wymagany dostęp |
|
||||||
| Konto usługi UPDM | |||||||
| Cel | Konto usługi UPDM jest używane do uruchamiania pasującego zadania. | ||||||
| Format | service-some-number@gcp-sa-adsdataconnector.iam.gserviceaccount.com |
||||||
| Wymagany dostęp |
|
||||||
Inne źródła danych
Nie jest to konieczne w przypadku innych źródeł danych
Przetwarzanie i dopasowywanie danych własnych
Formatowanie danych wejściowych
Aby dane zostały prawidłowo dopasowane, muszą spełniać te wymagania dotyczące formatowania:
- W miejscach wskazanych w opisach pól wejściowych musisz przesłać dane zaszyfrowane za pomocą algorytmu SHA256.
- Pola wejściowe muszą być sformatowane jako ciągi znaków. Jeśli na przykład używasz funkcji skrótu SHA256 BigQuery z funkcją kodowania Base16 (TO_HEX), użyj tej transformacji:
TO_HEX(SHA256(user_data)). - UPDM obsługuje kodowanie Base16 i Base64. Kodowanie danych własnych musi być zgodne z dekodowaniem używanym w zapytaniu w Centrum danych reklam. Jeśli zmienisz kodowanie danych własnych, musisz zaktualizować zapytanie Centrum danych reklam, aby dekodować dane z tej samej bazy. W poniższych przykładach użyto kodowania Base16.
Identyfikator użytkownika
- Zwykły tekst
- Haszowanie: brak
- Usuwanie spacji na początku i na końcu
- Używaj tylko małych liter.
- Wszystkie adresy e-mail muszą zawierać domenę, np. gmail.com lub hotmail.co.jp
- usuwać znaki diakrytyczne – np. zamieniać è, é, ê lub ë na e;
- usunąć wszystkie kropki (.) poprzedzające nazwę domeny w adresach e-mail
gmail.comigooglemail.com. - Szyfrowanie: SHA256 zakodowany w Base16
Prawidłowy: TO_HEX(SHA256("jeffersonloveshiking@gmail.com"))
Nieprawidłowy: TO_HEX(SHA256("JéffersonLôvesHiking@gmail.com"))
Telefon
- Usuń spacje
- Format w formacie E.164 – np. w przypadku Stanów Zjednoczonych: +14155552671, a w przypadku Wielkiej Brytanii: +442071838750
- Usuń wszystkie znaki specjalne z wyjątkiem znaku „+” przed kodem kraju.
- Szyfrowanie: SHA256 zakodowany w Base16
Prawidłowy: TO_HEX(SHA256("+18005550101"))
Nieprawidłowy: TO_HEX(SHA256("(800) 555-0101"))
Imię
- Usuń spacje
- Używaj tylko małych liter.
- Usuń wszystkie prefiksy, np. Pani, Panie, Ms., Dr
- Nie usuwaj znaków diakrytycznych, np. è, é, ê czy ë.
- Szyfrowanie: SHA256 zakodowany w Base16
Prawidłowy: TO_HEX(SHA256("daní"))
Nieprawidłowy: TO_HEX(SHA256("Daní"))
Nazwisko
- Usuń spacje
- Używaj tylko małych liter.
- Usuń wszystkie sufiksy, np. Jr., Sr., 2nd, 3rd, II, III, PHD, MD
- Nie usuwaj znaków diakrytycznych, np. è, é, ê czy ë.
- Szyfrowanie: SHA256 zakodowany w Base16
Prawidłowy: TO_HEX(SHA256("delacruz"))
Nieprawidłowy: TO_HEX(SHA256("de la Cruz, Jr."))
Kraj
- Podaj kod kraju, nawet jeśli wszyscy Twoi klienci pochodzą z tego samego kraju
- Nie szyfruj danych kraju
- Używaj kodów krajów w formacie ISO 3166-1 alpha-2.
- Haszowanie: brak
Prawidłowy: US
Nieprawidłowy: United States of America lub USA
Kod pocztowy
- Nie szyfruj danych kodu pocztowego
- Dopuszczalne są zarówno amerykańskie, jak i międzynarodowe kody pocztowe
- W przypadku Stanów Zjednoczonych:
- Dozwolone są kody 5-cyfrowe, np. 94043.
- Format pięciocyfrowy z czterocyfrowym rozszerzeniem jest również dozwolony, np. 94043-1351 lub 940431351
- W przypadku pozostałych krajów:
- Nie wymaga formatowania (nie musisz zmieniać wielkości liter ani usuwać spacji i znaków specjalnych).
- Nie dodawaj rozszerzeń kodu pocztowego
- Haszowanie: brak
Weryfikacja skrótu i kodowanie danych
Aby mieć pewność, że dane są prawidłowo sformatowane, możesz użyć tych skryptów do sprawdzania poprawności haszowania.
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()
Przeczytaj
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`;
Połącz klucze
Niektóre kombinacje danych przekazywanych przez użytkowników są bardziej skuteczne niż inne. Poniżej znajdziesz listę różnych kombinacji danych przekazywanych przez użytkowników, uporządkowanych według względnej siły. Jeśli używasz adresu, musisz podać imię, nazwisko, kraj i kod pocztowy.
- Adres e-mail, numer telefonu, adres (najsilniejszy)
- Telefon, adres
- Adres e-mail, adres
- E-mail, telefon
- Adres
- Telefon
- E-mail (najsłabszy)
Tworzenie tabeli dopasowań
- Kliknij Połączenia > Utwórz połączenie > Dopasowywanie danych własnych i przekazywanych przez użytkowników.
- Wybierz źródło danych i kliknij Połącz.
- W razie potrzeby uwierzytelnij się, a następnie kliknij Dalej:
BigQuery
Kliknij Zastosuj, aby przyznać dostęp do BigQuery.
Cloud Storage
Aby przyznać dostęp do Cloud Storage, kliknij Zastosuj.
MySQL
Wpisz lokalizację, port, nazwę użytkownika i hasło do bazy danych MySQL.
S3
Wpisz swój tajny klucz dostępu Amazon S3.
PostgreSQL
Wpisz lokalizację, port, nazwę użytkownika, hasło i nazwę bazy danych PostgreSQL.
Redshift
Wpisz lokalizację, port, nazwę użytkownika, hasło i nazwę bazy danych Redshift.
sFTP
Wpisz lokalizację serwera sFTP, nazwę użytkownika i hasło.
Płatek śniegu
Wpisz identyfikator konta Snowflake, nazwę użytkownika i hasło.
- Skonfiguruj źródło danych, a następnie kliknij Dalej:
BigQuery
Wybierz tabelę BigQuery do zaimportowania.
Cloud Storage
Wpisz ścieżkę gsutil, np.
gs://my-bucket/folder/, i wybierz format pliku.Jeśli łączysz ten zasób po raz pierwszy, pojawi się alert. Aby przyznać dostęp, kliknij kolejno Zastosuj i Dalej. Uwaga: musisz mieć rolę z uprawnieniami do przekazywania uprawnień
storage.buckets.setIamPolicydo odpowiedniego zasobnika.MySQL
Wybierz bazę danych i tabelę MySQL, których chcesz używać.
S3
Wpisz identyfikator URI pliku, który chcesz przesłać (względny w stosunku do adresu hosta).
PostgreSQL
Wpisz nazwę schematu i tabeli (lub widoku) w PostgreSQL.
Redshift
Wpisz nazwę schematu i tabeli (lub widoku) w Redshift. Domyślnie Redshift używa adresów URL lokalizacji bazy danych zgodnych z tym szablonem:
cluster-identifier.account-number.aws-region.redshift.amazonaws.com.sFTP
Wpisz ścieżkę i nazwę pliku w formacie
/PATH/FILENAME.csvPłatek śniegu
Wpisz nazwę bazy danych, schematu i tabeli (lub widoku) w Snowflake, których chcesz używać.
- Wybierz zbiór danych BigQuery, który ma służyć jako pośrednie miejsce docelowe, a potem kliknij Dalej. Dzięki temu będziesz mieć pewność, że dane są prawidłowo sformatowane.
- Opcjonalnie: zmień format danych. Przekształcenia obejmują obliczanie skrótu, formatowanie małych i wielkich liter oraz łączenie i dzielenie pól.
- Kliknij Działanie > > Przekształć.
- W wyświetlonym panelu kliknij Dodaj przekształcenie lub Dodaj kolejne przekształcenie.
- Wybierz w menu typ przekształcenia i wpisz wymagania.
- Kliknij Zapisz.
- Wybierz co najmniej 1 klucz złączenia i zmapuj pola, których będziesz używać. Centrum danych reklam automatycznie mapuje pola o identycznych nazwach, co jest oznaczone symbolem . Wprowadź niezbędne zmiany, a potem kliknij Dalej.
- Ustaw harmonogram:
- Nazwij połączenie.
- Ustaw częstotliwość, która określa, jak często dane będą importowane do zbioru danych wybranego w poprzednim kroku. Każde uruchomienie zastąpi dane w tabeli docelowej.
- Określ, jak chcesz obsługiwać kolizje identyfikatorów użytkowników. Możesz zachować dotychczasowe dopasowanie lub zastąpić je nowymi danymi.
- Kliknij Zakończ. Tabele odpowiedników są zwykle gotowe do wykonywania zapytań 12 godzin po ich utworzeniu.
Wyświetlanie szczegółów połączenia
Na stronie szczegółów połączenia znajdziesz informacje o ostatnich uruchomieniach i błędach danego połączenia. Aby wyświetlić szczegóły konkretnego połączenia:
- Kliknij Połączenia.
- Kliknij nazwę połączenia, aby wyświetlić jego szczegóły.
- Możesz teraz wyświetlać szczegóły połączenia i ostatnie uruchomienia. Każdy z nich pokazuje 2 możliwe typy błędów: na poziomie połączenia (połączenie nie zostało uruchomione) i na poziomie wiersza (wiersz nie został zaimportowany).
- Stan Nie udało się oznacza, że nie udało się uruchomić całego połączenia (np. z powodu problemu z uprawnieniami konta usługi). Kliknij stan błędu, aby sprawdzić, które błędy wpłynęły na połączenie.
- Stan Ukończono oznacza, że połączenie zostało uruchomione. Mogą jednak nadal występować błędy na poziomie wiersza, co wskazuje wartość inną niż zero w kolumnie „Wiersze z błędami”. Kliknij wartość, aby dowiedzieć się więcej o tym, które rekordy nie zostały przetworzone.
Edytowanie połączenia
Możesz edytować te szczegóły:
- Nazwa połączenia
- Zaplanuj
- Tabela docelowa
- Mapowanie pól
Edytowanie źródła danych nie jest obsługiwane. Aby zmienić źródło danych, utwórz nowe połączenie i usuń stare.
Aby edytować szczegóły połączenia:
- Kliknij Połączenia.
- Kliknij nazwę połączenia, które chcesz edytować.
- Edytuj szczegóły, które chcesz zmienić:
- Nazwa połączenia: kliknij Edytuj, wpisz nową nazwę, a potem naciśnij Enter.
- Harmonogram: kliknij Edytuj, ustaw nowy harmonogram, a potem kliknij Zapisz.
- Tabela docelowa: kliknij Edytuj, wpisz nową nazwę miejsca docelowego, a następnie kliknij Zapisz.
- Mapowanie pól: kliknij , wprowadź zmiany w polach, a następnie kliknij Zapisz.
- Kliknij .
Wykonywanie zapytań na dopasowanych danych
Wykonywanie zapytań dotyczących tabel odpowiedników
Gdy tabele odpowiedników zawierają wystarczającą ilość danych, aby spełnić wymagania mechanizmów kontroli prywatności, możesz wykonywać zapytania dotyczące tych tabel.
Oryginalna tabela danych własnych jest oznaczona symbolem my_data.
Obejmuje to zarówno informacje umożliwiające identyfikację osoby, jak i dane, które nie umożliwiają identyfikacji osoby.
Korzystanie z tabeli pierwotnej może wzbogacić raporty o dodatkowe statystyki, ponieważ w porównaniu z tabelą odpowiedników zawiera ona wszystkie dane własne w zakresie.
Każdej tabeli w schemacie Centrum danych reklam, która zawiera pole user_id, towarzyszy tabela odpowiedników. Na przykład w przypadku tabeli adh.google_ads_impressions Centrum danych reklam generuje też tabelę odpowiedników o nazwie adh.google_ads_impressions_updm, która zawiera Twoje identyfikatory użytkowników.
W przypadku tabel sieciowych odseparowanych zgodnie z zasadami tworzone są osobne tabele odpowiedników. Na przykład w przypadku tabeli adh.google_ads_impressions_policy_isolated_network Centrum danych reklam generuje też tabelę odpowiedników o nazwie adh.google_ads_impressions_policy_isolated_network_updm, która zawiera Twoje identyfikatory użytkowników.
Te tabele obejmują podzbiór użytkowników dostępnych w pierwotnych tabelach dopasowanych do identyfikatorów user_id. Jeśli na przykład pierwotna tabela zawiera dane dotyczące użytkowników A i B, ale dopasowane zostanie tylko konto użytkownika A, użytkownik B nie znajdzie się w tabeli odpowiedników.
Tabele odpowiedników zawierają dodatkową kolumnę o nazwie customer_data_user_id, która przechowuje identyfikator użytkownika w postaci bajtów.
Podczas tworzenia zapytań należy zwracać uwagę na typ pola. Operatory porównania SQL wymagają, aby porównywane literały były tego samego typu. Ostrzeżenie: w zależności od sposobu, w jaki w tabeli danych własnych przechowywane są dane (user_id), przed przystąpieniem do dopasowywania danych może być konieczne zakodowanie wartości w tabeli.
Aby zapewnić prawidłowe dopasowanie, musisz przeformatować klucz łączenia na bajty:
JOIN ON
adh.google_ads_impressions_updm.customer_data_user_id = CAST(my_data.user_id AS BYTES)
Poza tym porównania ciągów znaków w języku SQL uwzględniają wielkość liter, więc dokładne porównywanie ciągów znaków może wymagać ich zakodowania po obu stronach porównania.
Przykładowe zapytania
Liczba dopasowanych użytkowników
To zapytanie zlicza liczbę dopasowanych użytkowników w tabeli wyświetleń Google Ads.
/* Count matched users in Google Ads impressions table */
SELECT COUNT(DISTINCT user_id)
FROM adh.google_ads_impressions_updm
Obliczanie współczynnika dopasowania
Nie wszyscy użytkownicy kwalifikują się do dopasowania. Na przykład wylogowani użytkownicy, dzieci i użytkownicy, którzy nie wyrazili zgody, nie są dopasowywani za pomocą UPDM. Aby obliczyć dokładniejsze współczynniki dopasowania w ramach dopasowywania danych własnych i przekazywanych przez użytkowników, możesz użyć pola is_updm_eligible. Pamiętaj, że pole is_updm_eligible jest dostępne od 1 października 2024 r. Przed tą datą nie możesz używać tego pola do obliczania współczynników dopasowania.
/* 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)
Łączenie danych własnych i danych Google Ads
To zapytanie pokazuje, jak złączyć dane własne z danymi Google Ads:
/* 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
Najczęstsze pytania dotyczące UPDM
Listę najczęstszych pytań dotyczących UPDM znajdziesz w tym artykule.