ผสานรวมกับ B&A ในฐานะผู้ขาย

บริการเสนอราคาและประมูล (Bidding and Auction หรือ B&A) คือชุดบริการสำหรับผู้ซื้อและผู้ขายโฆษณาที่ทำงานในสภาพแวดล้อมการดำเนินการที่เชื่อถือได้ (TEE) เพื่ออำนวยความสะดวกในการประมูล Protected Audience (PA) คู่มือสำหรับนักพัฒนาซอฟต์แวร์นี้จะอธิบายวิธีที่ผู้ขายสามารถผสานรวมกับการประมูล PA ของ Chrome สำหรับ B&A

คำแนะนำแบบทีละขั้น

โดยสรุปขั้นตอนได้ดังนี้

1. เรียกใช้ getInterestGroupAdAuctionData() เพื่อรับเพย์โหลดที่เข้ารหัสจากเบราว์เซอร์
2. โทรหา fetch('https://your-ad-server.example') และส่งคำขอการประมูลแบบรวมพร้อมเพย์โหลดที่เข้ารหัสไปยัง SAS
3. เรียกใช้การดำเนินการ SelectAd() ของ SFE จาก SAS เพื่อเรียกใช้การประมูล B&A
4. ส่งคืนผลการประมูล B&A ไปยังหน้าเว็บพร้อมกับแฮชของการตอบกลับ
5. เรียกใช้ runAdAuction() ในเบราว์เซอร์เพื่อเรียกใช้การประมูล PA แบบผู้ขายรายเดียว แบบผสม หรือแบบผู้ขายหลายราย และส่งผลการประมูล B&A ฝั่งเซิร์ฟเวอร์ไปยังการเรียก

รับข้อมูลการประมูลโฆษณาที่เข้ารหัส

หากต้องการรับข้อมูลที่จำเป็นต่อการเรียกใช้การประมูล B&A ฝั่งเซิร์ฟเวอร์ โค้ด JavaScript ของผู้ขายในหน้าผู้เผยแพร่โฆษณาจะเรียกใช้ navigator.getInterestGroupAdAuctionData()

const adAuctionData = await navigator.getInterestGroupAdAuctionData({
  seller: 'https://ssp.example', // Required
  requestSize: 51200,
  coordinatorOrigin: 'https://publickeyservice.pa.gcp.privacysandboxservices.com/',
  perBuyerConfig: {
    'https://dsp-x.example': { targetSize: 8192 },
    'https://dsp-y.example': { targetSize: 8192 }
  }
});

const { requestId, request } = adAuctionData;

เมื่อมีการเรียกใช้ เบราว์เซอร์จะอ่านกลุ่มความสนใจของผู้ซื้อที่ระบุไว้ใน perBuyerConfig และเข้ารหัสข้อมูลผู้ซื้อ ข้อมูลผู้ซื้อนี้มีข้อมูลข้ามเว็บไซต์ที่จะใช้สำหรับการเสนอราคา และไม่สามารถถอดรหัสภายนอก TEE ได้ สำหรับการเพิ่มประสิทธิภาพเพย์โหลด จะมีเฉพาะชื่อกลุ่มความสนใจ คีย์สัญญาณการเสนอราคาที่เชื่อถือได้ และสัญญาณของเบราว์เซอร์เท่านั้นที่รวมอยู่ในเพย์โหลด

ในออบเจ็กต์ข้อมูลการประมูลโฆษณาที่ส่งคืนโดยการเรียก getInterestGroupAdAuctionData() คุณจะเห็นสตริง requestId และอาร์เรย์ไบต์ request ที่เข้ารหัส

ระบบจะใช้สตริง requestId ในภายหลังเมื่อเรียกใช้ runAdAuction() เพื่อสิ้นสุดการประมูลในเบราว์เซอร์ ระบบจะส่งเพย์โหลด request ที่เข้ารหัสไปยังบริการโฆษณาของผู้ขายโดยเป็นส่วนหนึ่งของคำขอการประมูลแบบรวม

ดูตัวอย่างการเรียกนี้ได้ที่โค้ด JavaScript ของผู้ขายของแอปทดสอบในเครื่อง

ส่งคำขอการประมูลแบบรวมไปยัง SAS

