สร้างระบบมอนิเตอร์อัตโนมัติและ Web Scraper ด้วย Apidog Scheduled Tasks

งานที่ตั้งเวลาทำอะไรได้บ้าง?

มีงานอัตโนมัติมากมายที่สามารถทำได้ ผมขอเริ่มจากการยกตัวอย่างกรณีการใช้งานทั่วไปบางส่วนก่อน:

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

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

แต่ตอนนี้ ด้วยคุณสมบัติ "งานที่ตั้งเวลา" ของ Apidog สถานการณ์อัตโนมัติเหล่านี้ก็สามารถจัดการได้อย่างง่ายดาย

ใน Apidog การนำงานตั้งเวลาอัตโนมัติ เช่น การรวบรวมข้อมูลและการตรวจสอบ สามารถแบ่งออกเป็นขั้นตอนหลักๆ ดังนี้:

1. รับ API
2. การวิเคราะห์ข้อมูลที่ส่งคืน
3. จัดเรียงสถานการณ์การทดสอบ
4. ตั้งค่างานที่ตั้งเวลา

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

รับ API

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

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

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

จำเป็นต้องมีการส่ง Token เมื่อเรียกใช้ Open API และโดยทั่วไปสามารถสร้างได้ในส่วนหลังบ้านของนักพัฒนา

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

การวิเคราะห์ข้อมูลที่ส่งคืน

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

ตัวอย่างเช่น การเข้าถึง Open API ด้านล่างนี้สามารถรับข้อมูลที่เก็บสำหรับโปรเจกต์โอเพนซอร์สเฉพาะบน GitHub ได้:

curl -L \
   -H "Accept: application/vnd.github+json" \
   -H "Authorization: Bearer <YOUR-TOKEN>" \
   -H "X-GitHub-Api-Version: 2022-11-28" \
  https://api.github.com/repos/{owner}/{repo}

โดยที่ {owner} คือชื่อผู้ใช้หรือชื่อองค์กรของเจ้าของ Repository และ {repo} คือชื่อของ Repository หากต้องการค้นหาข้อมูลนี้ เพียงแค่ดูที่ URL ของ GitHub Repository:

1. เปิดหน้าโปรเจกต์ GitHub ที่คุณต้องการดู
2. ดูที่ URL ในแถบที่อยู่ของเบราว์เซอร์ ซึ่งอยู่ในรูปแบบ: https://github.com/{owner}/{repo}
3. ส่วนที่อยู่หลังเครื่องหมายทับแรกใน URL คือ {owner} ส่วนที่อยู่หลังเครื่องหมายทับที่สองคือ {repo}

ใน Apidog คุณสามารถคัดลอกเนื้อหาคำสั่ง cURL ด้านบนเพื่อสร้างคำขอ API ใหม่ได้โดยตรง หรือคุณสามารถตั้งค่าวิธีการร้องขอและ URL ด้วยตนเองพร้อมเพิ่ม Token ไปยังส่วนหัวของคำขอ

เมื่อคุณส่งคำขอ คุณจะได้รับ JSON response ดังนี้:

{
  "id": 468576060,
  "name": "openai-cookbook",
  "full_name": "openai/openai-cookbook",
  "stargazers_count": 59366,
  ...
}

หลังจากได้รับข้อมูล JSON ดิบแล้ว ขั้นตอนต่อไปคือการประมวลผลข้อมูล ใน Apidog เราสามารถใช้ JSONPath expression หรือเขียนสคริปต์ง่ายๆ เพื่อให้บรรลุเป้าหมายนี้ได้

ตัวอย่างเช่น หากต้องการใช้ JSONPath เพื่อดึงข้อมูลฟิลด์ที่เฉพาะเจาะจง คุณสามารถเพิ่มการดำเนินการ "Extract Variables" ใน "Post-processors" และกรอก expression ที่เกี่ยวข้อง หากคุณไม่คุ้นเคยกับวิธีการเขียน expression คุณสามารถคลิกไอคอนในช่องป้อนข้อมูล "JSONPath Expression" เพื่อใช้เครื่องมือช่วยดึงข้อมูล JSONPath

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

