Interfejs Data Manager API jest dostępny w ramach zamkniętych testów beta. Aby zgłosić chęć udziału w testach zamkniętych, wypełnij ten formularz.

Ta strona została przetłumaczona przez Cloud Translation API.

Konfigurowanie dostępu do interfejsu API

Dowiedz się, jak skonfigurować dostęp do interfejsu Data Manager API za pomocą pakietu SDK lub REST.

Wymagania wstępne

Zanim zaczniesz korzystać z interfejsu Data API, sprawdź, czy masz:

Projekt Google Cloud.
Konto Google, które spełnia oba te kryteria:
1. ma przyznany dostęp do interfejsu Data Manager API po wypełnieniu formularza zainteresowania interfejsem Data Manager API. Jeśli widzisz stronę szczegółów produktu API, masz dostęp.
2. ma uprawnienie serviceusage.services.enable w Twoim projekcie Google Cloud lub ma rolę, która obejmuje to uprawnienie; Na przykład zarówno roles/owner, jak i roles/serviceusage.serviceUsageAdmin zawierają uprawnienie serviceusage.services.enable. Aby sprawdzić uprawnienia, przeczytaj artykuł Wyświetlanie bieżącego dostępu.

Włącz API

Jeśli nie masz jeszcze włączonego interfejsu Data Manager API, kliknij Włącz interfejs Data Manager API lub wykonaj instrukcje, aby ręcznie wykonać ten krok.

Jeśli nie możesz znaleźć interfejsu Data Manager API lub włączenie interfejsu Data Manager API nie działa, sprawdź, czy Twoje konto Google spełnia wymagania wstępne.

Konfigurowanie uwierzytelniania

Możesz użyć dowolnej z metod uwierzytelniania w Google z wyjątkiem kluczy interfejsu API. Zalecamy zapoznanie się z artykułem Wybieranie odpowiedniej metody uwierzytelniania w zależności od przypadku użycia, aby zdecydować, które podejście jest odpowiednie w Twoim przypadku.

Dwie popularne metody uwierzytelniania to konta użytkowników i konta usługi:

Konta użytkowników: reprezentują osoby, które bezpośrednio korzystają z interfejsów API i usług Google.
Konta usługi: reprezentują aplikacje, a nie osoby, jako użytkowników. Umożliwiają one aplikacjom zarządzanie uwierzytelnianiem i autoryzacją. Na przykład jeśli aplikacja potrzebuje dostępu do zasobów Google Cloud.

Integracja może używać domyślnych danych logowania aplikacji (ADC), aby automatycznie znajdować dane logowania w środowisku, dzięki czemu nie musisz zmieniać kodu klienta w celu uwierzytelnienia.

Aby skonfigurować ADC, wybierz Konto użytkownika lub Podszywanie się pod konto usługi:

Aby uwierzytelnić się za pomocą danych logowania konta użytkownika:

Skonfiguruj ustawienia platformy uwierzytelniania Google w projekcie.

Ważne: każda aplikacja Google Cloud używana do uzyskiwania danych logowania użytkownika w zakresie interfejsu Data Manager API musi przejść weryfikację OAuth w Google, aby uniknąć wyświetlania użytkownikom niezweryfikowanego ekranu interfejsu. Weryfikacja OAuth Google nie jest wymagana w przypadku kont usług.
1. Otwórz stronę marki w konsoli Google Cloud.
2. Wybierz projekt.
3. Wypełnij formularz i kliknij Utwórz.
Zakres interfejsu Data Manager API jest zakresem poufnym, dlatego wymagane są te czynności:
1. Otwórz ustawienia Dostęp do danych w projekcie.
2. Kliknij Dodaj lub usuń zakresy.
3. Na liście zakresów zaznacz pole wyboru obok pozycji Interfejs Data Manager API i kliknij Zaktualizuj.
4. Kliknij Zapisz.
5. W konsoli Google Cloud otwórz Odbiorców i zaktualizuj Stan publikacji oraz Typ użytkownika. Więcej informacji o tych ustawieniach znajdziesz w artykule Zarządzanie odbiorcami aplikacji.
Kliknij Utwórz klienta OAuth2, aby utworzyć klienta OAuth2 w projekcie, lub postępuj zgodnie z instrukcjami, aby utworzyć klienta OAuth2 na komputer.

