Dienstkonto verwenden

Ein Dienstkonto ist ein Google-Konto, das von einer Anwendung verwendet werden kann, um programmatisch mit OAuth 2.0 auf Google APIs zuzugreifen. Dafür ist keine Autorisierung durch eine Person erforderlich. Stattdessen wird eine Schlüsseldatei verwendet, auf die nur Ihre Anwendung zugreifen kann.

Bevor Sie mehr über Dienstkonten lesen, sollten Sie den einfacheren und sehr empfehlenswerten OAuth 2.0-Flow für installierte Anwendungen in Betracht ziehen. Bei diesem Ablauf ist zwar eine manuelle Nutzerinteraktion erforderlich, um Ihre Anwendung zu autorisieren, dieser Schritt muss jedoch nur einmal ausgeführt werden und ist in Ihrer Produktionsumgebung nicht erforderlich. Die mit diesem Ablauf generierten Aktualisierungstokens laufen nie ab, können im Cache gespeichert und in verschiedenen Umgebungen bereitgestellt werden und lassen sich verwenden, um bei Bedarf ohne Nutzerinteraktion Zugriffstokens zu generieren.

Sie lesen immer noch weiter? Sie können ein Dienstkonto auf eine der folgenden Arten verwenden:

  • Erstellen Sie einen Display & Video 360-Nutzer, der mit Ihrem Dienstkonto verknüpft ist. In diesem Szenario verhält sich Ihr Dienstkonto wie ein normales Nutzerkonto und Sie können auf alle Partner und Werbetreibenden zugreifen, für die der Nutzer eingerichtet wurde. Dies ist die bevorzugte Methode für die Verwendung von Dienstkonten mit Display & Video 360.
  • Verwenden Sie die domainweite Delegierung, um Anfragen im Namen eines oder mehrerer Display & Video 360-Nutzer zu stellen, die mit Konten unter einer G Suite-Domain verknüpft sind. In diesem Fall müssen Sie Administratorzugriff auf die Zieldomain haben. Hilfe zur G Suite- und Domainkonfiguration finden Sie auf der G Suite-Supportseite.

Vorbereitung

Wenn Sie ein Dienstkonto verwenden möchten, das mit einem Display & Video 360-Nutzer verknüpft ist, wählen Sie den Tab DV360-Nutzer aus. Wenn Sie die domainweite Delegierung verwenden möchten, wählen Sie den Tab Delegierung aus.

DV360-Nutzer

Ein Display & Video 360-Nutzer muss mit Ihrem Dienstkonto verknüpft sein.

Ermächtigung

  1. Sie benötigen Administratorzugriff auf eine Domain, die bei G Suite registriert ist.
  2. Sie müssen mindestens einen Display & Video 360-Nutzer mit Konten unter Ihrer in G Suite registrierten Domain verknüpft haben. Nutzer, die mit Konten unter anderen Domains (z. B. gmail.com) verknüpft sind, können nicht verwendet werden.

Dienstkonto konfigurieren und verwenden

DV360-Nutzer

  1. Generieren Sie in der Google API Console einen Dienstkontoschlüssel.

  2. Verknüpfen Sie den Display & Video 360-Nutzer mit der im vorherigen Schritt abgerufenen Dienstkonto-E-Mail-Adresse, wie im Hilfeartikel Nutzer in Display & Video 360 verwalten beschrieben.

  3. Implementieren Sie den OAuth 2.0-Ablauf von Server zu Server in Ihrer Anwendung und verwenden Sie dabei das neu erstellte Dienstkonto. Weitere Informationen finden Sie im Abschnitt Beispiele.

Ermächtigung

  1. Generieren Sie in der Google API Console einen Dienstkontoschlüssel.

  2. Delegieren Sie die domainweiten Befugnisse an dieses Dienstkonto, damit es die Identität von Nutzern in Ihrer Domain übernehmen kann. Geben Sie bei Aufforderung die folgenden API-Bereiche an:

    Umfang Bedeutung
    https://www.googleapis.com/auth/display-video Lese-/Schreibzugriff
    https://www.googleapis.com/auth/display-video-user-management Lese-/Schreibzugriff für den Dienst users. Nur für Dienstkontonutzer verfügbar.

  3. Implementieren Sie den OAuth 2.0-Ablauf von Server zu Server in Ihrer Anwendung und verwenden Sie dabei das neu erstellte Dienstkonto. Weitere Informationen finden Sie im Abschnitt Beispiele. Sie müssen ein Konto angeben, dessen Identität übernommen werden soll. Es muss zu der Domain gehören, für die Ihrem Dienstkonto im vorherigen Schritt die domainweiten Befugnisse delegiert wurden.

Hilfe bei der G Suite- und / oder Domainkonfiguration finden Sie auf der G Suite-Supportseite.

Beispiele

Java

import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.services.displayvideo.v4.DisplayVideo;
import com.google.api.services.displayvideo.v4.DisplayVideoScopes;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableSet;
import java.io.FileInputStream;

/**
 * This example demonstrates how to authenticate using a service account.
 */
public class AuthenticateUsingServiceAccount {
  // Path to a JSON file containing service account credentials for this application. This file can
  // be downloaded from the Credentials tab on the Google API Console.
  private static final String PATH_TO_JSON_FILE = "ENTER_PATH_TO_CLIENT_SECRETS_HERE";

  /**
   * An optional Google account email to impersonate. Only applicable to service accounts which have
   * enabled domain-wide delegation and wish to make API requests on behalf of an account within
   * their domain. Setting this field will not allow you to impersonate a user from a domain you
   * don't own (e.g., gmail.com).
   */
  private static final String EMAIL_TO_IMPERSONATE = "";