นอกเหนือจากรูปแบบ JSON ทั่วไปแล้ว ยังมีอีกประเภทหนึ่งที่ส่งคืนเอกสาร HTML ทั้งหมดโดยตรง ซึ่งเป็นเรื่องปกติมากในสถานการณ์การเรนเดอร์ฝั่งเซิร์ฟเวอร์ สำหรับกรณีนี้ เราจำเป็นต้องใช้สคริปต์ในการประมวลผล

ใน Apidog คุณสามารถสร้าง "Custom Script" ใหม่ใน "Post-processors" และใช้วิธี fox.liveRequire เพื่ออ้างอิงไลบรารี htmlparser2 เพื่อประมวลผลข้อมูลรูปแบบ HTML

ตัวอย่างเช่น หากคุณต้องการดึงแท็ก <article> ทั้งหมดและเนื้อหาภายในจาก HTML และแปลงเป็นรูปแบบข้อความ คุณสามารถเขียนสคริปต์ได้ดังนี้:

fox.liveRequire("htmlparser2", (htmlparser2) => {
    
    console.log(htmlparser2);

    // HTML string (generally read from interface return data)
    const htmlString = `
    <html>
        <body>
        <article>
            <h1>Title</h1>
            <p>This is a paragraph.</p>
            <p>Another piece of text.</p>
        </article>
        <footer>Footer content</footer>
        </body>
    </html>
    `;

    // Parse document
    const document = htmlparser2.parseDocument(htmlString);

    // Use DomUtils to find <article> tags
    const article = htmlparser2.DomUtils.findOne(elem => elem.name === "article", document.children);

    // Convert content in <article> to complete HTML fragment
    if (article) {
        const articleHTML = htmlparser2.DomUtils.getOuterHTML(article);
        console.log(articleHTML);
    } else {
        console.log("No <article> tag found.");
    }
})

การประมวลผลเนื้อหารูปแบบ HTML ผ่านสคริปต์จะไม่ได้ลงรายละเอียดมากนักในที่นี้ คุณสามารถเข้าใจง่ายๆ ว่านี่คือ "การจัดการ DOM" - คุณสามารถสอบถาม AI เพื่อดูรายละเอียดเฉพาะเจาะจงได้

จัดเรียงสถานการณ์การทดสอบ

เมื่อ API พร้อมและข้อมูลได้รับการวิเคราะห์แล้ว ขั้นตอนต่อไปคือการจัดเรียงสถานการณ์การทดสอบในการทดสอบอัตโนมัติ

ใน Apidog คุณสามารถสร้างสถานการณ์การทดสอบในการทดสอบอัตโนมัติและนำเข้าคำขอ API ที่เตรียมไว้เข้าไปได้

หากคุณต้องการแทรกข้อมูลที่ประมวลผลแล้วลงในฐานข้อมูล คุณสามารถสร้าง "Database Operation" ใหม่ใน "Post-processors" และแทรกข้อมูลที่ประมวลผลแล้วลงในฐานข้อมูลผ่านคำสั่ง SQL คำสั่ง SQL รองรับการอ่านค่าจากตัวแปรสภาพแวดล้อม ตัวอย่างเช่น:

INSERT INTO monitoring_data (project_name, star_count, updated_time) 
VALUES ('{{project_name}}', {{star_count}}, NOW())

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

ตัวอย่างเช่น หากฉันต้องการส่งข้อมูลที่ประมวลผลแล้วไปยัง Feishu (Lark) ฉันสามารถเพิ่มขั้นตอนการทดสอบใหม่ในสถานการณ์การทดสอบและใช้ Webhook API ที่ Feishu ให้มาเพื่อส่งข้อความ ในระหว่างกระบวนการนี้ คุณสามารถอ่านผลลัพธ์การดำเนินการของขั้นตอนก่อนหน้าผ่าน "Dynamic Values" ซึ่งทำให้การประมวลผลข้อมูลสะดวกยิ่งขึ้น