คำขอการประมูลแบบรวมคือคำขอที่มีเพย์โหลดการประมูลตามบริบทแบบข้อความธรรมดาและเพย์โหลดการประมูล PA B&A เพย์โหลดการประมูล PA B&A คือrequestข้อมูลที่เข้ารหัสซึ่งเบราว์เซอร์สร้างขึ้นในการเรียกใช้ getInterestGroupAdAuctionData() คำขอนี้จะส่งไปยัง SAS ซึ่งจะประสานงานการประมูลตามบริบทและการประมูล PA B&A

fetch('https://ssp.example/ad-auction', {
  method: 'POST',
  adAuctionHeaders: true,
  body: JSON.stringify({
    contextualAuctionPayload: { somePayload },
    protectedAudienceAuctionPayload: encodeBinaryData(request)
  }),
});

หากต้องการส่งคำขอไปยัง SAS ระบบจะเรียกใช้ fetch() จากหน้าเว็บ

• การเรียกต้องมีตัวเลือก adAuctionHeaders: true ซึ่งส่งสัญญาณให้เบราว์เซอร์ยืนยันการตอบกลับของการเรียกนี้ในภายหลังเมื่อมีการเรียก runAdAuction() เพื่อจบการประมูลในเบราว์เซอร์
• ต้นทางของคำขอ Fetch ต้องตรงกับsellerต้นทางที่ระบุไว้ในการเรียกใช้ getInterestGroupAdAuctionData() และ runAdAuction()

เนื้อหาของการเรียกมีดังนี้

1. เพย์โหลดการประมูลตามบริบทแบบข้อความธรรมดาที่ SAS ใช้เพื่อเรียกใช้การประมูลตามบริบท
2. เพย์โหลดการประมูลที่ใช้ Protected Audience API ที่เข้ารหัสซึ่ง SAS จะส่งไปยัง SFE เพื่อเรียกใช้การประมูล B&A ฝั่งเซิร์ฟเวอร์

ดูตัวอย่างการเรียกนี้ได้ที่โค้ด JavaScript ของผู้ขายของแอปทดสอบในเครื่อง

การเข้ารหัสและถอดรหัส Base64

เพย์โหลด request ที่เข้ารหัสซึ่งแสดงผลจากการเรียก getInterestGroupAdAuctionData() เป็นอินสแตนซ์ของ Uint8Array ซึ่งเป็นประเภทข้อมูลที่ JSON จัดการไม่ได้ หากต้องการส่งอาร์เรย์ไบต์ในรูปแบบ JSON คุณสามารถใช้การเข้ารหัส base64 กับข้อมูลไบนารีเพื่อแปลงเป็นสตริงได้

JavaScript Browser API มีฟังก์ชัน atob() และ btoa() ใน window ซึ่งแปลงข้อมูลไบนารีและสตริง ASCII ที่เข้ารหัส Base64 (atob หมายถึง ASCII เป็นไบนารี และ btoa หมายถึงไบนารีเป็น ASCII)

เรียกใช้ btoa() เพื่อเข้ารหัสข้อมูลไบนารีเป็นสตริงที่เข้ารหัส Base64 ซึ่งมีลักษณะดังนี้

function encodeBinaryData(data) {
  return btoa(String.fromCharCode.apply(null, data));
}

ผลการประมูล B&A ที่เข้ารหัสซึ่งส่งคืนจากการเรียก fetch นี้จะอยู่ในรูปแบบการเข้ารหัส base64 ด้วย ดังนั้นคุณจึงต้องถอดรหัสกลับเป็นข้อมูลไบนารี เรียกใช้ atob() เพื่อถอดรหัสสตริง ASCII ที่เข้ารหัส Base64 เป็นข้อมูลไบนารี

function decodeBase64String(base64string) {
  return new Uint8Array(
    atob(base64string)
      .split('')
      .map((char) => char.charCodeAt(0))
  );
}

อย่างไรก็ตาม สตริงที่เข้ารหัส Base64 มักจะใหญ่กว่าข้อมูลต้นฉบับประมาณ 33% หากต้องการปรับปรุงเวลาในการตอบสนองเพิ่มเติม ให้ใช้รูปแบบอื่นที่ไม่ใช่ JSON เพื่อส่งข้อมูลไบนารี

โทรหา SelectAd ของ SFE เพื่อเรียกใช้การประมูล B&A

