服务器到服务器：竞拍服务器设置指南

本指南将向您介绍如何构建内部竞拍服务器。在下面的分步指南中，我们会使用在插屏广告中竞价的示例。请确保您已经熟悉 Audience Network 插屏广告的使用方法。竞价还支持原生广告、横幅广告、插屏广告、视频插播广告和激励视频广告格式。您可以查看下方支持的广告格式，以集成其他广告格式。

竞拍服务器设置步骤

第 1 步：在服务器上定义平台

第 2 步：从服务器生成开放实时竞价 (ORTB) 请求

第 3 步：从服务器执行开放实时竞价 (ORTB) 请求

第 4 步：在服务器上运行竞拍

第 5 步：发送获胜/失败/超时通知

第 6 步：把获胜者传送回客户端

竞拍服务器设置步骤

第 1 步：在服务器上定义平台

发送到 Audience Network 竞拍端点的开放实时竞价 (ORTB) 请求必须同时包含设备和应用信息。以下是开放实时竞价 (ORTB) 请求中的示例负载：

{
// Device information from client side
'device': {
'ifa': '${DEVICE_ID}',
'dnt': '0',
'ip': '127.0.0.1'
},
// Application information
'app': {
'ver': '1.0',
'bundle': 'com.facebook.audiencenetwork.AdUnitsSample',
'publisher': {
// For server to server bidding integration, this is your application id on Facebook
'id': '${APP_ID}',
}
},
// Placement information we can store on server
'imp': [
{
'id': 'banner_test_bid_req_id',
// This is the placement id for Audience Network
'tagid': '${PLACEMENT_ID}',
'banner': {
'w': -1,
'h': 50,
},
},
],
// Optional regulations object from client side
'regs': {
'coppa': 0,
},
// In server to server integration, you can use the Facebook app id as platform id here
'ext': {
'platformid': '${PLATFORM_ID}',
// Mediation partner Platform ID or publisher FB app ID, mandatory.
'authentication_id': '${AUTHENTICATION_ID}',   
// Authentication token to validate the originator of the request.
'security_app_id': '${AN_SECURITY_APP_MY_SECURITY_APP_ID}',
// Security app id used to generate authentication_id.
's2s_version': '${VERSION_NUMBER}',
// Version of the integration. Max 16 characters.
},
// buyeruid is the user bidder token generated on client side, using the `getBidderToken` method from the Audience Network SDK. 
// It's constant through out app session so you could cache it on the client side
'user': {
'buyeruid': 'mybuyeruid',
},
// Test mode flag
'test': '1',
// Time out setting we can store on server
'tmax': 1000,
// Request ID we can generate on server
'id': 'banner_test_bid_req_id',
// Auction setting we can store on server
'at': 1,
}

Audience Network 需要以上开放实时竞价 (ORTB) 请求负载。不过，在您自己的竞拍服务器上，您实际上可以定义其中一些应用参数（如应用编号、版位编号以及服务器配置中的一些其他参数）；然后您的客户端应用仅需要发送简化请求。您的服务器可以循环版位信息，并构建最终开放实时竞价 (ORTB) 请求。以下是竞拍服务器设置示例：

{
"bidding_source_platforms": [
{
"platform_name": "audience_network",
"end_point": "https://an.facebook.com/${PLATFORM_ID}/placementbid.ortb",
"timeout": 1000,
"timeout_notification_url": "https://www.facebook.com/audiencenetwork/nurl/?partner=${PARTNER_FBID}&app=${APP_FBID}&auction=${AUCTION_ID}&ortb_loss_code=2"
}
],
"apps": [
{
"app_id": "101",
"app_name": "My example app",
"placements": [
{
"placement_id": "1",
"placement_name": "My example placement",
"ad_format": "interstitial",
"bidding_source_placement_ids":[
{
"platform_name": "audience_network",
"platform_app_id": "${APP_ID}",
"platform_placement_id": "${PLACEMENT_ID}"
}
]
}
]
}
]
}

在以上竞拍服务器设置下，客户端应用仅需要使用 "app_id":"101" 和 "placement_id":"1" 向服务器发送简化请求；然后服务器将查询完整的版位信息，例如 placement_id、ad_format、platform_name 等。下面是来自客户端的简化请求负载示例：

{
// App ID and placement ID are used to look up settings from
// server settings
'app_id': '101',
'placement_id': '1',

'bundle': 'com.facebook.samples.s2sbiddingclient',
'bundle_version': '1.0',

// Device specifics
'ifa': '${DEVICE_ID}',
'coppa': 0,
'dnt': 0,

// buyer_tokens are the user tokens required for different networks
'buyer_tokens': {
// Token for audience network from BidderTokenProvider.getBidderToken(context)
// This can be cached for the same app session
'audience_network': 'my-buyeruid',
},
}

