Utilizza un account di servizio

Un account di servizio è un tipo di Account Google che può essere utilizzato da un'applicazione per accedere alle API di Google in modo programmatico tramite OAuth 2.0. Questa operazione non richiede un'autorizzazione fisica, bensì utilizza un file chiave accessibile soltanto dalla tua applicazione.

Prima di scoprire di più sugli account di servizio, valuta la possibilità di utilizzare il flusso di applicazione installata OAuth 2.0, più semplice e vivamente consigliato. Anche se questo flusso richiede l'interazione manuale dell'utente per autorizzare l'applicazione, questo passaggio deve essere eseguito una sola volta e non è necessario nell'ambiente di produzione. I token di aggiornamento generati da questo flusso non scadono mai, possono essere memorizzati nella cache e impiegati in ambienti diversi e possono essere utilizzati per generare token di accesso su richiesta senza alcuna interazione dell'utente.

Stai ancora leggendo? OK, puoi utilizzare un account di servizio in uno dei seguenti modi:

  • Crea un utente Display & Video 360 associato al tuo account di servizio. In questo scenario, il tuo account di servizio si comporta come un normale account utente e ti consente di accedere a tutti i partner e gli inserzionisti per i quali è stato eseguito il provisioning dell'utente. Questo è il modo preferito per utilizzare gli account servizio con Display & Video 360.
  • Utilizza la delega a livello di dominio per inviare richieste per conto di uno o più utenti Display & Video 360 collegati agli account di un dominio G Suite. In questo caso, devi disporre dell'accesso amministrativo al dominio di destinazione. Per assistenza con la configurazione di G Suite e/o del dominio, consulta la pagina di assistenza di G Suite.

Prerequisiti

Per utilizzare un account di servizio associato a un utente Display & Video 360, seleziona la scheda Utente DV360 di seguito. Per utilizzare la delega a livello di dominio, seleziona la scheda Delega.

Utente DV360

Devi avere un utente Display & Video 360 collegato al tuo account di servizio.

Delega

  1. Devi disporre dell'accesso amministrativo a un dominio registrato su G Suite.
  2. Devi avere uno o più utenti Display & Video 360 collegati agli account nel tuo dominio registrato con G Suite. Gli utenti collegati ad account di altri domini (ad esempio gmail.com) non possono essere utilizzati.

Configurazione e utilizzo di un account di servizio

Utente DV360

  1. Genera una chiave dell'account di servizio nella console API di Google.

  2. Associa l'utente Display & Video 360 all'indirizzo email dell'account di servizio ottenuto nel passaggio precedente, come descritto nell'articolo del Centro assistenza Gestire gli utenti in Display & Video 360.

  3. Implementa il flusso OAuth 2.0 server-to-server nella tua applicazione utilizzando l'account di servizio appena creato. Per ulteriori informazioni, consulta la sezione Esempi.

Delega

  1. Genera una chiave dell'account di servizio nella console API di Google.

  2. Delega l'autorità a livello di dominio a questo account di servizio per consentirgli di rubare l'identità degli utenti all'interno del tuo dominio. Quando richiesto, fornisci i seguenti ambiti API:

    Ambito Significato
    https://www.googleapis.com/auth/display-video Accesso di lettura/scrittura.
    https://www.googleapis.com/auth/display-video-user-management Accesso in lettura/scrittura per il servizio users. Disponibile solo per gli utenti degli account di servizio.

  3. Implementa il flusso OAuth 2.0 server-to-server nella tua applicazione utilizzando l'account di servizio appena creato. Per ulteriori informazioni, consulta la sezione Esempi. Ricorda che dovrai fornire un account da simulare e che questo deve appartenere al dominio per cui al tuo account di servizio è stata delegata l'autorità per tutto il dominio nel passaggio precedente.

Per assistenza con la configurazione di G Suite e / o del dominio, consulta la pagina dell'assistenza G Suite.

Esempi

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;
    }
}