เมื่อบริการโฆษณาของผู้ขายได้รับคำขอการประมูลแบบรวมจากหน้าเว็บ การประมูลตามบริบทจะทำงานก่อนเพื่อพิจารณาผู้ชนะการประมูลตามบริบทและรวบรวมสัญญาณของผู้ซื้อเพื่อส่งไปยังการประมูล PA B&A จากนั้นการประมูล B&A จะเริ่มต้นโดยการเรียกใช้การดำเนินการ SelectAd ของ SFE จาก SAS พร้อมกับเพย์โหลดคำขอ โปรดทราบว่าระบบจะส่งต่อข้อมูลเมตาบางอย่างจากคำขอของหน้าเว็บไปยัง SAS ในขั้นตอนที่ 2 ไปยัง SFE

สร้างเพย์โหลด SelectAdRequest

คุณสร้างเพย์โหลดคำขอของSelectAdได้ดังนี้

const selectAdRequest = {
  auction_config: {
    seller: 'https://ssp.example',
    auction_signals: '{"testKey":"someValue"}',
    seller_signals: '{"testKey":"someValue"}',
    buyer_list: [
      'https://dsp-x.example',
      'https://dsp-y.example',
    ],
    per_buyer_config: {
      'https://dsp-x.example': { buyer_signals: '{"testKey": "someValue"}' },
      'https://dsp-y.example': { buyer_signals: '{"testKey": "someValue"}' },
    },
  },
  client_type: 'CLIENT_TYPE_BROWSER',
  protected_auction_ciphertext: decodeBase64string(request)
};

โปรดทราบว่าหากข้อมูลการประมูลโฆษณาที่เข้ารหัสจากเบราว์เซอร์ได้รับการเข้ารหัส base64 คุณจะต้องถอดรหัสกลับเป็นข้อมูลไบนารีหากส่งคำขอไปยัง SFE โดยใช้ gRPC หากส่งคำขอโดยใช้ HTTP ข้อมูลการประมูลโฆษณาที่เข้ารหัสจะยังคงอยู่ในรูปแบบที่เข้ารหัส Base64 ได้

หากต้องการดูฟิลด์อื่นๆ ที่กำหนดไว้ในSelectAdคำขอ โปรดดูคำจำกัดความของโปรโตของ SelectAdRequest

ตั้งค่าฟิลด์ผู้ขายระดับบนสุดสำหรับการประมูลแบบผสมและแบบคอมโพเนนต์

หากผู้ขายกำลังทำการประมูลแบบผสมหรือเข้าร่วมในฐานะผู้ขายที่เป็นคอมโพเนนต์ในการประมูลแบบผู้ขายหลายราย คุณต้องกำหนดฟิลด์ top_level_seller ในคำขอ

หากคุณเป็นผู้ขายแบบผสม ค่า top_level_seller คือต้นทางของคุณ

const selectAdRequest = {
  auction_config: {
    seller: 'https://ssp-mix.example',
    top_level_seller: 'https://ssp-mix.example',
  }
}

หากคุณเป็นผู้ขายคอมโพเนนต์ ค่า top_level_seller คือผู้ขายระดับบนสุดของการประมูลแบบผู้ขายหลายราย

const selectAdRequest = {
  auction_config: {
    seller: 'https://ssp-mix.example',
    top_level_seller: 'https://ssp-top.example',
  }
}

โทรหา SelectAd ของ SFE

การเรียกใช้ SFE จาก SAS สามารถทำได้ด้วย gRPC หรือ HTTP

การเรียกใช้ gRPC

คำขอ gRPC ไปยัง SFE จะมีลักษณะดังต่อไปนี้โดยใช้ Express ใน Node ด้วยไคลเอ็นต์ gRPC

import grpc from '@grpc/grpc-js';

// Load proto definition
const packageDefinition = protoLoader.loadSync(protoPath, { keepCase: true, enums: String });

const {
  privacy_sandbox: {
    bidding_auction_servers: { SellerFrontEnd }
  }
} = grpc.loadPackageDefinition(packageDefinition);

// Instantiate the gRPC client
const sfeGrpcClient = new SellerFrontEnd('192.168.84.104:50067', grpc.credentials.createInsecure());

// Send SelectAd request
sfeGrpcClient.selectAd(selectAdRequest,(error, response) => {
  // Handle SFE response
});

ดูคำจำกัดความของ Proto สำหรับไคลเอ็นต์ SFE ได้ใน ที่เก็บแอปทดสอบในเครื่อง