简化请求发送到竞拍服务器后，您应该可以通过竞拍服务器设置中的 app_id 和 placement_id 查询完整的版位、设备和应用信息。以下是查询结果示例：

{
"placement_id": "1",
"placement_name": "My example placement",
"ad_format": "interstitial",
"bidding_source_placement_ids":[
{
"platform_name": "audience_network",
"platform_app_id": "${APP_ID}",
"platform_placement_id": "${PLACEMENT_ID}"
}
]
}

第 2 步：从服务器生成开放实时竞价 (ORTB) 请求

竞拍服务器收到竞拍请求后，需要为每个需求源构建竞价请求。以下是 app.py 中接收竞拍请求的端点：

@app.route('/get_bid', methods=['POST'])
def get_bid():
'''
The actual endpoint that expects a ClientRequest in the parameters
'''
# Initialize the server settings
ServerSettings.initialize(
app.config['bidding_source_platforms'],
app.config['apps']
)

request_params = request.get_json(force=True)

# See the code sample below for this function in `bid_manager.py`
(code, response) = get_bid_response(
request.remote_addr,
request.user_agent.string,
request_params)

app.logger.debug('server response: {0} {1}'.format(code, response))
return Response(
json.dumps(response),
status=code,
mimetype='application/json'
)

在 bid_manager.py 中，客户端的竞拍请求包含 app_id 和 placement_id，用于查询服务器设置中的完整版位信息。

# Return Auction Result - Winner - back to client side
def get_bid_response(ip, user_agent, request_params):
"""Get the winner bid response for the current request"""
try:
app_id = request_params['app_id']
placement_id = request_params['placement_id']
auction_id = get_auction_id()
...
# Find placement in the settings
placement = ServerSettings.get_placement(app_id, placement_id)

# Collect bid requests for different platforms
bid_requests = get_bid_requests(
ip,
user_agent,
auction_id,
placement,
request_params)

except Exception as e:
raise ParameterError("Error in request parameters: {}".format(str(e)))
...
return final_response

# Get all bid requests for different platforms
def get_bid_requests(ip, user_agent, auction_id, placement, request_params):
"""Create bid requests based on the internal placement setting"""

...

(end_point, data, timeout_notification_url) = get_bid_request(
ip,
user_agent,
auction_id,
platform_name,
platform_app_id,
platform_placement_id,
ad_format,
request_params)

if data is not None:
results.append({
'platform_name': platform_name,
'end_point': end_point,
'data': data,
'timeout_notification_url': timeout_notification_url,
})

# current_app.logger.debug("requests: {}".format(results))
return results

# Get bid request for each platform
def get_bid_request(
ip,
user_agent,
auction_id,
platform_name,
platform_app_id,
platform_placement_id,
ad_format,
request_params
):
"""Create bid request for a specific platform"""
if platform_name == 'audience_network':

return audience_network.get_bid_request(
ip,
user_agent,
auction_id,
platform_app_id,
platform_placement_id,
ad_format,
request_params)

else:
return (None, None, None)

然后在 audience_network.py 中，函数 get_bid_request 将根据完整的版位信息为 Audience Network 生成最终的开放实时竞价 (ORTB) 请求。

def get_bid_request(
ip,
user_agent,
auction_id,
platform_app_id,
platform_placement_id,
ad_format,
request_params
):
'''
Gather the required bid request parameters for networks. The parameters
consist of platform settings like app id, placement ids, ad sizes etc., and
client side information such as device information, user agent etc. We use
the `settings.json` file to store platform specific settings, and the
client request to retrieve the clietn specific information.
'''
platform = ServerSettings.get_platform('audience_network')
end_point = platform['end_point']
timeout = platform['timeout']
timeout_notification_url = platform['timeout_notification_url']

timeout_notification_url.replace('${PARTNER_FBID}', platform_app_id)
timeout_notification_url.replace('${APP_FBID}', platform_app_id)
timeout_notification_url.replace('${AUCTION_ID}', auction_id)

imp = []
if ad_format == 'native':
imp.append({
'id': auction_id,
'native': {
'w': -1,
'h': -1,
},
'tagid': platform_placement_id,
})
elif ad_format == 'banner':
imp.append({
'id': auction_id,
'banner': {
'w': -1,
'h': 50,
},
'tagid': platform_placement_id,
})
elif ad_format == 'interstitial':
imp.append({
'id': auction_id,
'banner': {
'w': 0,
'h': 0,
},
'tagid': platform_placement_id,
'instl': 1,
})
elif ad_format == 'rewarded_video':
imp.append({
'id': auction_id,
'video': {
'w': 0,
'h': 0,
'linearity': 2,
},
'tagid': platform_placement_id,
})
elif ad_format == 'instream_video':
imp.append({
'id': auction_id,
'video': {
'w': 0,
'h': 0,
'linearity': 1,
},
'tagid': platform_placement_id,
})
else:
raise ParameterError("Incorrect ad format")