หากคุณต้องการวนซ้ำกลุ่มข้อมูล หรือให้ฟิลด์ที่ส่งคืนตรงตามเงื่อนไขเฉพาะบางอย่างก่อนที่จะดำเนินการต่อ คุณยังสามารถเพิ่ม "Flow Control Conditions" ไปยังขั้นตอนการทดสอบได้อีกด้วย

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

ตั้งค่างานที่ตั้งเวลา

ใน Apidog การตั้งค่างานที่ตั้งเวลาทำได้ง่ายมาก อย่างไรก็ตาม ข้อกำหนดเบื้องต้นสำหรับการใช้งานงานที่ตั้งเวลาคือคุณต้องได้ติดตั้ง Runner บนเซิร์ฟเวอร์แล้ว คุณสามารถอ้างอิงคู่มือโดยละเอียดเกี่ยวกับขั้นตอนการติดตั้งและกำหนดค่า Runner ได้

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

ในการทดสอบอัตโนมัติของ Apidog ให้ค้นหาโมดูล "Scheduled Tasks" จากนั้นสร้างงานที่ตั้งเวลาใหม่ ในส่วนติดต่อการกำหนดค่า คุณจะเห็นตัวเลือกดังต่อไปนี้:

• ชื่อภารกิจ: ตั้งชื่อภารกิจให้สื่อความหมาย เช่น "การตรวจสอบจำนวนดาว GitHub รายวัน"
• สถานการณ์การทดสอบ: เลือกสถานการณ์การทดสอบที่ต้องทำงานเป็นประจำ เช่น สถานการณ์การตรวจสอบที่ตั้งเวลาไว้ หรือสถานการณ์การทดสอบการรวบรวมข้อมูล
• ตั้งค่ารอบการทำงาน: ตัวอย่างเช่น ทำงานวันละครั้งเวลา 18:00 น.
• สภาพแวดล้อมการทำงาน: เลือกบริการ Runner ที่ติดตั้งไว้
• การตั้งค่าการแจ้งเตือน: ระบุวิธีการแจ้งเตือนหลังจากงานเสร็จสมบูรณ์ ซึ่งอาจเป็นอีเมล, DingTalk ฯลฯ

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

ส่วนขยาย

ในส่วน "รับ API" ด้านบน นอกจากการค้นหา API บนแพลตฟอร์มเปิดอย่างเป็นทางการแล้ว คุณยังสามารถดักจับแพ็กเก็ตในเบราว์เซอร์ได้โดยตรงอีกด้วย

นี่คือตัวอย่าง:

สมมติว่าเราต้องการตรวจสอบหัวข้อที่กำลังเป็นที่นิยมบน Weibo เราสามารถเปิดหน้าเทรนด์ Weibo ในเบราว์เซอร์ จากนั้นกด F12 หรือ Ctrl + Shift + I เพื่อเปิดเครื่องมือสำหรับนักพัฒนา และสลับไปที่แท็บ Network รีเฟรชหน้าเว็บ แล้วคุณจะเห็นคำขอจำนวนมาก ค้นหาคำขอที่ดึงข้อมูลเทรนด์ คลิกขวาแล้วคัดลอกเป็น cURL จากนั้น เปิด Apidog สร้างอินเทอร์เฟซใหม่ และวาง cURL ที่คุณเพิ่งคัดลอกลงในช่องป้อนข้อมูล Apidog จะแยกวิเคราะห์ให้เราโดยอัตโนมัติ - สะดวกสุดๆ!

นอกจากการดักจับแพ็กเก็ตแล้ว นักพัฒนาบุคคลที่สามบางรายอาจได้ทำการย้อนรอยวิศวกรรม API ของบริการบางอย่างไว้แล้ว คุณสามารถค้นหาบน GitHub และใช้งานได้โดยตรงหากจำเป็น

บทสรุป

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