Tworzenie klienta OAuth2
W ostatnim kroku kliknij POBIERZ KONFIGURACJĘ KLIENTA i zanotuj wybraną lokalizację pobierania.
Wygeneruj lokalny plik ADC, uruchamiając to polecenie: To polecenie uruchamia proces internetowy, w którym musisz zalogować się na konto Google używane w interfejsie API.

Zastąp PATH_TO_CLIENT_JSON nazwą pobranego pliku JSON.
```
gcloud auth application-default login \
  --scopes="https://www.googleapis.com/auth/datamanager,https://www.googleapis.com/auth/cloud-platform" \
  --client-id-file="PATH_TO_CLIENT_JSON"
```
Sprawdź, czy dane logowania są prawidłowo skonfigurowane, używając tego polecenia. Jeśli polecenie zadziała, w konsoli zostanie wyświetlony token dostępu.
```
gcloud auth application-default print-access-token
```

Więcej informacji o uwierzytelnianiu i danych logowania aplikacji znajdziesz w artykułach Metody uwierzytelniania w Google i Jak działają domyślne dane logowania aplikacji.

Konfigurowanie dostępu do konta operacyjnego

Przyznaj adresowi e-mail powiązanemu z Twoim kontem użytkownika dostęp do Destination.

Jeśli używasz konta Google Ads lub konta partnera danych, postępuj zgodnie z instrukcjami, aby dodać adres e-mail użytkownika do konta.
Jeśli używasz konta Display & Video 360, postępuj zgodnie z instrukcjami, aby dodać adres e-mail użytkownika do konta.

Konfigurowanie pakietu SDK dla wybranego języka programowania

Zainstaluj na komputerze lokalnym wybrany pakiet SDK:

REST

Zastąp symbole zastępcze w tym przykładzie, np. OPERATING_ACCOUNT_PRODUCT, OPERATING_ACCOUNT_ID i AUDIENCE_ID, wartościami odpowiednimi dla Twojego konta i miejsca docelowego.
Zastąp PROJECT_ID identyfikatorem Google Cloud.

Skopiuj przykład do wiersza poleceń, aby wysłać żądanie.

Usuń atrybut linkedAccount z wpisu w destinations, jeśli nie uzyskujesz dostępu do operatingAccount za pomocą ustalonego linku do produktu.

#!/bin/bash

# Uses gcloud to get an access token. If the Application Default
# Credentials aren't for a service account, the command that specifies
# --scopes fails. This sample falls back to the command without the
# --scopes argument.
DATA_MANAGER_ACCESS_TOKEN="$(gcloud auth application-default print-access-token --scopes=https://www.googleapis.com/auth/datamanager || \
  gcloud auth application-default print-access-token)"

# Fetches and prints the scope information for the access token. If you
# get scope-related errors when you send the request in the next step,
# verify that this output includes the Data Manager API scope:
#   https://www.googleapis.com/auth/datamanager
curl https://www.googleapis.com/oauth2/v1/tokeninfo?access_token="${DATA_MANAGER_ACCESS_TOKEN}"