  // The OAuth 2.0 scopes to request.
  private static final ImmutableSet OAUTH_SCOPES =
      ImmutableSet.copyOf(DisplayVideoScopes.all());

  private static Credential getServiceAccountCredential(
      String pathToJsonFile, String emailToImpersonate) throws Exception {
    // Generate a credential object from the specified JSON file.
    GoogleCredential credential = GoogleCredential.fromStream(new FileInputStream(pathToJsonFile));

    // Update the credential object with appropriate scopes and impersonation info (if applicable).
    if (Strings.isNullOrEmpty(emailToImpersonate)) {
      credential = credential.createScoped(OAUTH_SCOPES);
    } else {
      credential =
          new GoogleCredential.Builder()
              .setTransport(credential.getTransport())
              .setJsonFactory(credential.getJsonFactory())
              .setServiceAccountId(credential.getServiceAccountId())
              .setServiceAccountPrivateKey(credential.getServiceAccountPrivateKey())
              .setServiceAccountScopes(OAUTH_SCOPES)
              // Set the email of the user you are impersonating (this can be yourself).
              .setServiceAccountUser(emailToImpersonate)
              .build();
    }

    return credential;
  }

  public static void main(String[] args) throws Exception {
    // Build service account credential.
    Credential credential = getServiceAccountCredential(PATH_TO_JSON_FILE, EMAIL_TO_IMPERSONATE);

    // Create a DisplayVideo service instance.
    //
    // Note: application name below should be replaced with a value that identifies your
    // application. Suggested format is "MyCompany-ProductName/Version.MinorVersion".
    DisplayVideo service =
        new DisplayVideo.Builder(credential.getTransport(), credential.getJsonFactory(), credential)
            .setApplicationName("displayvideo-java-service-acct-sample")
            .build();

    // Make API requests.
  }
}

Python

"""This example demonstrates how to authenticate using a service account.

An optional Google account email to impersonate may be specified as follows:
    authenticate_using_service_account.py <path_to_json_file> -i <email>

This optional flag only applies to service accounts which have domain-wide
delegation enabled and wish to make API requests on behalf of an account
within that domain. Using this flag will not allow you to impersonate a
user from a domain you don't own (e.g., gmail.com).
"""

import argparse
import sys

from googleapiclient import discovery
import httplib2
from oauth2client import client
from oauth2client import tools
from oauth2client.service_account import ServiceAccountCredentials

# Declare command-line flags.
argparser = argparse.ArgumentParser(add_help=False)
argparser.add_argument(
    'path_to_service_account_json_file',
    help='Path to the service account JSON file to use for authenticating.')
argparser.add_argument(
    '-i',
    '--impersonation_email',
    help='Google account email to impersonate.')

API_NAME = 'displayvideo'
API_VERSION = 'v4'
API_SCOPES = ['https://www.googleapis.com/auth/display-video']


def main(argv):
  # Retrieve command line arguments.
  parser = argparse.ArgumentParser(
      description=__doc__,
      formatter_class=argparse.RawDescriptionHelpFormatter,
      parents=[tools.argparser, argparser])
  flags = parser.parse_args(argv[1:])

  # Authenticate using the supplied service account credentials
  http = authenticate_using_service_account(
      flags.path_to_service_account_json_file,
      flags.impersonation_email)

  # Build a service object for interacting with the API.
  service = discovery.build(API_NAME, API_VERSION, http=http)

  # Make API requests.

def authenticate_using_service_account(path_to_service_account_json_file,
                                       impersonation_email):
  """Authorizes an httplib2.Http instance using service account credentials."""
  # Load the service account credentials from the specified JSON keyfile.
  credentials = ServiceAccountCredentials.from_json_keyfile_name(
      path_to_service_account_json_file,
      scopes=API_SCOPES)

  # Configure impersonation (if applicable).
  if impersonation_email:
    credentials = credentials.create_delegated(impersonation_email)

  # Use the credentials to authorize an httplib2.Http instance.
  http = credentials.authorize(httplib2.Http())

  return http


if __name__ == '__main__':
  main(sys.argv)

PHP

/**
 * This example demonstrates how to authenticate using a service account.
 *
 * The optional flag email parameter only applies to service accounts which have
 * domain-wide delegation enabled and wish to make API requests on behalf of an
 * account within that domain. Using this flag will not allow you to impersonate
 * a user from a domain that you don't own (e.g., gmail.com).
 */
class AuthenticateUsingServiceAccount
{
    // The OAuth 2.0 scopes to request.
    private static $OAUTH_SCOPES = [Google_Service_DisplayVideo::DISPLAY_VIDEO];

    public function run($pathToJsonFile, $email = null)
    {
        // Create an authenticated client object.
        $client = $this->createAuthenticatedClient($pathToJsonFile, $email);

        // Create a Dfareporting service object.
        $service = new Google_Service_DisplayVideo($client);

        // Make API requests.
    }

    private function createAuthenticatedClient($pathToJsonFile, $email)
    {
        // Create a Google_Client instance.
        //
        // Note: application name should be replaced with a value that identifies
        // your application. Suggested format is "MyCompany-ProductName".
        $client = new Google_Client();
        $client->setApplicationName('PHP service account sample');
        $client->setScopes(self::$OAUTH_SCOPES);

        // Load the service account credentials.
        $client->setAuthConfig($pathToJsonFile);

        // Configure impersonation (if applicable).
        if (!is_null($email)) {
            $client->setSubject($email);
        }

        return $client;
    }
}