Ein Dienstkonto ist ein Google-Konto, das von einer Anwendung verwendet werden kann. um über OAuth 2.0 programmatisch auf Google APIs zuzugreifen. Dies erfordert keine menschliche Autorisierung verwendet. Stattdessen wird eine Schlüsseldatei verwendet, die nur Ihre Anwendung Zugriff haben.
Bevor Sie mehr über Dienstkonten lesen, überlegen Sie, welches einfachere und ausführlichere dringend empfohlener Ablauf für installierte OAuth 2.0-Anwendungen. Während Dieser Ablauf erfordert eine manuelle Nutzerinteraktion, um Ihre Anwendung zu autorisieren. darf nur einmal ausgeführt werden und muss nicht in der Produktionsumgebung erfolgen. Die von diesem Ablauf generierten Aktualisierungstokens laufen niemals ab, können im Cache gespeichert und in verschiedenen Umgebungen bereitgestellt und können zum Generieren von Zugriffstokens verwendet werden, ohne Interaktion der Nutzer.
Sie lesen immer noch weiter? Ok, Sie können ein Dienstkonto in einer der folgenden Optionen verwenden Möglichkeiten:
- Erstellen Sie ein Display- und Video 360-Nutzer, der Ihrem Dienstkonto. In diesem Szenario verhält sich Ihr Dienstkonto wie ein normales Nutzerkonto und ermöglicht es Ihnen, auf alle Partner und Werbetreibenden der für den Nutzer bereitgestellt wurde. Dies ist die bevorzugte Methode, den Dienst zu verwenden Konten mit Display- und Video 360
- Verwenden Sie die domainweite Delegierung, um Anfragen im Namen eines oder eines mehr Display- und Video 360-Nutzer, die mit Konten einer G Suite verknüpft sind . In diesem Fall benötigen Sie Administratorzugriff auf die Zieldomain. Hilfe zur Konfiguration der G Suite und/oder Domain finden Sie in der G Suite-Supportseite
Vorbereitung
So verwenden Sie ein Dienstkonto, das mit einem Video 360-Nutzer, wählen Sie die DV360-Nutzer. So verwenden Sie die domainweite Delegierung: Wählen Sie den Tab Delegierung aus.
DV360-Nutzer
Sie benötigen ein Display- und Video 360-Nutzer ist mit Ihrem Dienstkonto verknüpft.
Ermächtigung
- Sie benötigen Administratorzugriff auf eine Domain, die bei registriert ist. G Suite
- Sie benötigen mindestens ein Display & Video 360-Nutzer, die mit Konten verknüpft sind in Ihrer für die G Suite registrierten Domain. Nutzer, die mit Konten verknüpft sind unter andere Domains (z. B. gmail.com) können nicht verwendet werden.
Dienstkonto konfigurieren und verwenden
DV360-Nutzer
Generieren Sie einen Dienstkontoschlüssel im Google API-Konsole.
Display- und Video 360-Nutzer mit der E-Mail-Adresse des Dienstkontos die im vorherigen Schritt abgerufen wurden, wie in den Nutzer in Display &Video 360 verwalten Video 360-Hilfe Artikel.
Implementieren Sie den OAuth 2.0-Vorgang von Server zu Server in Ihrer Anwendung mithilfe von das neu erstellte Dienstkonto. Weitere Informationen finden Sie in der Beispiele.
Ermächtigung
Generieren Sie einen Dienstkontoschlüssel im Google API-Konsole.
Domainweite Berechtigungen an dieses Dienstkonto delegieren Zulassen, dass sich Nutzer innerhalb Ihrer Domain imitieren. Wenn Sie dazu aufgefordert werden, folgenden API-Bereichen:
Umfang Bedeutung https://www.googleapis.com/auth/display-videoLese-/Schreibzugriff https://www.googleapis.com/auth/display-video-user-managementLese-/Schreibzugriff für den Dienst users. Nur für Dienstkontonutzer verfügbar.Implementieren Sie den OAuth 2.0-Vorgang von Server zu Server in Ihrer Anwendung mithilfe von das neu erstellte Dienstkonto. Weitere Informationen finden Sie in der Beispiele. Sie müssen ein Konto angeben, imitiert, und sie muss zu der Domain gehören, für die Ihr Dienst Konto wurde im vorherigen Schritt domainweite Befugnisse übertragen.
Hilfe zur Konfiguration der G Suite und / oder Domain finden Sie in der Supportseite für die G Suite.
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.v3.DisplayVideo;
import com.google.api.services.displayvideo.v3.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 = 'v3'
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;
}
}