Un compte de service est un type de compte Google permettant à une application d'accéder par programmation aux API Google via OAuth 2.0. Cette opération ne nécessite pas d'autorisation humaine, mais utilise un fichier de clé auquel seule votre application peut accéder.
Avant d'en savoir plus sur les comptes de service, consultez le flux OAuth 2.0 pour les applications installées, un processus simple et plus recommandé. Bien que ce flux nécessite une interaction manuelle de l'utilisateur pour autoriser votre application, cette étape ne doit être effectuée qu'une seule fois et ne doit pas être effectuée dans votre environnement de production. Les jetons d'actualisation générés par ce flux n'expirent jamais. Ils peuvent être mis en cache et déployés dans différents environnements, et peuvent être utilisés pour générer des jetons d'accès à la demande sans interaction avec l'utilisateur.
Nous espérons que vous suivez toutes ces instructions. OK, vous pouvez utiliser un compte de service de l'une des manières suivantes:
- Créez un utilisateur Display & Video 360 associé à votre compte de service. Dans ce scénario, votre compte de service se comporte comme un compte utilisateur normal et vous permet d'accéder à tous les partenaires et annonceurs auxquels l'utilisateur a été provisionné. Il s'agit de la méthode privilégiée pour utiliser les comptes de service avec Display & Video 360.
- Utilisez la délégation au niveau du domaine pour envoyer des requêtes au nom d'un ou de plusieurs utilisateurs Display & Video 360 associés à des comptes appartenant à un domaine G Suite. Dans ce cas, vous devez disposer d'un accès administrateur au domaine cible. Pour obtenir de l'aide concernant la configuration de G Suite et/ou du domaine, consultez la page d'assistance G Suite.
Conditions préalables
Pour utiliser un compte de service associé à un utilisateur de Display & Video 360, sélectionnez l'onglet Utilisateur DV360 ci-dessous. Pour utiliser la délégation au niveau du domaine, sélectionnez l'onglet Délégation.
Utilisateur DV360
Un utilisateur Display & Video 360 doit être associé à votre compte de service.
Délégation
- Vous devez disposer d'un accès administrateur à un domaine enregistré auprès de G Suite.
- Un ou plusieurs utilisateurs Display & Video 360 doivent être associés à des comptes dans votre domaine enregistré G Suite. Les utilisateurs associés à des comptes d'autres domaines (par exemple, gmail.com) ne peuvent pas être utilisés.
Configurer et utiliser un compte de service
Utilisateur DV360
Générez une clé de compte de service dans la console Google APIs.
Associez l'utilisateur Display & Video 360 à l'adresse e-mail du compte de service obtenue à l'étape précédente, comme décrit dans l'article Gérer les utilisateurs dans Display & Video 360 du centre d'aide.
Mettez en œuvre le flux OAuth 2.0 de serveur à serveur dans votre application à l'aide du compte de service que vous venez de créer. Pour en savoir plus, consultez la section Exemples.
Délégation
Générez une clé de compte de service dans la console Google APIs.
Déléguez l'autorité au niveau du domaine à ce compte de service pour lui permettre d'emprunter l'identité des utilisateurs de votre domaine. Lorsque vous y êtes invité, indiquez les champs d'application d'API suivants:
Définition du champ d'application Signification https://www.googleapis.com/auth/display-videoAccès en lecture/écriture https://www.googleapis.com/auth/display-video-user-managementAccès en lecture/écriture au service users. Disponible uniquement pour les utilisateurs de comptes de service.Mettez en œuvre le flux OAuth 2.0 de serveur à serveur dans votre application à l'aide du compte de service que vous venez de créer. Pour en savoir plus, consultez la section Exemples. N'oubliez pas que vous devrez fournir un compte dont vous souhaitez emprunter l'identité et qu'il doit appartenir au domaine pour lequel une autorité au niveau du domaine a été déléguée à votre compte de service à l'étape précédente.
Pour obtenir de l'aide sur la configuration de G Suite et / ou du domaine, consultez la page d'assistance G Suite.
Exemples
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;
}
}