typed_ip = ipaddress.ip_address(ip)
device = {
'ifa': request_params['ifa'],
'ua': user_agent,
'dnt': request_params['dnt'],
}
if type(typed_ip) is ipaddress.IPv6Address:
device['ipv6'] = ip
else:
device['ip'] = ip

# Construct the ORTB request
request = {
'id': auction_id,
'imp': imp,
'app': {
'bundle': request_params['bundle'],
'ver': request_params['bundle_version'],
'publisher': {
'id': platform_app_id,
}
},
'device': device,
'regs': {
'coppa': request_params['coppa'],
},
'user': {
'buyeruid': request_params['buyer_tokens']['audience_network'],
},
'ext': {
'
': platform_app_id,
},
'at': 1,
'tmax': timeout,
'test': request_params['test'],
}

return (end_point, request, timeout_notification_url)

第 3 步：从服务器执行开放实时竞价 (ORTB) 请求

按上述方法创建开放实时竞价 (ORTB) 请求后，可以使用 HTTP 请求、post 和 Content-Type: application/json 向位于 https://an.facebook.com/${PLATFORM_ID}/placementbid.ortb 的 Audience Network 端点发送请求。

在 bid_manager.py 中，应用收集到每个平台的所有竞价请求后，将调用每个平台的 exec_bid_request：

# Return Auction Result - Winner - back to client side
def get_bid_response(ip, user_agent, request_params):
"""Get the winner bid response for the current request"""
...
# Execute bid requests by network
bid_responses = []
for bid_request in bid_requests:
(code, response) = exec_bid_request(
bid_request['platform_name'],
bid_request['end_point'],
bid_request['data'],
bid_request['timeout_notification_url'])

bid_responses.append({
'platform_name': bid_request['platform_name'],
'code': code,
'response': response,
})

final_response = run_auction(bid_responses, placement)
return final_response

# Execute bid request for different platform (network)
def exec_bid_request(
platform_name,
end_point,
request_params,
timeout_notification_url
):
'''
Actually run the bid requests for the networks.
'''
if platform_name == 'audience_network':
return audience_network.exec_bid_request(
end_point,
request_params,
timeout_notification_url,
)
else:
raise InternalError("Invalid platform: {}".format(platform_name))

需要设置响应中的以下 HTTP 标头（竞价和无竞价），其中包含问题解决的有用信息，并应记录在竞拍服务器上：

• X-FB-AN-Request-ID：Audience Network 需要请求编号，以调试特定请求。请在寻求支持时获取。
• X-FB-AN-Errors：遇到错误的列表，有助于理解无竞价的原因。
• X-FB-Debug：关于该请求的一些调试信息，可以发送给 Audience Network 的业务代表，以解决问题。

注意：为了将延迟降到最低，需要将 X-FB-Pool-Routing-Token 标头添加到竞价请求中。

• X-FB-Pool-Routing-Token：该口令用于将请求指向我们最近的数据中心，其值与 user.buyeruid 相同。

在 audience_network.py 中，开放实时竞价 (ORTB) 请求将发送到 Audience Network，并且竞价响应将相应地传递到竞拍服务器：

def exec_bid_request(
end_point,
request_params,
timeout_notification_url
):
try:
platform = ServerSettings.get_platform('audience_network')
headers = {
'Content-Type': 'application/json; charset=utf-8',
'X-FB-Pool-Routing-Token': request_params['user']['buyeruid'],
}
timeout = platform['timeout']
r = requests.post(
end_point,
json=request_params,
headers=headers,
# Timeout in settings.json in ms
timeout=(timeout / 1000),
)
except Exception as e:
current_app.logger.error(BID_TIMEOUT)

# Send time out notification
r = requests.get(timeout_notification_url, timeout)
return (500, BID_TIMEOUT)

if r.status_code == requests.codes.ok:
try:
data = json.loads(r.text)
current_app.logger.debug('Audience Network response: {}'.format(
data
))
# Parse response from Audience Network with the ORTBResponse
ortb_response = ORTBResponse(data)
except Exception as e:
current_app.logger.error(
PARSE_ERROR + "{}".format(e)
)
return (500, PARSE_ERROR + "{}".format(e))

return (r.status_code, ortb_response)

else:
# The error message is stored in the X-FB-AN-Errors header
error_header = r.headers.get('x-fb-an-errors')
debug_header = r.headers.get('x-fb-debug')
bid_request_id = r.headers.get('x-fb-an-request-id')

if r.status_code == 400:
error_message = INVALID_BID + error_header + INVALID_BID_ADVICE
elif r.status_code == 204:
error_message = NO_BID + error_header
else:
error_message = UNEXPECTED_ERROR

