จัดการข้อมูลอย่างมีประสิทธิภาพ

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

ทำความเข้าใจนโยบายการใช้งานทรัพยากรของ Google สำหรับรายงาน

Google Ads API จะควบคุมรูปแบบการค้นหา GoogleAdsService.Search และ GoogleAdsService.SearchStream ที่ใช้ทรัพยากร API มากเกินไป เพื่อให้มั่นใจว่าเซิร์ฟเวอร์จะเสถียร หากมีการควบคุมรูปแบบการค้นหาหนึ่งๆ บริการ วิธีการ และรูปแบบการค้นหาอื่นๆ จะยังคงทำงานต่อไปโดยไม่ได้รับผลกระทบ ระบบจะแสดงข้อผิดพลาดต่อไปนี้สำหรับคำขอที่ถูกควบคุม

หากพบข้อผิดพลาดเหล่านี้ ให้รอ 5 นาทีก่อนที่จะลองส่งคำขอที่ล้มเหลวด้วย QuotaError.EXCESSIVE_SHORT_TERM_QUERY_RESOURCE_CONSUMPTION อีกครั้ง และรอ 30 นาทีสำหรับคำขอที่ล้มเหลวด้วย QuotaError.EXCESSIVE_LONG_TERM_QUERY_RESOURCE_CONSUMPTION

นอกจากนี้ เราจะแสดงเมตริกค่าใช้จ่ายสำหรับรายงานแต่ละรายการด้วย เพื่อช่วยคุณระบุและตรวจสอบรายงานที่มีค่าใช้จ่ายสูง

เมตริกค่าใช้จ่ายที่แสดงผลโดยช่องเหล่านี้ขึ้นอยู่กับปัจจัยต่างๆ เช่น

• ขนาดบัญชี
• มุมมองและคอลัมน์ที่คุณดึงข้อมูลในรายงาน
• ภาระงานในเซิร์ฟเวอร์ Google Ads API

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

ตัวอย่างเช่น สมมติว่าคุณใช้รูปแบบการค้นหาต่อไปนี้ ซึ่งใช้ทรัพยากร 600 หน่วยต่อรายงาน

SELECT campaign.id, campaign.name, metrics.cost_micros FROM campaign WHERE
    segments.date = "YYYY-MM-DD"

คุณเรียกใช้การค้นหานี้สำหรับบัญชีลูกค้าหลายบัญชีในวันที่ต่างๆ โดยการแก้ไขการค้นหาเพื่อแทนที่ค่าต่างๆ สำหรับตัวกรอง segments.date ตารางต่อไปนี้แสดงจำนวนรายงานที่คุณเรียกใช้ได้ในกรอบเวลาที่กำหนดเพื่อให้การใช้ทรัพยากรอยู่ในกลุ่มการใช้ทรัพยากรต่างๆ

การเรียกใช้รูปแบบการค้นหานี้ 10 ครั้งใน 5 นาทีจะถือเป็นการใช้งานโดยเฉลี่ย ในขณะที่การเรียกใช้รายงาน 3, 000 รายการใน 5 นาทีจะถือเป็นการใช้งานสูงมาก

มีกลยุทธ์หลายอย่างในการเพิ่มประสิทธิภาพการใช้ทรัพยากรของรายงาน ส่วนที่เหลือของคู่มือนี้จะครอบคลุมกลยุทธ์บางอย่าง

แคชข้อมูล

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

เพิ่มประสิทธิภาพความถี่ในการเรียกใช้รายงาน

Google Ads ได้เผยแพร่หลักเกณฑ์เกี่ยวกับความใหม่ของข้อมูลและความถี่ในการอัปเดตข้อมูล คุณควรใช้คำแนะนำนี้เพื่อกำหนดความถี่ในการดึงข้อมูลรายงาน

หากต้องการอัปเดตบัญชีเป็นประจำ เราขอแนะนำให้จำกัดจำนวนบัญชีดังกล่าวไว้เพียงเล็กน้อย เช่น เฉพาะบัญชี Google Ads 20 อันดับแรก ส่วนที่เหลือสามารถอัปเดตได้ด้วยความถี่ที่ต่ำกว่า เช่น วันละ 1 หรือ 2 ครั้ง

เพิ่มประสิทธิภาพขนาดรายงาน

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

ตัวอย่างเช่น ลองดูโค้ดต่อไปนี้ที่ดึงข้อมูลสถิติสำหรับกลุ่มโฆษณาที่เฉพาะเจาะจงและอัปเดตตารางฐานข้อมูลสถิติ

  List<long> adGroupIds = FetchAdGroupIdsFromLocalDatabase();

  foreach (long adGroupId in adGroupIds)
  {
    string query = "SELECT ad_group.id, ad_group.name, metrics.clicks, " +
        "metrics.cost_micros, metrics.impressions, segments.date FROM " +
        "ad_group WHERE segments.date DURING LAST_7_DAYS AND " +
        "ad_group.id = ${adGroupId}";
    List<GoogleAdsRow> rows = RunGoogleAdsReport(customerId, query);
    InsertRowsIntoStatsTable(adGroupId, rows);
  }