การเรียกใช้ HTTP ไปยังพร็อกซี Envoy

ระบบจะส่งคำขอ HTTP POST ไปยัง SFE ที่/v1/selectAd path และมีลักษณะดังนี้

fetch('https://ssp-ba.example/sfe/v1/selectAd', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(selectAdRequest),
});

ส่งต่อข้อมูลเมตา

ควรเพิ่มข้อมูลเมตาต่อไปนี้จากการเรียก SAS ของหน้าไปยังการเรียก SelectAd ของ SAS ไปยัง SFE

• Accept-Language
• User-Agent
• ที่อยู่ IP

เมื่อส่งข้อมูลเมตาไปยัง SFE ข้อมูลเมตาจะต้องใช้ส่วนหัวที่ไม่เป็นมาตรฐานต่อไปนี้ เนื่องจาก gRPC อาจเปลี่ยนแปลงส่วนหัว User-Agent

• X-Accept-Language
• X-User-Agent
• X-BnA-Client-IP

ตัวอย่างต่อไปนี้แสดงวิธีส่งต่อข้อมูลเมตาโดยใช้ Express ใน Node ด้วย gRPC client

sellerAdService.post('/ad-auction', (req, res) => {
  // …
  const metadata = new grpc.Metadata();
  metadata.add('X-Accept-Language', req.header('Accept-Language'));
  metadata.add('X-User-Agent', req.header('User-Agent'));
  metadata.add('X-BnA-Client-IP', req.ip);

  const sfeGrpcClient = createSfeGrpcClient();
  sfeGrpcClient.selectAd(selectAdRequest, metadata, callbackFn);
})

ตัวอย่างต่อไปนี้แสดงวิธีส่งต่อข้อมูลเมตาโดยใช้การเรียก HTTP

sellerAdService.post('/ad-auction', (req, res) => {
  // …
  fetch('https://ssp-ba.example/sfe/v1/selectAd', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-Accept-Language': req.header('Accept-Language'),
      'X-User-Agent': req.header('User-Agent'),
      'X-BnA-Client-IP': req.ip
    },
    body: JSON.stringify(selectAdRequest)
  });
})

การประมูลแบบผู้ขายหลายรายที่จัดโดยเซิร์ฟเวอร์

หากคุณเป็นผู้ขายระดับบนสุดที่เรียกใช้การประมูลแบบผู้ขายหลายรายที่จัดระเบียบเซิร์ฟเวอร์ ระบบจะเรียกใช้ GetComponentAuctionCiphertexts ไปยัง SFE ก่อนที่จะเรียกใช้ SelectAd การตอบกลับมีเพย์โหลดการประมูลคอมโพเนนต์ที่เข้ารหัสอีกครั้งซึ่งส่งไปยังบริการโฆษณาของผู้ขายคอมโพเนนต์ ผลการประมูลโฆษณา B&A ของคอมโพเนนต์ที่แสดงผลจะส่งไปยังการเรียกใช้ SelectAd ของ SFE ของผู้ขายระดับบนสุด

ดูข้อมูลเพิ่มเติมได้ที่คำอธิบายสำหรับผู้ขายหลายรายใน GitHub

ส่งผลการประมูล B&A กลับไปยังหน้าเว็บ

หลังจากที่การประมูล B&A สิ้นสุดลง ระบบจะส่งผลการประมูลที่เข้ารหัสไปยัง SAS และ SAS จะตอบกลับคำขอการประมูลแบบรวมจากหน้าเว็บในขั้นตอนที่ 2 ด้วยผลการประมูลที่เข้ารหัส ในการตอบกลับ SAS ไปยังหน้าเว็บ ระบบจะตั้งค่าแฮช SHA-256 ที่เข้ารหัส base64url ของผลการประมูลที่เข้ารหัสไว้ในส่วนหัวการตอบกลับ Ad-Auction-Result เบราว์เซอร์ใช้แฮชนี้เพื่อยืนยันเพย์โหลดเมื่อสิ้นสุดการประมูลในไคลเอ็นต์

การสร้างแฮช SHA-256 ด้วยการเข้ารหัส Base64 จะมีลักษณะดังนี้ใน Node

import { createHash } from 'crypto';

createHash('sha256')
  .update(binaryData, 'base64')
  .digest('base64url');

