Una cuenta de servicio es un tipo de Cuenta de Google que puede usar una aplicación para acceder a las APIs de Google de manera programática a través de OAuth 2.0. Esto no requiere autorización humana, sino que utiliza un archivo de claves al que solo puede acceder tu aplicación.
Antes de leer más sobre las cuentas de servicio, considera el flujo de aplicación instalada de OAuth 2.0, que es más simple y recomendado. Si bien este flujo requiere la interacción manual del usuario para autorizar tu aplicación, este paso solo debe realizarse una vez y no es necesario hacerlo en tu entorno de producción. Los tokens de actualización que genera este flujo no vencen, se pueden almacenar en caché e implementar en diferentes entornos, y se pueden usar para generar tokens de acceso a pedido sin interacción del usuario.
¿Sigues leyendo? Muy bien. Puedes usar una cuenta de servicio de cualquiera de las siguientes maneras:
- Crea un usuario de Display & Video 360 asociado a tu cuenta de servicio. En esta situación, tu cuenta de servicio se comporta como una cuenta de usuario normal y te permite acceder a todos los socios y anunciantes a los que se aprovisionó el usuario. Esta es la forma preferida de usar cuentas de servicio con Display & Video 360.
- Usa la delegación de todo el dominio para realizar solicitudes en nombre de uno o más usuarios de Display & Video 360 vinculados a cuentas de un dominio de G Suite. En este caso, debes tener acceso de administrador al dominio de destino. Para obtener ayuda con la configuración del dominio o de G Suite, consulta la página de asistencia de G Suite.
Requisitos previos
Para usar una cuenta de servicio asociada con un usuario de Display & Video 360, selecciona la pestaña Usuario de DV360 a continuación. Para usar la delegación de todo el dominio, selecciona la pestaña Delegación.
Usuario de DV360
Debes tener un usuario de Display & Video 360 vinculado a tu cuenta de servicio.
Delegación
- Debes tener acceso de administrador a un dominio registrado en G Suite.
- Debes tener uno o más usuarios de Display & Video 360 vinculados a cuentas en tu dominio registrado en G Suite. No se pueden usar usuarios vinculados a cuentas en otros dominios (por ejemplo, gmail.com).
Configura y usa una cuenta de servicio
Usuario de DV360
Genera una clave de cuenta de servicio en la Consola de APIs de Google.
Asocia el usuario de Display & Video 360 con el correo electrónico de la cuenta de servicio obtenido en el paso anterior, como se describe en el artículo del Centro de ayuda Administra usuarios en Display & Video 360.
Implementa el flujo de OAuth 2.0 de servidor a servidor en tu aplicación con la cuenta de servicio que creaste recientemente. Para obtener más información, consulta la sección de ejemplos.
Delegación
Genera una clave de cuenta de servicio en la Consola de APIs de Google.
Delega autoridad en todo el dominio a esta cuenta de servicio para permitir que actúe en nombre de usuarios de tu dominio. Cuando se te solicite, proporciona los siguientes alcances de la API:
Permiso Significado https://www.googleapis.com/auth/display-videoAcceso de lectura/escritura https://www.googleapis.com/auth/display-video-user-managementAcceso de lectura/escritura para el servicio de users. Solo está disponible para usuarios de cuentas de servicio.Implementa el flujo de OAuth 2.0 de servidor a servidor en tu aplicación con la cuenta de servicio que creaste recientemente. Para obtener más información, consulta la sección de ejemplos. Recuerda que deberás proporcionar una cuenta para suplantar la identidad y que debe pertenecer al dominio para el que se delegó la autoridad de todo el dominio a tu cuenta de servicio en el paso anterior.
Para obtener ayuda con la configuración del dominio o de G Suite, consulta la página de asistencia de G Suite.
Ejemplos
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;
}
}