# Log error information for debugging
error = {
'bid_request_id': bid_request_id,
'debug_header': debug_header,
'error_message': error_message,
}
current_app.logger.error(error)

# Respond error status code to client
return (r.status_code, error_message)

如果您在请求中提供 Content-Encoding:gzip 标头，则可以传递二进制 gzip 压缩形式的请求正文。

第 4 步：在服务器上运行竞拍

现在我们已经有来自不同平台（网络）的竞价响应。在 bid_manager.py 中，函数 get_bid_response 将负责比较填充的竞价响应，并确定最高竞价 - 获胜者。

def get_bid_response(ip, user_agent, request_params):
"""Get the winner bid response for the current request"""
...
final_response = run_auction(bid_responses, placement)
return final_response

def run_auction(bid_responses, placement):
"""Run auction based on raw responses and create the response object"""
other_bid = 1
response = (204, None)  # default is 204 no fill

for bid_response in bid_responses:
if bid_response['platform_name'] == 'audience_network':
if bid_response['code'] == 200:
ortb_response = bid_response['response']
if ortb_response.price > other_bid:
response = create_response(bid_response, placement)
current_app.logger.debug(
'Audience Network bid: {} won!'.format(
ortb_response.price
)
)
notify_result(bid_response)
else:
current_app.logger.debug(
'Audience Network bid: {} lost!'.format(
ortb_response.price
)
)
notify_result(bid_response, 102)
else:
current_app.logger.debug(bid_response['response'])

return response

由于 Audience Network 是我们示例中唯一的竞价者，所以运行竞拍方法简单地将返回的竞价与某个价格值进行比较，并确定其是否赢得竞拍。因此，如果 Audience Network 返回的竞价高于 1 美元，我们响应为 Audience Network 赢得竞拍，否则将视为竞拍失败。

第 5 步：发送得标、失标、可计费或超时通知

"https://www.facebook.com/audiencenetwork/nurl/?partner=${PARTNER_FBID}&app=${APP_FBID}&placement=${PLACEMENT_FBID}&auction=${AUCTION_ID}&impression=${IMPRESSION_ID}&request=${BID_REQUEST_ID}&bid=${BID_ID}&ortb_loss_code=0&clearing_price=${AUCTION_PRICE}"

"https://www.facebook.com/audiencenetwork/nurl/?partner=${PARTNER_FBID}&app=${APP_FBID}&placement=${PLACEMENT_FBID}&auction=${AUCTION_ID}&impression=${IMPRESSION_ID}&request=${BID_REQUEST_ID}&bid=${BID_ID}&ortb_loss_code=${AUCTION_LOSS}&clearing_price=${AUCTION_PRICE}"

"https://www.facebook.com/audiencenetwork/burl/?partner=${PARTNER_FBID}&app=${APP_FBID}&placement=${PLACEMENT_FBID}&auction=${AUCTION_ID}&impression=${IMPRESSION_ID}&request=${BID_REQUEST_ID}&bid=${BID_ID}&ortb_loss_code=0&clearing_price=${AUCTION_PRICE}"

"https://www.facebook.com/audiencenetwork/nurl/?partner=${PARTNER_FBID}&app=${APP_FBID}&auction=${AUCTION_ID}&ortb_loss_code=2"

第 6 步：把获胜者传送回客户端

运行竞拍以后，我们创建响应对象，并将其返回到客户端应用中。以下是 bid_manager.py 中创建竞拍服务器最终响应的方法示例：

def create_response(bid_response, placement):
"""Create response object based on the auction result"""
ad_format = placement['ad_format']
platform_name = bid_response['platform_name']
platform_placement_id = None

for bidding_source_placement_id in placement[
'bidding_source_placement_ids'
]:
if bidding_source_placement_id['platform_name'] == platform_name:
platform_placement_id = bidding_source_placement_id[
'platform_placement_id'
]

if platform_placement_id is None:
raise InternalError("Platform placement ID not found!")

bid_payload = None
if platform_name == 'audience_network':
bid_payload = bid_response['response'].adm
else:
raise InternalError("Invalid platform")

return (200, {
'placement_id': placement['placement_id'],
'ad_format': ad_format,
'platform_name': platform_name,
'platform_placement_id': platform_placement_id,
'bid_payload': bid_payload,
})

最后，我们的示例服务器可以向客户端创建该响应，以通知使用哪个平台：

{
'placement_id': string, // Placement identifier for the auction server
'ad_format': string, // Format of the placement
'platform_name': string, // Which platform won the auction, for example 'audience_network'
'platform_placement_id': string, // Placement ID for the platform, for example the placement ID for Audience network
'bid_payload': string, // The JSON string payload for the platform SDK to load the final ad
}

下一步：客户端分步集成

• Android 客户端设置步骤
• iOS 客户端设置步骤
• 测试
• 问题解决