การแนบแฮชในส่วนหัวของการตอบกลับและการแสดงผลการประมูลในหน้าเว็บจะมีลักษณะดังนี้

sellerAdService.post('/ad-auction', (req, res) => {
  // …
  sfeGrpcClient.selectAd(selectAdRequest, metadata, (error, response) => {
    const { auction_result_ciphertext } = response;

    const ciphertextShaHash = createHash('sha256')
      .update(auction_result_ciphertext, 'base64')
      .digest('base64url');

    res.set('Ad-Auction-Result', ciphertextShaHash);

    res.json({
      protectedAudienceAuctionResult: encodeBinaryData(auction_result_ciphertext),
      contextualAuctionResult: getContextualAuctionResult()
    });
  });
})

เนื่องจากนี่คือการตอบกลับคำขอการประมูลแบบรวมที่ส่งจากหน้าเว็บในขั้นตอนที่ 2 ผลการประมูลตามบริบทจึงรวมอยู่ในการตอบกลับด้วย

คุณใส่แฮชหลายรายการใน Ad-Auction-Result ได้โดยทำซ้ำส่วนหัวหรือแยกแฮช ส่วนหัวการตอบกลับ 2 รายการต่อไปนี้มีความหมายเหมือนกัน

Ad-Auction-Result: ungWv48Bz-pBQUDeXa4iI7ADYaOWF3qctBD_YfIAFa0=,9UTB-u-WshX66Xqz5DNCpEK9z-x5oCS5SXvgyeoRB1k=

Ad-Auction-Result: ungWv48Bz-pBQUDeXa4iI7ADYaOWF3qctBD_YfIAFa0=
Ad-Auction-Result: 9UTB-u-WshX66Xqz5DNCpEK9z-x5oCS5SXvgyeoRB1k=

ดูตัวอย่างการเรียกนี้ได้ที่โค้ดเซิร์ฟเวอร์ของผู้ขายของแอปทดสอบในเครื่อง

โทรหา runAdAuction() เพื่อทำการประมูลให้เสร็จสมบูรณ์

การตอบกลับการประมูลแบบรวมที่ส่งคืนจาก SAS จะมีผลการประมูล B&A ที่เข้ารหัส ระบบจะส่งเพย์โหลดนี้ไปยังการเรียกใช้ runAdAuction() เพื่อสิ้นสุดการประมูลในเบราว์เซอร์ ระบบจะส่งค่า requestId จากการเรียก getInterestGroupAdAuctionData() ในขั้นตอนที่ 1 ไปยังการประมูลด้วย

// Get the encrypted ad auction data (Step #1)
const { requestId, request } = navigator.getInterestGroupAdAuctionData(adAuctionDataConfig)

// Send unified auction request (Step #2)
const response = await fetch('https://ssp-ba.example/ad-auction', {
  method: 'POST',
  body: JSON.stringify({
    adAuctionRequest: encodeBinaryData(request),
  }),
});

const { protectedAudienceAuctionResult } = await response.json();

// Finish the auction in the browser
await navigator.runAdAuction({
  // pass in "requestId" and "protectedAudienceAuctionResult"
  // the config structure will differ based on the auction configuration
});

โครงสร้างของการกำหนดค่าการประมูลที่ส่งไปยังการเรียกใช้ runAdAuction() จะแตกต่างกันไปตามการกำหนดค่าการประมูลที่ผู้ขายเลือก

การประมูลที่มีผู้ขายรายเดียว

สำหรับการเรียกใช้การประมูล B&A แบบผู้ขายรายเดียว ระบบจะสร้างการกำหนดค่าการประมูลของการเรียก runAdAuction() ดังนี้

await navigator.runAdAuction({
  seller: 'https://ssp-ba.example',
  requestId,
  serverResponse: protectedAudienceAuctionResult,
});

ฟิลด์ requestId จะยอมรับ requestId ที่ส่งคืนโดยการเรียก getInterestGroupAdAuctionData() ฟิลด์ serverResponse ยอมรับอาร์เรย์ไบต์ของการประมูล B&A ที่ทํางานในขั้นตอนที่ 3

ดูตัวอย่างการเรียกนี้ได้ที่โค้ด JavaScript ของผู้ขายของแอปทดสอบในเครื่อง

การประมูลแบบผสม