# Sends the request.
curl -X POST "https://datamanager.googleapis.com/v1/audienceMembers:ingest" \
  --header "Authorization: Bearer ${DATA_MANAGER_ACCESS_TOKEN}" \
  --header "x-goog-user-project: PROJECT_ID" \
  --header "Content-Type: application/json" \
  --data @- <<EOF
{
  "destinations": [
    {
      "operatingAccount": {
        "product": "OPERATING_ACCOUNT_PRODUCT",
        "accountId": "OPERATING_ACCOUNT_ID"
      },
      "loginAccount": {
        "product": "LOGIN_ACCOUNT_PRODUCT",
        "accountId": "LOGIN_ACCOUNT_ID"
      },
      "linkedAccount": {
        "product": "LINKED_ACCOUNT_PRODUCT",
        "accountId": "LINKED_ACCOUNT_ID"
      },
      "productDestinationId": "AUDIENCE_ID"
    }
  ],
  "audienceMembers": [
    {
      "userData": {
        "userIdentifiers": [
          {
            "emailAddress": "07e2f1394b0ea80e2adca010ea8318df697001a005ba7452720edda4b0ce57b3"
          },
          {
            "emailAddress": "1df6b43bc68dd38eca94e6a65b4f466ae537b796c81a526918b40ac4a7b906c7"
          }
        ]
      }
    },
    {
      "userData": {
        "userIdentifiers": [
          {
            "emailAddress": "2ef46c4214c3fc1b277a2d976d55194e12b899aa50d721f28da858c7689756e3"
          },
          {
            "emailAddress": "54e410b14fa652a4b49b43aff6eaf92ad680d4d1e5e62ed71b86cd3188385a51"
          },
          {
            "emailAddress": "e8bd3f8da6f5af73bec1ab3fbf7beb47482c4766dfdfc94e6bd89e359c139478"
          }
        ]
      }
    },
    {
      "userData": {
        "userIdentifiers": [
          {
            "emailAddress": "05bb62526f091b45d20e243d194766cca8869137421047dc53fa4876d111a6f0"
          },
          {
            "emailAddress": "f1fcde379f31f4d446b76ee8f34860eca2288adc6b6d6c0fdc56d9eee75a2fa5"
          }
        ]
      }
    },
    {
      "userData": {
        "userIdentifiers": [
          {
            "emailAddress": "83a834cc5327bc4dee7c5408988040dc5813c7662611cd93b707aff72bf7d33f"
          },
          {
            "emailAddress": "223ebda6f6889b1494551ba902d9d381daf2f642bae055888e96343d53e9f9c4"
          }
        ]
      }
    }
  ],
  "consent": {
    "adUserData": "CONSENT_GRANTED",
    "adPersonalization": "CONSENT_GRANTED"
  },
  "encoding": "HEX",
  "termsOfService": {
    "customerMatchTermsOfServiceStatus": "ACCEPTED"
  },
  "validateOnly": true
}
EOF

.NET

Pobierz i wyodrębnij plik google-cloud-ads-datamanager-v1-csharp.tar.gz.
W projekcie .NET zadeklaruj zależność ProjectReference od biblioteki Data Manager API. Zastąp PATH_TO_CLIENT_LIBRARY lokalizacją, z której wyodrębniono katalog google-cloud-ads-datamanager-v1-csharp z google-cloud-ads-datamanager-v1-csharp.tar.gz.
```
<ProjectReference Include="PATH_TO_CLIENT_LIBRARY\Google.Ads.DataManager.V1\Google.Ads.DataManager.V1.csproj" />
```
Opcjonalnie. Pobierz bibliotekę narzędzi i przykłady kodu.
1. Pobierz i wyodrębnij plik data-manager-dotnet.tar.gz.
2. W projekcie .NET zadeklaruj ProjectReference zależność od biblioteki narzędziowej. Zastąp PATH_TO_UTILITY_LIBRARY lokalizacją, z której wyodrębniono katalog data-manager-dotnet.data-manager-dotnet.tar.gz
```
<ProjectReference Include="PATH_TO_UTILITY_LIBRARY\Google.Ads.DataManager.Util\src\Google.Ads.DataManager.Util.csproj" />
```
3. Aby sformatować dane, użyj narzędzia Formatter w projekcie .NET.
4. Przeglądaj przykładowe fragmenty kodu w podkatalogu samples.
  
  Aby uruchomić przykładowy kod, ustaw zmienną środowiskową DATA_MANAGER_DOTNET_LIB na lokalizację, w której wyodrębniono katalog google-cloud-ads-datamanager-v1-csharp z google-cloud-ads-datamanager-v1-csharp.tar.gz.
```
export DATA_MANAGER_DOTNET_LIB="PATH_TO_CLIENT_LIBRARY"
```
  Przejdź do katalogu samples i użyj polecenia dotnet run, aby uzyskać listę dostępnych próbek.