โค้ดนี้ทำงานได้ดีในบัญชีทดสอบขนาดเล็ก อย่างไรก็ตาม Google Ads รองรับกลุ่มโฆษณาได้สูงสุด 20,000 กลุ่มต่อแคมเปญ และแคมเปญ 10,000 รายการต่อบัญชี ดังนั้น หากโค้ดนี้ทำงานกับบัญชี Google Ads ขนาดใหญ่ ก็อาจทำให้เซิร์ฟเวอร์ Google Ads API ทำงานหนักเกินไป ซึ่งนำไปสู่การจำกัดอัตราคำขอและการควบคุม

แนวทางที่ดีกว่าคือการเรียกใช้รายงานเดียวและประมวลผลในเครื่อง ตัวอย่างแนวทางหนึ่งที่ใช้การแมปในหน่วยความจำแสดงไว้ด้านล่าง

  Hashset<long> adGroupIds = FetchAdGroupIdsFromLocalDatabase();

  string query = "SELECT ad_group.id, ad_group.name, metrics.clicks, " +
      "metrics.cost_micros, metrics.impressions, segments.date FROM " +
      "ad_group WHERE segments.date DURING LAST_7_DAYS";
  List<GoogleAdsRow> rows = RunGoogleAdsReport(customer_id, query);

  var memoryMap = new Dictionary<long, List<GoogleAdsRow>>();
  for each (GoogleAdsRow row in rows)
  {
    var adGroupId = row.AdGroup.Id;

    if (adGroupIds.Contains(adGroupId))
    {
      CheckAndAddRowIntoMemoryMap(row, adGroupId, memoryMap);
    }
  }
  foreach (long adGroupId in memoryMap.Keys())
  {
    InsertRowsIntoStatsTable(adGroupId, rows);
  }

วิธีนี้จะช่วยลดภาระงานในเซิร์ฟเวอร์ Google Ads API เนื่องจากมีการเรียกใช้รายงานจำนวนน้อยลง

หากพบว่ารายงานมีขนาดใหญ่เกินกว่าจะเก็บไว้ในหน่วยความจำ คุณสามารถแบ่งการค้นหาออกเป็นกลุ่มเล็กลงได้โดยเพิ่มคําสั่ง LIMIT ดังนี้

SELECT
  ad_group.id,
  ad_group.name,
  metrics.clicks,
  metrics.cost_micros,
  metrics.impressions,
  segments.date
FROM ad_group
WHERE segments.date DURING LAST_7_DAYS
  AND ad_group.id IN (id1, id2, ...)
LIMIT 100000

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

เพิ่มประสิทธิภาพสิ่งที่คุณดึงข้อมูล

เมื่อเรียกใช้รายงาน คุณควรคำนึงถึงคอลัมน์ที่คุณรวมไว้ในการค้นหา ลองดูตัวอย่างต่อไปนี้ที่กำหนดเวลาให้เรียกใช้ทุกชั่วโมง

SELECT
  customer.id,
  customer.currency_code,
  campaign.id,
  campaign.name,
  ad_group.id,
  ad_group.name,
  ad_group_criterion.keyword.match_type,
  ad_group_criterion.keyword.text,
  ad_group_criterion.criterion_id,
  ad_group_criterion.quality_info.creative_quality_score,
  ad_group_criterion.system_serving_status,
  ad_group_criterion.negative,
  ad_group_criterion.quality_info.quality_score,
  ad_group_criterion.quality_info.search_predicted_ctr,
  ad_group_criterion.quality_info.post_click_quality_score,
  metrics.historical_landing_page_quality_score,
  metrics.search_click_share,
  metrics.historical_creative_quality_score,
  metrics.clicks,
  metrics.impressions
FROM keyword_view
WHERE segments.date DURING LAST_7_DAYS

คอลัมน์ที่มีแนวโน้มว่าจะเปลี่ยนแปลงทุกชั่วโมงคือ metrics.clicks และ metrics.impressions คอลัมน์อื่นๆ ทั้งหมดจะอัปเดตไม่บ่อยนักหรือไม่อัปเดตเลย ดังนั้นการดึงข้อมูลทุกชั่วโมงจึงไม่มีประสิทธิภาพอย่างยิ่ง คุณสามารถจัดเก็บค่าเหล่านี้ ไว้ในฐานข้อมูลในเครื่องและเรียกใช้รายงานเหตุการณ์การเปลี่ยนแปลง หรือ สถานะการเปลี่ยนแปลง เพื่อดาวน์โหลดการเปลี่ยนแปลงวันละ 1 หรือ 2 ครั้ง

ในบางกรณี คุณสามารถลดจำนวนแถวที่ดาวน์โหลดได้โดยใช้ตัวกรองที่เหมาะสม

ล้างบัญชีที่ไม่ได้ใช้

หากแอปพลิเคชันของคุณจัดการบัญชีลูกค้าของบุคคลที่สาม คุณต้องพัฒนาแอปพลิเคชันโดยคำนึงถึงการเลิกใช้บริการของลูกค้า คุณควรล้างกระบวนการและที่เก็บข้อมูลเป็นระยะๆ เพื่อนำบัญชีของลูกค้าที่ไม่ได้ใช้แอปพลิเคชันของคุณอีกต่อไปออก เมื่อล้างบัญชี Google Ads ที่ไม่ได้ใช้ โปรดคำนึงถึงคำแนะนำต่อไปนี้

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