สําหรับการประมูล B&A แบบผสมที่ทั้งผู้ซื้อในอุปกรณ์และผู้ซื้อ B&A สามารถเข้าร่วมได้ ระบบจะสร้างการกําหนดค่าการประมูลของrunAdAuction()การเรียกใช้ในลักษณะต่อไปนี้

await navigator.runAdAuction({
  seller: 'https://ssp-mix.example',
  decisionLogicURL: 'https://ssp-mix.example/score-ad.js',
  componentAuctions: [
    // B&A auction result
    {
      seller: 'https://ssp-mix.example',
      requestId,
      serverResponse: protectedAudienceAuctionResult,
    },
    // On-device auction config
    {
      seller: 'https://ssp-mix.example',
      decisionLogicURL: 'https://ssp-mix.example/on-device-score-ad.js',
      interestGroupBuyers: [
        'https://dsp-a.example', // On-device buyer
        'https://dsp-a.example', // On-device buyer
      ],
    },
  ]
});

ระบบจะส่งผลการประมูล B&A และการกำหนดค่าการประมูลในอุปกรณ์ไปยังช่อง componentAuctions เพื่ออำนวยความสะดวกในการประมูลแบบผสม ในการประมูลแบบผสม ค่า seller จะเหมือนกันทั้งสำหรับการกำหนดค่าระดับบนสุดและการกำหนดค่าคอมโพเนนต์

ดูตัวอย่างการเรียกนี้ได้ที่โค้ด JavaScript ของผู้ขายของแอปทดสอบในเครื่อง

การประมูลที่มีผู้ขายหลายราย

หากคุณเป็นผู้ขายระดับบนสุดที่จัดการประมูลแบบหลายผู้ขายที่ประสานงานโดยอุปกรณ์ ผู้ขายที่เป็นส่วนประกอบแต่ละรายจะส่งผลการประมูล B&A และการกำหนดค่าการประมูลในอุปกรณ์

await navigator.runAdAuction({
  seller: 'https://ssp-top.example',
  decisionLogicURL: 'https://ssp-top.example/score-ad.js',
  componentAuctions: [
    // SSP-BA's B&A-only auction result
    {
      seller: 'https://ssp-ba.example',
      requestId: 'g8312cb2-da2d-4e9b-80e6-e13dec2a581c',
      serverResponse: Uint8Array(560) [193, 120, 4, …] // Encrypted B&A auction result
    },
    // SSP-MIX's B&A auction result
    {
      seller: 'https://ssp-mix.example',
      requestId: 'f5135cb2-da2d-4e9b-80e6-e13dec2a581c',
      serverResponse: Uint8Array(560) [133, 20, 4, …] // Encrypted B&A auction result
    }.
    // SSP-MIX's on-device auction config
    {
      seller: 'https://ssp-mix.example',
      interestGroupBuyers: ['https://dsp-a.example', 'https://dsp-b.example'],
      decisionLogicURL: 'https://ssp-mix.example/score-ad.js',
    }
    // SSP-OD's on-device auction config
    {
      seller: 'https://ssp-od.example',
      interestGroupBuyers: ['https://dsp-a.example', 'https://dsp-b.example'],
      decisionLogicURL: 'https://ssp-od.example/score-ad.js',
    }
  ]
})

ดูตัวอย่างการเรียกนี้ได้ที่โค้ด JavaScript ของผู้ขายของแอปทดสอบในเครื่อง

ขั้นตอนถัดไป

หลังจากอ่านคู่มือนี้แล้ว คุณสามารถทำตามขั้นตอนถัดไปได้ดังนี้

ดูข้อมูลเพิ่มเติม

• ดูข้อมูลเพิ่มเติมได้ที่คำอธิบายต่อไปนี้ใน GitHub
  • B&A API ใน Chrome
  • การออกแบบระบบ B&A
  • การประมูลแบบผู้ขายหลายรายของ B&A
  • การประมูลแบบผสม B&A
• ดูข้อมูลเพิ่มเติมเกี่ยวกับสถาปัตยกรรม B&A สำหรับเว็บ
• ทดสอบ Protected Audience ด้วย B&A โดยทำตาม Codelab การทดสอบในเครื่องแบบครบวงจร

หากมีคำถาม

• หากมีคำถามเกี่ยวกับบริการการเสนอราคาและการประมูล โปรดเปิดปัญหาในที่เก็บบริการ B&A