```
dotnet run --framework net8.0
```
  Podaj argument --help podczas uruchamiania przykładu, aby wydrukować instrukcję użycia z oczekiwanymi parametrami.
```
dotnet run --framework net8.0 -- ingest-audience-members --help
```
  Aby ułatwić Ci rozpoczęcie pracy z przykładowymi danymi, użyj pliku dostępnego pod adresem samples/sampledata/audience_members_1.csv.

Java

Pobierz i wyodrębnij plik google-cloud-ads-datamanager-v1-java.tar.gz.
Przejdź do katalogu google-cloud-ads-datamanager-v1-java.
Uruchom to polecenie, aby skompilować bibliotekę i opublikować ją w lokalnym repozytorium Maven do użycia z Mavenem lub Gradle.
```
./gradlew -Pversion=0.1.0 install
```

W projekcie Java zadeklaruj zależność od biblioteki interfejsu Data Manager API.

Gradle:

implementation 'com.google.cloud:gapic-google-cloud-ads-datamanager-v1-java:0.1.0'

Maven:

<dependency>
  <groupId>com.google.cloud</groupId>
  <artifactId>gapic-google-cloud-ads-datamanager-v1-java</artifactId>
  <version>0.1.0</version>
</dependency>

Opcjonalnie. Pobierz bibliotekę narzędzi i przykłady kodu.
1. Sklonuj repozytorium GitHub.
```
git clone https://github.com/googleads/data-manager-java.git
```
2. Przejdź do katalogu data-manager-java.
3. Skompiluj i opublikuj bibliotekę narzędziową w lokalnym repozytorium Maven.
```
./gradlew data-manager-util:install
```
4. W projekcie Java zadeklaruj zależność od biblioteki narzędziowej.
  
  Gradle:
```
implementation 'com.google.api-ads:data-manager-util:0.1.0'
```
  Maven:
```
<dependency>
   <groupId>com.google.api-ads</groupId>
   <artifactId>data-manager-util</artifactId>
   <version>0.1.0</version>
</dependency>
```
5. Aby sformatować i zaszyfrować dane, użyj narzędzi UserDataFormatter i Encrypter w projekcie Java.
6. Przejrzyj przykłady kodu w podkatalogu data-manager-samples lub na GitHubie. Aby uruchomić przykład z wiersza poleceń, użyj zadania Gradle run.
  
  Na przykład to polecenie uruchamia przykład IngestAudienceMembers i wyświetla instrukcję użycia:
```
./gradlew data-manager-samples:run \
  --args='IngestAudienceMembers --help'
```
  Aby ułatwić Ci rozpoczęcie pracy z przykładowymi danymi, użyj pliku dostępnego pod adresem data-manager-samples/src/main/resources/sampledata/audience_members_1.csv.

Python

Pobierz plik ads-datamanager-v1-py.tar.gz.
Przejdź do katalogu pobranych plików.
Uruchom to polecenie, aby utworzyć bibliotekę i udostępnić ją innym projektom w tym samym środowisku Pythona:
```
pip install ./ads-datamanager-v1-py.tar.gz
```
W projekcie w języku Python zadeklaruj zależność od biblioteki interfejsu Data Manager API. Jeśli na przykład w projekcie używasz pliku requirements.txt, dodaj do niego ten wiersz:
```
google-ads-data-manager=0.1.0
```
Opcjonalnie. Pobierz bibliotekę narzędzi i przykłady kodu.
1. Pobierz i wypakuj plik data-manager-python.tar.gz.
2. Przejdź do katalogu data-manager-python.
3. Aby zainstalować bibliotekę narzędziową w środowisku Pythona, uruchom to polecenie:
```
pip install .
```
4. W projekcie w Pythonie zadeklaruj zależność od biblioteki narzędziowej. Jeśli na przykład w projekcie używasz pliku requirements.txt, dodaj do niego ten wiersz:
```
google-ads-data-manager-util=0.1.0
```
5. Aby sformatować i zaszyfrować dane, użyj narzędzi Formatter i Encrypter w projekcie w Pythonie.
6. Przeglądaj przykładowe fragmenty kodu w podkatalogu samples. Podaj argument --help podczas uruchamiania próbki, aby wydrukować instrukcję użycia z oczekiwanymi parametrami.
  
  Aby ułatwić Ci rozpoczęcie pracy z przykładowymi danymi, użyj pliku dostępnego pod adresem samples/sampledata/audience_members_1.csv.

