服務帳戶是一種 Google 帳戶類型，應用程式可以透過 OAuth 2.0，以程式輔助的方式存取 Google API。這項作業不需要人為授權，而是使用只有您的應用程式能存取的金鑰檔案。
進一步瞭解服務帳戶前，建議除了實作已安裝 OAuth 2.0 的應用程式流程之外，我們也極力推薦您這麼做。這個方法會要求使用者手動授權應用程式產生更新憑證，但由於這些憑證永遠不會過期，您只需要進行「一次」即可。
還在閱讀嗎？好的，您可以透過下列任一方式實作服務帳戶：
- 如果您的使用者位於不同的網域，請以 Campaign Manager 360 使用者的身分使用服務帳戶進行導入。這個做法可讓您連結不同代理商擁有的多個帳戶，方法是為每個帳戶建立新的使用者設定檔，並將這些帳戶全部連結至單一服務帳戶。建議您以這種方式搭配 Campaign Manager 360 使用服務帳戶。
- 如果使用者位於您擁有的單一網域，請實作全網域委派功能，您必須擁有向 G Suite 註冊網域的管理員存取權。如需 G Suite 和 / 或網域設定方面的協助，請參閱 G Suite 支援頁面。
必要條件
如要以 Campaign Manager 360 使用者的身分導入服務帳戶，請選取「Campaign Manager 360 使用者」分頁標籤。如要實作全網域委派，請選取下方的「委派」分頁標籤。
您必須有權存取已啟用 API 存取權的 Campaign Manager 360 帳戶。
- 您必須有權存取已啟用 API 存取權的 Campaign Manager 360 帳戶。
- 你必須具備透過 G Suite 註冊網域的管理員權限。
- 您必須在註冊 G Suite 的網域下，將 Campaign Manager 360 使用者設定檔連結到一或多個帳戶。您無法使用連結至其他網域 (例如 gmail.com) 帳戶的使用者設定檔。
設定及使用服務帳戶
如要以 Campaign Manager 360 使用者身分使用服務帳戶，請選取「Campaign Manager 360 使用者」分頁標籤。如要實作全網域委派，請選取下方的「委派」分頁標籤。
- 在 Google API 控制台中產生服務帳戶金鑰。
注意：請務必保護能授予服務帳戶 Google 服務存取權的金鑰檔案。在全網域委派流程中尤其如此，因為 G Suite 的網域層級控管機制可讓服務帳戶模擬網域中任何使用者。您也可以只允許服務帳戶存取個別 Google API (透過下一個步驟說明的「範圍」欄位)。這項預防措施是為了在服務帳戶的金鑰檔案遭到入侵時，減少攻擊者能存取的資料量。 - 將「全網域授權」委派給這個服務帳戶，即可允許該帳戶模擬您網域中的使用者。收到系統提示時，請提供下列 API 範圍：
範圍 意義 https://www.googleapis.com/auth/dfatrafficking具備 Campaign Manager 360 廣告投放的讀取/寫入權限。 https://www.googleapis.com/auth/dfareporting具備 Campaign Manager 360 報表的讀取/寫入權限。 https://www.googleapis.com/auth/ddmconversions具備 Campaign Manager 360 離線轉換的讀取/寫入權限。 - 使用新建立的服務帳戶，在應用程式中實作伺服器對伺服器 OAuth 2.0 流程。詳情請參閱「範例」一節。請注意，您必須提供可模擬的帳戶，且該帳戶必須位於您在上一個步驟中，用來委派全網域授權的網域。
如需 G Suite 和 / 或網域設定方面的協助，請參閱 G Suite 支援頁面。
範例
C#
/*
* Copyright 2015 Google Inc
*
* Licensed under the Apache License, Version 2.0(the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
using Google.Apis.Auth.OAuth2;
using Google.Apis.Dfareporting.v4;
using Google.Apis.Dfareporting.v4.Data;
using Google.Apis.Json;
using Google.Apis.Services;
using System;
using System.Collections.Generic;
using System.IO;
namespace DfaReporting.Samples {
/// <summary>
/// This example demonstrates how to authenticate and make a basic request using a service
/// account.
/// </summary>
class AuthenticateUsingServiceAccount : SampleBase {
/// <summary>
/// The OAuth 2.0 scopes to request.
/// </summary>
private static readonly IEnumerable<string> OAuthScopes = new[] {
DfareportingService.Scope.Dfareporting
};
/// <summary>
/// Returns a description about the code example.
/// </summary>
public override string Description {
get {
return "This example demonstrates how to authenticate and make a basic request" +
" using a service account.\n";
}
}
/// <summary>
/// Main method, to run this code example as a standalone application.
/// </summary>
/// <param name="args">The command line arguments.</param>
public static void Main(string[] args) {
SampleBase codeExample = new AuthenticateUsingServiceAccount();
Console.WriteLine(codeExample.Description);
codeExample.Run(null);
}
/// <summary>
/// Run the code example.
/// </summary>
/// <param name="service">Unused</param>
public override void Run(DfareportingService service) {
string pathToJsonFile = _T("ENTER_PATH_TO_JSON_FILE_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).
string emailToImpersonate = _T("");
// Build service account credential.
ServiceAccountCredential credential =
getServiceAccountCredential(pathToJsonFile, emailToImpersonate);
// Create a Dfareporting service object.
//
// Note: application name should be replaced with a value that identifies your application.
service = new DfareportingService(
new BaseClientService.Initializer {
HttpClientInitializer = credential,
ApplicationName = "C# service account sample"
}
);
// Retrieve and print all user profiles for the current authorized user.
UserProfileList profiles = service.UserProfiles.List().Execute();
foreach (UserProfile profile in profiles.Items) {
Console.WriteLine("Found user profile with ID {0} and name \"{1}\".",
profile.ProfileId, profile.UserName);
}
}
private ServiceAccountCredential getServiceAccountCredential(String pathToJsonFile,
String emailToImpersonate) {
// Load and deserialize credential parameters from the specified JSON file.
JsonCredentialParameters parameters;
using (Stream json = new FileStream(pathToJsonFile, FileMode.Open, FileAccess.Read)) {
parameters = NewtonsoftJsonSerializer.Instance.Deserialize<JsonCredentialParameters>(json);
}
// Create a credential initializer with the correct scopes.
ServiceAccountCredential.Initializer initializer =
new ServiceAccountCredential.Initializer(parameters.ClientEmail) {
Scopes = OAuthScopes
};
// Configure impersonation (if applicable).
if (!String.IsNullOrEmpty(emailToImpersonate)) {
initializer.User = emailToImpersonate;
}
// Create a service account credential object using the deserialized private key.
ServiceAccountCredential credential =
new ServiceAccountCredential(initializer.FromPrivateKey(parameters.PrivateKey));
return credential;
}
}
}
Java
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.api.services.samples.dfareporting.auth;
import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.services.dfareporting.Dfareporting;
import com.google.api.services.dfareporting.DfareportingScopes;
import com.google.api.services.dfareporting.model.UserProfileList;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableSet;
import java.io.FileInputStream;
/**
* This example demonstrates how to authenticate and make a basic request using a service account.
*/
public class AuthenticateUsingServiceAccount {
private static final String PATH_TO_JSON_FILE = "ENTER_PATH_TO_JSON_FILE_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<String> OAUTH_SCOPES =
ImmutableSet.of(DfareportingScopes.DFAREPORTING);
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 runExample(Dfareporting reporting) throws Exception {
// Retrieve and print all user profiles for the current authorized user.
UserProfileList profiles = reporting.userProfiles().list().execute();
for (int i = 0; i < profiles.getItems().size(); i++) {
System.out.printf("%d) %s%n", i + 1, profiles.getItems().get(i).getUserName());
}
}
public static void main(String[] args) throws Exception {
// Build service account credential.
Credential credential = getServiceAccountCredential(PATH_TO_JSON_FILE, EMAIL_TO_IMPERSONATE);
// Create a Dfareporting client instance.
//
// Note: application name below should be replaced with a value that identifies your
// application. Suggested format is "MyCompany-ProductName/Version.MinorVersion".
Dfareporting reporting =
new Dfareporting.Builder(credential.getTransport(), credential.getJsonFactory(), credential)
.setApplicationName("dfareporting-java-service-acct-sample")
.build();
runExample(reporting);
}
}
PHP
<?php
/*
* Copyright 2017 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
require_once dirname(__DIR__) . '/vendor/autoload.php';
/**
* This example demonstrates how to authenticate and make a basic request using
* a service account.
*
* This example is written to be run as a command line application, not as a
* webpage. An optional Google account email to impersonate may be specified as
* follows:
*
* AuthenticateUsingServiceAccount.php /path/to/client_secrets.json <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 that you don't own (e.g., gmail.com).
*/
class AuthenticateUsingServiceAccount
{
// The OAuth 2.0 scopes to request.
private static $OAUTH_SCOPES = [
Google_Service_Dfareporting::DFAREPORTING
];
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_Dfareporting($client);
$this->getUserProfiles($service);
}
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;
}
private function getUserProfiles($service)
{
// Retrieve and print all user profiles for the current authorized user.
$result = $service->userProfiles->listUserProfiles();
foreach ($result['items'] as $userProfile) {
printf(
"User profile \"%s\" (ID: %d) found for account %d.\n",
$userProfile->getUserName(),
$userProfile->getProfileId(),
$userProfile->getAccountId()
);
}
}
}
if ($argc < 2 || $argc >= 4) {
printf(
"Usage: %s /path/to/client_secrets.json [email_to_impersonate]\n",
$argv[0]
);
} else {
$sample = new AuthenticateUsingServiceAccount();
if ($argc == 2) {
$sample->run($argv[1]);
} else {
$sample->run($argv[1], $argv[2]);
}
}
Python
#!/usr/bin/python
#
# Copyright 2015 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""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.')
# The OAuth 2.0 scopes to request.
OAUTH_SCOPES = ['https://www.googleapis.com/auth/dfareporting']
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)
# Construct a service object via the discovery service.
service = discovery.build('dfareporting', 'v4', http=http)
try:
# Construct the request.
request = service.userProfiles().list()
# Execute request and print response.
response = request.execute()
for profile in response['items']:
print('Found user profile with ID %s and user name "%s".' %
(profile['profileId'], profile['userName']))
except client.AccessTokenRefreshError:
print('The credentials have been revoked or expired, please re-run the '
'application to re-authorize')
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=OAUTH_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)
小茹
#!/usr/bin/env ruby
#
# Copyright:: Copyright 2016, Google Inc. All Rights Reserved.
#
# License:: Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# 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.rb <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).
require 'google/apis/dfareporting_v4'
require 'googleauth'
require 'optparse'
API_NAMESPACE = Google::Apis::DfareportingV4
def authenticate_using_service_account(path_to_json_file, impersonation_email)
# Create a Dfareporting service object.
#
# Note: application name should be replaced with a value that identifies
# your application. Suggested format is "MyCompany-ProductName".
service = API_NAMESPACE::DfareportingService.new
service.client_options.application_name = 'Ruby service account sample'
service.client_options.application_version = '1.0.0'
# Generate an authorization object from the specified JSON file.
File.open(path_to_json_file, 'r+') do |json|
service.authorization =
Google::Auth::ServiceAccountCredentials.make_creds(
json_key_io: json,
scope: [API_NAMESPACE::AUTH_DFAREPORTING]
)
end
# Configure impersonation (if applicable).
service.authorization.sub = impersonation_email unless
impersonation_email.nil?
service
end
def get_userprofiles(service)
# Get all user profiles.
result = service.list_user_profiles
# Display results.
result.items.each do |profile|
puts format(
'User profile with ID %d and name "%s" was found for account %d.',
profile.profile_id, profile.user_name, profile.account_id
)
end
end
if $PROGRAM_NAME == __FILE__
# Retrieve command line arguments.
impersonation_email = nil
optparse = OptionParser.new do |opts|
opts.banner = format('Usage: %s path_to_json_file [options]', $PROGRAM_NAME)
opts.on_tail('-i', '--impersonate EMAIL',
'Google account email to impersonate') do |email|
impersonation_email = email
end
end
optparse.parse!
if ARGV.empty?
puts optparse
exit(-1)
end
# Authenticate and initialize API service using service account.
service = authenticate_using_service_account(ARGV.shift, impersonation_email)
get_userprofiles(service)
end