Uma conta de serviço é um tipo de Conta do Google que pode ser usada por um aplicativo para acessar as APIs do Google de maneira programática via OAuth 2.0. Isso não requer autorização humana, mas usa um arquivo de chave que somente seu aplicativo pode acessar.
Antes de ler mais sobre contas de serviço, considere o fluxo de aplicativos instalados do OAuth 2.0 mais simples e altamente recomendado. Embora esse fluxo exija a interação manual do usuário para autorizar seu aplicativo, essa etapa só pode ser feita uma vez e não precisa ser realizada no ambiente de produção. Os tokens de atualização gerados por esse fluxo nunca expiram, podem ser armazenados em cache e implantados em diferentes ambientes e podem ser usados para gerar tokens de acesso sob demanda sem interação do usuário.
Ainda está lendo? É possível usar uma conta de serviço de uma das seguintes maneiras:
- Crie um usuário do Display & Video 360 associado à sua conta de serviço. Nesse cenário, sua conta de serviço se comporta como uma conta de usuário normal e permite que você acesse todos os parceiros e anunciantes aos quais o usuário foi provisionado. Essa é a melhor maneira de usar contas de serviço com o Display & Video 360.
- Use a delegação em todo o domínio para fazer solicitações em nome de um ou mais usuários do Display & Video 360 vinculados a contas em um domínio do G Suite. Nesse caso, é preciso ter acesso de administrador ao domínio de destino. Para receber ajuda com a configuração do G Suite e/ou do domínio, consulte a página de suporte do G Suite.
Pré-requisitos
Para usar uma conta de serviço associada a um usuário do Display & Video 360, selecione a guia Usuário do DV360 abaixo. Para usar a delegação em todo o domínio, selecione a guia Delegação.
Usuário do DV360
Você precisa ter um usuário do Display & Video 360 vinculado à sua conta de serviço.
Delegação
- Você precisa ter acesso de administrador a um domínio registrado no G Suite.
- É preciso ter um ou mais usuários do Display & Video 360 vinculados a contas no domínio registrado no G Suite. Não é possível usar usuários vinculados a contas em outros domínios (por exemplo, gmail.com).
Como configurar e usar uma conta de serviço
Usuário do DV360
Gere uma chave de conta de serviço no Console de APIs do Google.
Associe o usuário do Display & Video 360 ao e-mail da conta de serviço recebido na etapa anterior, conforme descrito no artigo da Central de Ajuda Gerenciar usuários no Display & Video 360.
Implemente o fluxo do OAuth 2.0 de servidor para servidor no aplicativo usando a conta de serviço recém-criada. Para mais informações, consulte a seção de exemplos.
Delegação
Gere uma chave de conta de serviço no Console de APIs do Google.
Delegue autoridade em todo o domínio a essa conta de serviço para permitir que ela represente usuários no seu domínio. Quando solicitado, forneça os seguintes escopos de API:
Escopo Significado https://www.googleapis.com/auth/display-videoAcesso de leitura e gravação. https://www.googleapis.com/auth/display-video-user-managementAcesso de leitura/gravação ao serviço users. Disponível apenas para usuários de contas de serviço.Implemente o fluxo do OAuth 2.0 de servidor para servidor no aplicativo usando a conta de serviço recém-criada. Para mais informações, consulte a seção de exemplos. Lembre-se de que você precisará fornecer uma conta a ser representada. Ela precisa pertencer ao mesmo domínio que teve autoridade em todo o domínio delegada à conta de serviço na etapa anterior.
Para receber ajuda com a configuração do G Suite e / ou do domínio, consulte a página de suporte do G Suite.
Exemplos
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;
}
}