Node.js

Pobierz i rozpakuj plik ads-datamanager-v1-nodejs.tar.gz.
Przejdź do katalogu ads-datamanager-v1-nodejs.
Uruchom te polecenia, aby skompilować i spakować bibliotekę do pliku .tgz do użycia z npm.
```
npm install
npm pack
```
Polecenia generują archiwum o nazwie google-cloud-datamanager-0.1.0.tgz.
W projekcie Node.js zadeklaruj zależność od biblioteki Data Manager API, dodając wpis dependencies dla pełnej ścieżki i nazwy pliku google-cloud-datamanager-0.1.0.tgz.

PHP

Pobierz i rozpakuj plik google-cloud-ads-datamanager-v1-php.tar.gz.
Przejdź do katalogu google-cloud-ads-datamanager-v1-php.
Aby rozwiązać zależności biblioteki, uruchom to polecenie:
```
composer update --prefer-dist
```
W pliku composer.json projektu PHP na tym samym hoście zadeklaruj zależność od biblioteki Data Manager API, wykonując te czynności:
1. Dodaj sekcję repositories, która wskazuje lokalizację katalogugoogle-cloud-ads-datamanager-v1-php.
```
"repositories" : [
   {
      "type" : "path",
      "url" : "PATH_TO_CLIENT_LIBRARY"
   }
]
```
2. Zadeklaruj zależność od biblioteki Data Manager API.
```
"require": {
   "googleads/data-manager": "^0.1.0"
}
```
(Opcjonalnie) Pobierz bibliotekę narzędzi i przykłady kodu.
1. Pobierz i wyodrębnij plik data-manager-php.tar.gz.
2. Przejdź do katalogu data-manager-php.
3. Aby rozwiązać zależności biblioteki, uruchom to polecenie:
```
composer update --prefer-dist
```
4. W pliku composer.json projektu PHP na tym samym hoście zadeklaruj zależność od biblioteki narzędziowej, wykonując te czynności:
  1. Dodaj wpis w sekcji repositories, który wskazuje lokalizację katalogu data-manager-php.
```
"repositories" : [
   {
      "type" : "path",
      "url" : "PATH_TO_UTILITY_LIBRARY"
   }
]
```
  2. Zadeklaruj zależność od biblioteki narzędziowej.
```
"require": {
   "googleads/data-manager-util": "@dev"
}
```
  Aby sformatować dane, użyj narzędzia Formatter w projekcie PHP.
5. Przeglądaj przykładowe fragmenty kodu w podkatalogu samples. Uruchom przykłady, wykonując te czynności:
  1. Przejdź do katalogu samples.
  2. Ustaw zmienną środowiskową DATA_MANAGER_PHP_LIB na ścieżkę, w której została wyodrębniona biblioteka klienta.
```
export DATA_MANAGER_PHP_LIB="PATH_TO_CLIENT_LIBRARY"
```
  3. Aby rozwiązać zależności biblioteki, uruchom to polecenie:
```
composer update --prefer-dist
```
  4. Uruchom przykłady, przekazując wymagane argumenty. Podczas uruchamiania przykładu przekaż argument --help, aby wydrukować instrukcję użycia z oczekiwanymi parametrami.
  Aby ułatwić Ci rozpoczęcie pracy z przykładowymi danymi, użyj pliku dostępnego pod adresem samples/sampledata/audience_members_1.csv.

Dalsze kroki

Dowiedz się więcej o przesyłaniu danych o odbiorcach.
Dowiedz się więcej o wysyłaniu zdarzeń.
Przejrzyj dokumentację interfejsu REST lub RPC.