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

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

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

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

ขั้นตอนต่างๆ สรุปได้ดังนี้

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

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

แผนภาพการแนะนำแบบเดียวกันที่ไฮไลต์ขั้นตอนแรก ซึ่งเป็นเวลาที่โค้ด JavaScript ของผู้ขายเรียก getInterestGroupAdAuctionData

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

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;
ช่อง คำอธิบาย
seller ต้องระบุ ต้นทางของผู้ขายที่ทำการประมูล ค่านี้ต้องตรงกับค่า seller ในการเรียกใช้ runAdAuction() ในภายหลัง
requestSize ไม่บังคับ กําหนดขนาดเพย์โหลดสูงสุดของข้อมูลผู้ซื้อทั้งหมด ดูข้อมูลเพิ่มเติมได้ที่ส่วนขนาดคำขอของคำอธิบาย
perBuyerConfig ไม่บังคับ ตั้งค่าการกำหนดค่าสำหรับผู้ซื้อแต่ละราย รวมถึงควบคุมผู้ซื้อที่จะเข้าร่วมการประมูล B&A ด้วย

หากแหล่งที่มาของผู้ซื้อแสดงอยู่ใน perBuyerConfig ระบบจะรวมเฉพาะข้อมูลกลุ่มความสนใจของผู้ซื้อเหล่านั้นไว้ในเพย์โหลด หากไม่มีผู้ซื้อแสดงอยู่ใน perBuyerConfig ระบบจะรวมกลุ่มความสนใจทั้งหมดของผู้ใช้ไว้ในเพย์โหลด
targetSize ไม่บังคับหากตั้งค่า requestSize ไว้ ต้องระบุหากตั้งค่าต้นทางของผู้ซื้อใน perBuyerConfig แต่ไม่ได้ตั้งค่า requestSize

กําหนดขนาดเพย์โหลดสูงสุดของข้อมูลของผู้ซื้อรายนั้น ดูข้อมูลเพิ่มเติมได้ที่ส่วนขนาดคำขอของคำอธิบาย
coordinatorOrigin ไม่บังคับ แต่จะต้องระบุในท้ายที่สุด ค่าเริ่มต้นคือ https://publickeyservice.pa.gcp.privacysandboxservices.com เมื่อไม่ได้ตั้งค่าไว้

ตั้งค่าผู้ประสานงานที่จะใช้ดึงข้อมูลคีย์สําหรับการเข้ารหัสเพย์โหลด ดูข้อมูลเพิ่มเติมได้ในส่วนผู้ประสานงานของคำอธิบาย

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

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

ภาพหน้าจอเครื่องมือสำหรับนักพัฒนาเว็บใน Chrome ที่แสดงคําขอและรหัสคําขอที่มีอยู่ในข้อมูลการประมูลโฆษณา

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

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

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

แผนภาพการแนะนำแบบเดียวกันที่ไฮไลต์ขั้นตอนที่ 2 ซึ่งเป็นเวลาที่โค้ด JavaScript ของผู้ขายส่งคําขอการประมูลแบบรวมไปยัง SAS

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

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

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

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

เนื้อความของการเรียกใช้ประกอบด้วยข้อมูลต่อไปนี้

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

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

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

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

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

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

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

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

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

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

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

แผนภาพการแนะนำแบบเดียวกันที่ไฮไลต์ขั้นตอนที่ 3 ซึ่งเป็นตอนที่ SAS ส่งคําขอ SelectAd ไปยัง SFE และ SFE ทำการประมูล B&A

เมื่อบริการโฆษณาของผู้ขายได้รับคําขอการประมูลแบบรวมจากหน้าเว็บ การประมูลตามบริบทจะทํางานก่อนเพื่อระบุผู้ชนะการประมูลตามบริบทและรวบรวมสัญญาณของผู้ซื้อเพื่อส่งไปยังการประมูล B&A ของ PA จากนั้นระบบจะเริ่มการประมูล 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
});

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

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

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

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

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

คุณควรเพิ่มข้อมูลเมตาต่อไปนี้จากการเรียก SAS ของหน้าเว็บลงในSelectAdของ SAS ที่เรียก SFE

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

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

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

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 กลับไปยังหน้าเว็บ

แผนภาพแสดงขั้นตอนที่เหมือนกันซึ่งไฮไลต์ขั้นตอนที่ 4 ซึ่งเป็นตอนที่ SAS ส่งผลการประมูลของ SelectAd กลับไปที่เบราว์เซอร์

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

การสร้างแฮช SHA-256 ที่เข้ารหัสฐาน 64 ใน 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() เพื่อทำการประมูลให้เสร็จสมบูรณ์

แผนภาพการแนะนำแบบเดียวกันที่ไฮไลต์ขั้นตอนที่ 5 ซึ่งเป็นเวลาที่โค้ด JavaScript ฝั่งไคลเอ็นต์เรียกใช้การประมูลและส่งการตอบกลับของเซิร์ฟเวอร์

การตอบกลับการประมูลแบบรวมที่ส่งคืนจาก 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 ของผู้ขายในแอปทดสอบในเครื่อง

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

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

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

หากมีคำถาม