<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Kriangsak Sumthong on Medium]]></title>
        <description><![CDATA[Stories by Kriangsak Sumthong on Medium]]></description>
        <link>https://medium.com/@puk.kriangsak?source=rss-c50d774af4fc------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*0yOq1EqbbF-xK1dhOmZN0A.png</url>
            <title>Stories by Kriangsak Sumthong on Medium</title>
            <link>https://medium.com/@puk.kriangsak?source=rss-c50d774af4fc------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 11:27:22 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@puk.kriangsak/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Spark Join Strategies Explained: How to Process Big Data Efficiently]]></title>
            <link>https://medium.com/@puk.kriangsak/spark-join-strategies-explained-how-to-process-big-data-efficiently-e124c63fc305?source=rss-c50d774af4fc------2</link>
            <guid isPermaLink="false">https://medium.com/p/e124c63fc305</guid>
            <category><![CDATA[spark]]></category>
            <category><![CDATA[clouddatalabor]]></category>
            <category><![CDATA[pyspark]]></category>
            <dc:creator><![CDATA[Kriangsak Sumthong]]></dc:creator>
            <pubDate>Mon, 02 Nov 2026 15:46:36 GMT</pubDate>
            <atom:updated>2026-11-02T15:46:36.035Z</atom:updated>
            <content:encoded><![CDATA[<p>ผมไปเจอคลิปหนึ่งของช่อง DataExpert ชื่อว่า “Processing 2000 TBs per day of network data at Netflix with Spark and Airflow” แค่อ่านชื่อก็ชวนให้คิดต่อแล้วว่า ในสเกลข้อมูลระดับนี้ การเลือกวิธี join ผิดเพียงจุดเดียว ต้นทุนและเวลาจะบานปลายไปขนาดไหน แม้ในงานจริงผมจะเอาเคสของบริษัทมาเปิดโชว์ไม่ได้ 😆 และสเกลข้อมูลในไทยอาจจะไม่ได้วิ่งไปถึงระดับ 2,000 TB ต่อวันแบบ Netflix (แต่ที่ดูแลอยู่ก็หนักเอาเรื่องอยู่นะ 🥹)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GVb3LXJ3ynP5X13P" /></figure><p>หลักการเบื้องหลังที่ใช้รับมือกับมันกลับเป็นเรื่องเดียวกันทั้งหมด Blog นี้เลยขอพาไปเจาะลึกฝั่งกลไกและทฤษฎีแบบเน้นๆ ว่า Join ใน Spark มีกี่แบบ แต่ละแบบทำงานข้างในยังไง และ Spark ตัดสินใจเลือกวิธีไหนให้เราครับ</p><h3>ทำไม Join ถึงเป็นเรื่องใหญ่บน Big Data</h3><p>ถ้าเป็น Database ตัวเดียว การ join ก็คือเอาสองตารางมาจับคู่กันด้วย key แล้ว Engine ก็ทำจบในเครื่องเดียว แต่ทีนี้ใน Spark ข้อมูลถูกแบ่งเป็น Partition กระจายอยู่ตามเครื่องต่างๆ</p><p>เช่น แถวที่ customer_id = 42 ของตารางซ้ายอาจอยู่เครื่องหนึ่ง ในขณะที่แถว customer_id = 42 ของตารางขวาไปอยู่อีกเครื่อง ก่อนจะจับคู่กันได้ก็ต้องเอาแถวที่ key เดียวกันมากองรวมไว้ที่เดียวกันก่อน</p><p>กระบวนการย้ายข้อมูลข้ามเครื่องแบบนี้เรียกว่า Shuffle ซึ่งต้องเขียนลงดิสก์ ส่งผ่านเครือข่าย แล้วอ่านกลับมาอีกที เป็นส่วนที่แพงที่สุดของ job ส่วนใหญ่เลยครับ สรุปง่ายๆ ได้ว่า</p><blockquote>Join คือการทำให้ key เดียวกันมาเจอกัน ส่วน Shuffle คือราคาที่ต้องจ่ายเพื่อให้มันเจอกัน</blockquote><p>ทั้งบทความนี้จึงวนอยู่กับคำถามเดียวคือ จะทำยังไงให้จ่ายราคานี้น้อยที่สุดครับ<br>“ราคา” ในที่นี้คือเวลาและทรัพยากรที่ต้องเสียไปกับการขนข้อมูลข้ามเครื่อง ทุกแถวที่ต้องย้ายจะถูกแปลงเป็น bytes เขียนลงดิสก์ ส่งผ่านเครือข่าย แล้วอ่านกลับมารวมกันที่ปลายทาง ยิ่งข้อมูลเยอะก็ยิ่งแพงทั้งเวลา Network Disk และ memory</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qhEYNhqzZjvB6uLA" /></figure><h3>Join Type กับ Join Strategy คนละเรื่องกันเลย</h3><p>สองคำนี้มักถูกปนกันบ่อยมากและทำให้สับสนเวลาพูดถึง ขอแยกให้ชัดก่อน</p><ul><li><strong>Join Type</strong> ตอบคำถามว่า “อยากได้แถวอะไรกลับมา” เช่น Inner, Left, Full เป็นเรื่องของความหมายเชิงตรรกะ ผลลัพธ์ต้องออกมาเหมือนกันไม่ว่า Spark จะรันด้วยวิธีไหน</li><li><strong>Join Strategy</strong> ตอบคำถามว่า “Spark จะลงมือทำยังไง” เช่น Broadcast Hash Join, Sort Merge Join เป็นเรื่องของประสิทธิภาพล้วนๆ ผลลัพธ์เหมือนเดิม แต่เวลาและทรัพยากรที่ใช้ต่างกันได้มหาศาล</li></ul><p>เราเป็นคนเลือก Join Type ส่วน Join Strategy นั้น Spark จะเลือกให้ (และเราก็สามารถไปชี้นำมันได้ด้วย Hint ซึ่งจะเล่าให้ฟังด้านล่างครับ)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CnMR0cJQiAfsyV7R" /></figure><h3>Join Type: อยากได้แถวอะไรกลับมา</h3><p>เพื่อให้เห็นภาพ สมมติว่ามีสองตารางที่ key ไม่ตรงกันเสียทีเดียว</p><pre>orders     : customer_id = 1, 2, 3<br>customers  : customer_id = 2, 3, 4</pre><p>ตาราง orders มีลูกค้าหมายเลข 1 ที่ไม่มีอยู่ในตาราง customers และตาราง customers ก็มีลูกค้าหมายเลข 4 ที่ยังไม่เคยสั่งซื้อ คราวนี้ลองดูว่าแต่ละ Join Type จะให้อะไรกลับมาบ้าง</p><ul><li>Inner Join: เอาเฉพาะ key ที่เจอทั้งสองฝั่ง ได้ลูกค้า 2 กับ 3 เป็นค่า default ของ Spark SQL เลยครับ</li><li>Left Outer Join: เก็บทุกแถวของ orders ไว้ครบ ใครไม่มีคู่ฝั่งขวาก็ได้ค่า NULL ในคอลัมน์ของ customers ได้ลูกค้า 1, 2, 3</li><li>Right Outer Join: กลับด้านกับ Left เก็บทุกแถวของ customers ได้ลูกค้า 2, 3, 4</li><li>Full Outer Join: เก็บทั้งสองฝั่ง ฝั่งไหนไม่มีคู่ก็เติม NULL ได้ลูกค้า 1, 2, 3, 4</li><li>Left Semi Join: คืนเฉพาะแถวฝั่งซ้ายที่ “มีคู่” ในฝั่งขวา ได้ลูกค้า 2 กับ 3 แต่ได้เฉพาะคอลัมน์ของ orders เท่านั้น ตารางขวาทำหน้าที่เป็นแค่ตัวกรอง และแถวซ้ายแต่ละแถวจะถูกคืนมาอย่างมากแค่ครั้งเดียว ไม่ว่าฝั่งขวาจะมีคู่กี่แถวก็ตาม</li><li>Left Anti Join: ตรงข้ามกับ Semi คืนเฉพาะแถวฝั่งซ้ายที่ “ไม่มีคู่” ได้ลูกค้า 1 ตอบโจทย์แนว “ลูกค้าที่ยังไม่เคยทำรายการ” ได้ตรงๆ โดยไม่ต้อง Left Join แล้วมานั่งเช็ค NULL อีกที</li><li>Cross Join: จับคู่ทุกแถวกับทุกแถว 3 x 3 ได้ 9 แถว ไม่มีเงื่อนไข key เลย</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*NKy9-SoHrJEvQP7b" /></figure><p>ใน DataFrame API ก็สั่งผ่าน argument ตัวที่สามตรงๆ แบบนี้ได้เลยครับ</p><pre>orders.join(customers, &quot;customer_id&quot;, &quot;inner&quot;)<br>orders.join(customers, &quot;customer_id&quot;, &quot;left&quot;)       # หรือ left_outer<br>orders.join(customers, &quot;customer_id&quot;, &quot;right&quot;)      # หรือ right_outer<br>orders.join(customers, &quot;customer_id&quot;, &quot;full&quot;)       # หรือ outer, full_outer<br>orders.join(customers, &quot;customer_id&quot;, &quot;left_semi&quot;)  # หรือ semi<br>orders.join(customers, &quot;customer_id&quot;, &quot;left_anti&quot;)  # หรือ anti<br>orders.crossJoin(customers)</pre><p>มีเรื่องเล็กๆ ที่คนมักพลาดอยู่หนึ่งเรื่องคือ <strong>key ที่เป็น NULL จะไม่ถูกจับคู่กันเอง</strong> เพราะตามหลัก SQL แล้ว NULL = NULL ไม่ได้ให้ผลเป็นจริง ถ้าฝั่งซ้ายมี NULL หนึ่งแถว ฝั่งขวามี NULL หนึ่งแถว Inner Join ปกติจะไม่คืนคู่นี้มาให้ ถ้าอยากให้ NULL จับคู่กับ NULL ต้องใช้ null-safe equality อย่าง &lt;=&gt; ใน SQL หรือ eqNullSafe ใน DataFrame ครับ</p><h3>Join Strategy: Spark ลงมือ join ยังไง</h3><p>ทีนี้มาถึงส่วนที่ทำให้ job เร็วหรือช้ากันจริงๆ เวลาเรียก .explain() เราจะเห็นชื่อ Operator ใน Physical Plan ซึ่งมีให้เจออยู่ห้าตัวหลักๆ</p><h4>1. Broadcast Hash Join (BHJ)</h4><blockquote>BroadcastHashJoin</blockquote><p>ไอเดียคือ ถ้าฝั่งหนึ่งเล็กพอ ก็ไม่ต้องไปขยับฝั่งใหญ่เลย Spark จะรวบฝั่งเล็กมาที่ Driver ก่อน แล้วส่งสำเนาไปให้ทุก Executor แต่ละ Executor สร้าง Hash Table จากฝั่งเล็กเก็บไว้ใน memory จากนั้นก็ไล่อ่านฝั่งใหญ่ที่ตัวเองถืออยู่ทีละแถว แล้วไปค้นใน Hash Table ได้ทันที ฝั่งใหญ่จึงไม่ต้อง Shuffle เลยครับ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*67BXqGHl2__Qacke" /></figure><p>ข้อควรรู้ของ BHJ มีหลายข้อ</p><ul><li>ใช้ได้กับ equi join (เงื่อนไขเท่ากับ) เท่านั้น</li><li>Spark จะเลือก BHJ ให้อัตโนมัติเมื่อประเมินว่าฝั่งนั้นเล็กกว่า spark.sql.autoBroadcastJoinThreshold ซึ่งค่า default คือ 10 MB (ตั้งเป็น -1 เพื่อปิดได้) หรือเราจะสั่งเองด้วย Hint ก็ได้</li><li>Spark ต้อง “รู้” ขนาดของฝั่งเล็กก่อน ซึ่งมาจาก Statistics ของไฟล์หรือตาราง ถ้าไม่มีข้อมูลขนาด เช่น DataFrame ที่สร้างมาจาก RDD Spark จะไม่กล้า Broadcast ให้เอง และเลือกทางที่ปลอดภัยกว่าอย่าง Sort Merge Join ไปก่อน</li><li>ฝั่งที่ต้อง “เก็บแถวไว้ให้ครบ” Broadcast ไม่ได้ เช่น ฝั่งซ้ายของ Left Outer ฝั่งขวาของ Right Outer และ Full Outer Broadcast ไม่ได้เลยทั้งสองฝั่ง เหตุผลคือการจะรู้ว่าแถวไหน “ไม่มีคู่” ต้องเห็นข้อมูลอีกฝั่งทั้งหมด แต่ Executor แต่ละตัวเห็นแค่ฝั่งใหญ่เป็นบางส่วนเท่านั้น (ส่วน Inner, Left ที่ Broadcast ฝั่งขวา, Semi และ Anti ทำได้ปกติ)</li><li>ถ้าใหญ่เกินไปจะเสี่ยง OOM ทั้งที่ Driver และ Executor และถ้า Broadcast ช้าเกิน spark.sql.broadcastTimeout (default 300 วินาที) งานก็จะล้ม</li></ul><h4>2. Sort Merge Join (SMJ)</h4><blockquote>SortMergeJoin</blockquote><p>ตัวนี้คือ “ม้างาน” ของการ join ข้อมูลใหญ่ชนข้อมูลใหญ่ และเป็น default ของ equi join เมื่อ Broadcast ไม่ได้ โดยทำงานเป็นสามขั้นตอน</p><ol><li>Shuffle: แบ่งทั้งสองฝั่งด้วย Hash ของ join key เพื่อให้ key เดียวกันไปอยู่ Partition เลขเดียวกัน</li><li>Sort: เรียงข้อมูลในแต่ละ Partition ตาม key</li><li>Merge: ไล่อ่านสองฝั่งที่เรียงแล้วไปพร้อมกันด้วย “ตัวชี้” สองตัว ถ้า key ตรงกันก็จับคู่ ถ้าไม่ตรงก็ขยับฝั่งที่ key น้อยกว่า</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jIopeTc2tUFrSVYU" /></figure><p>จุดแข็งคือ การ Sort สามารถ spill ลงดิสก์ได้ จึงไม่ต้องเก็บทั้ง Partition ไว้ใน memory ทำให้ทนต่อข้อมูลขนาดใหญ่มากๆ ได้ดี และรองรับทุก Join Type ส่วนจุดอ่อนคือต้อง Shuffle และ Sort ทั้งสองฝั่ง แพงทั้งเครือข่ายและ CPU</p><p>ค่า spark.sql.join.preferSortMergeJoin เป็น true โดย default ครับ</p><h4>3. Shuffled Hash Join (SHJ)</h4><blockquote>ShuffledHashJoin</blockquote><p>ขั้นตอนแรกเหมือน SMJ คือ Shuffle ทั้งสองฝั่งด้วย Hash ของ key แต่ต่างกันตรงที่<br>ไม่ Sort แล้ว<br>ในแต่ละ Partition จะเอาฝั่งที่เล็กกว่าไปสร้างเป็น Hash Table แล้วให้ฝั่งที่ใหญ่กว่าวิ่งมาค้น (Build แล้ว Probe) จึงเสียเวลาน้อยกว่า SMJ ตรงที่ไม่ต้อง Sort</p><ul><li><strong>Build:</strong> เอาแถวของฝั่งที่เล็กกว่ามาผ่าน Hash Function แล้วสร้างเป็น Hash Table เก็บไว้ใน memory</li><li><strong>Probe:</strong> เอาแถวของฝั่งที่ใหญ่กว่ามาค้นทีละแถว โดย Hash key ด้วยวิธีเดียวกันแล้วเปิดดูช่องที่ตรงกันใน Hash Table ถ้าเจอก็จับคู่ออกเป็นผลลัพธ์ทันที</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5pyHbE04s1J-kl2C" /></figure><p>แต่ข้อแลกเปลี่ยนคือ Hash Table ของแต่ละ Partition ต้องอยู่ใน memory ได้ทั้งหมด ถ้า Partition ไหนบวมเกินก็เสี่ยง OOM ในขณะที่ SMJ ยัง spill ลงดิสก์ได้ Spark จึงไม่ค่อยเลือกตัวนี้ให้เองครับ ต้องปิด preferSortMergeJoin หรือใช้ Hint SHUFFLE_HASH และฝั่งเล็กต้องเล็กพอ (และเล็กกว่าอีกฝั่งมากพอ) ด้วย ส่วนเรื่อง Join Type นั้น Spark รุ่นใหม่ๆ รองรับกว้างขึ้นแล้ว รวมถึง Full Outer</p><h4>4. Broadcast Nested Loop Join (BNLJ)</h4><blockquote>BroadcastNestedLoopJoin</blockquote><p>เมื่อเงื่อนไข join ไม่ใช่รูปแบบการเท่ากัน (non-equi join) เช่น a.price &gt; b.min_price หรือ BETWEEN ตามช่วงเวลา จะทำให้ไม่มี key ให้เอาไป Hash หรือ Sort ได้ ทำให้ตัวตระกูล Hash Join และ Sort Merge Join จึงใช้ไม่ได้ทั้งหมด และโดยเฉพาะถ้าเกิดว่าฝั่งหนึ่งเล็กพอจะ Broadcast ได้ (หรือเป็น Outer Join ที่ไม่มี equi key ซึ่งบังคับให้ต้องใช้ท่านี้แม้ข้อมูลอาจจะใหญ่ก็ตาม) Spark จะส่งฝั่งหนึ่งไปที่ทุก Executor แล้ววนลูปเทียบเงื่อนไขกับ “ทุกคู่”</p><h4>5. Cartesian Product Join</h4><blockquote>CartesianProduct</blockquote><p>ถ้าไม่มี equi key และ Broadcast ก็ไม่ได้ (Inner Join เท่านั้น) ก็เหลือทางเดียวคือจับทุกแถวฝั่งซ้ายคูณทุกแถวฝั่งขวา ข้อมูลฝั่งละล้านแถวก็คือหนึ่งล้านล้านคู่ นี่คือสิ่งที่ควรหลีกเลี่ยงที่สุดในบรรดาทั้งหมดครับ ถ้าต้องการ Cross Join จริงๆ ให้เขียน crossJoin() ให้ชัดเจนเพื่อแสดงเจตนา อย่าปล่อยให้มันเกิดขึ้นโดยบังเอิญจากการลืมใส่เงื่อนไข</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*f5EMecUlFtGwQvCa" /></figure><h3>ความเหมือนที่แตกต่าง: BHJ vs SMJ vs SHJ</h3><p>สามตัวแรกคือกลุ่มที่ใช้กับ equi join ซึ่งเจอบ่อยที่สุด ลองเทียบกันตรงๆ ดูครับ</p><blockquote>ทวนอีกที<br>BHJ — Broadcast Hash Join<br>SMJ — Sort Merge Join<br>SHJ — Shuffled Hash Join</blockquote><ul><li>เรื่อง Shuffle: BHJ จะไม่ Shuffle ฝั่งใหญ่เลย ส่วน SMJ กับ SHJ ต้อง Shuffle ทั้งสองฝั่ง</li><li>เรื่อง Sort: มีเฉพาะ SMJ ที่ต้อง Sort ข้อมูลทั้งสองฝั่ง</li><li>เรื่อง memory:<br>– BHJ ต้องแบกฝั่งเล็กทั้งก้อนไว้ในทุก Executor (และต้องผ่าน Driver ก่อน)<br>– SHJ ต้องเก็บ Hash Table ของแต่ละ Partition<br>– SMJ มีความทนที่สุดเพราะ spill ลงดิสก์ได้</li><li>เรื่อง Join Type: BHJ Broadcast ได้เฉพาะฝั่งที่ไม่ต้องเก็บแถวไว้ครบ เช่น Left Outer Broadcast ได้แค่ฝั่งขวา, Right Outer Broadcast ได้แค่ฝั่งซ้าย ส่วน Full Outer Broadcast ไม่ได้เลย เพราะ Executor แต่ละตัวเห็นฝั่งใหญ่แค่บางส่วน จึงบอกไม่ได้ว่าแถวที่ต้องเก็บไว้ครบนั้น “ไม่มีคู่จริงๆ” หรือแค่คู่ไปอยู่ที่ Executor ตัวอื่น ในขณะที่ SMJ Shuffle ทั้งสองฝั่งด้วย key ทำให้แถวที่ key เดียวกันมาอยู่ Partition เดียวกันเสมอ จึงตัดสินได้เองและใช้ได้ครบทุกแบบ</li><li>เรื่องขนาดข้อมูลที่เหมาะ: BHJ เหมาะเมื่อมีฝั่งเล็ก SMJ เหมาะเมื่อใหญ่ชนใหญ่ SHJ เหมาะเมื่อมีฝั่งที่เล็กกว่ามากแต่ใหญ่เกินจะ Broadcast</li></ul><h3>Spark เลือก Strategy ให้เรายังไง</h3><p>สำหรับ equi join Spark จะไล่ดูตัวเลือกโดยประมาณตามลำดับนี้ครับ Broadcast Hash Join ก่อน ถ้าไม่ได้ก็ Sort Merge Join แล้วค่อย Shuffled Hash Join ส่วนกรณีไม่มี equi key ก็จะไปที่ Broadcast Nested Loop Join หรือ Cartesian Product</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*37pVYwWUoERdmRBy" /></figure><p>ถ้าเรารู้ข้อมูลดีกว่า Spark ก็สามารถบอกใบ้ผ่าน Hint ได้ มีให้ใช้สี่แบบคือ BROADCAST, MERGE, SHUFFLE_HASH และ SHUFFLE_REPLICATE_NL</p><pre>from pyspark.sql.functions import broadcast<br>orders.join(broadcast(customers), &quot;customer_id&quot;)                # Broadcast Hash Join<br>orders.join(customers.hint(&quot;merge&quot;), &quot;customer_id&quot;)             # Sort Merge Join<br>orders.join(customers.hint(&quot;shuffle_hash&quot;), &quot;customer_id&quot;)      # Shuffled Hash </pre><pre>SELECT /*+ BROADCAST(c) */ *<br>FROM orders o<br>JOIN customers c ON o.customer_id = c.customer_id</pre><p>ถ้ามี Hint ขัดกันสองฝั่ง Spark จะให้ความสำคัญตามลำดับ BROADCAST ก่อน MERGE ก่อน SHUFFLE_HASH ก่อน SHUFFLE_REPLICATE_NL</p><p>แต่ช้าก่อน! Hint คือ “คำขอ” ไม่ใช่ “คำสั่ง” ครับ ถ้า Strategy ที่ขอไม่รองรับ Join Type นั้น Spark ก็จะเมินแล้วเลือกตัวอื่นแทน เช่น สั่ง Broadcast ใส่ Full Outer Join ก็จะได้ Sort Merge Join กลับมาอยู่ดี</p><p>พออ่านได้แล้วว่าทางเลือกมีอะไรบ้าง เวลาเจอสถานการณ์จริงก็ลองคิดแบบนี้</p><ul><li>ตารางเล็กอย่าง Dimension join กับตารางใหญ่อย่าง Fact: เล็งไปที่ Broadcast ก่อนเลย</li><li>ใหญ่ชนใหญ่ด้วย equi key: ปล่อย Sort Merge Join เป็น default ไปครับ แล้วไปโฟกัสที่ปัญหา Skew แทน</li><li>ไม่มี equi key: ลองกลับไปคิดว่าแปลงให้มี equi key ได้ไหม เช่น แบ่งช่วงเวลาเป็น bucket แล้ว join ด้วย bucket ก่อนค่อยกรองเงื่อนไขละเอียดทีหลัง</li><li>ต้องการแค่ “มีหรือไม่มี”: ใช้ Semi หรือ Anti แทนการ Inner แล้ว Distinct ซึ่งทั้งสั้นกว่าและ Spark ทำงานให้ได้ตรงจุดกว่า</li></ul><h3>Data Skew: ศัตรูตัวฉกาจของ Join</h3><p>ต่อให้เลือก Strategy ถูกแล้ว ก็ยังมีปัญหาหนึ่งที่ทำให้ job ช้าได้อีก นั่นคือ Data Skew ครับ</p><p>เนื่องจาก Shuffle แบ่งข้อมูลด้วย Hash ของ key ดังนั้น key เดียวกันจะตกไปอยู่ Partition เดียวกันเสมอ ถ้า key ใด key หนึ่งมีแถวเยอะผิดปกติ Partition นั้นก็จะบวมตามไปด้วย Task ที่ดูแล Partition นั้นก็จะทำงานนานกว่าตัวอื่นๆ มาก ในขณะที่ตัวอื่นเสร็จไปหมดแล้วและต้องนั่งรอ ทั้ง Stage จึงช้าเท่ากับ Task ที่ช้าที่สุด และบางครั้งก็ล้มด้วย OOM เลย</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oPwszWgfFfjriRZy" /></figure><p>ต้นตอที่เจอบ่อยคือ</p><ul><li>ค่า NULL จำนวนมาก</li><li>ค่า default อย่าง -1, 0 หรือ “unknown” ที่ถูกใส่แทนข้อมูลที่ขาดหายไป</li><li>เจ้าของ key ที่ใหญ่ผิดธรรมดา เช่น ลูกค้ารายใหญ่ หรือ Entity ที่ได้รับความนิยมสูงมาก</li></ul><p>วิธีรับมือมีหลายระดับ เรียงจากง่ายไปยาก</p><ol><li>ปล่อยให้ AQE จัดการ (เอาไว้เดี๋ยวเล่าในหัวข้อถัดไป)</li><li>ถ้าอีกฝั่งเล็กพอ ก็ Broadcast ไปเลย จะได้ไม่ต้อง Shuffle ทำให้ Skew ไม่มีผล</li><li>กรอง NULL key ทิ้งก่อน ถ้า Join Type ที่ใช้อยู่ไม่มีทางจับคู่กับ NULL อยู่แล้ว (เช่น Inner Join) ลดข้อมูลที่จะถูก Shuffle ไปได้ทันที</li><li>แยกจัดการ Hot Key ต่างหาก เช่น Hot Key ไม่กี่ตัวให้ join แบบ Broadcast แล้ว key ที่เหลือก็ join ปกติ จากนั้นค่อย Union ผลลัพธ์รวมกัน</li><li>Salting คือการเติมเลขสุ่มต่อท้าย key ของฝั่งที่ Skew เพื่อกระจายแถวของ key เดียวกันไปหลาย Partition แล้ว replicate อีกฝั่งให้ครบทุกค่าของเลขสุ่มนั้น</li></ol><p>หน้าตาของ Salting ประมาณนี้ครับ (ตัวอย่างเพื่อประกอบความเข้าใจ)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*uh-LzFQ6DDvdCSu7" /></figure><pre>from pyspark.sql import functions as F<br>SALT = 8 # ฝั่งใหญ่ที่ Skew: สุ่มเลข salt ให้แต่ละแถว เพื่อกระจาย key เดียวกันไปหลาย Partition<br>big_salted = big.withColumn(&quot;salt&quot;, (F.rand() * SALT).cast(&quot;int&quot;)) # ฝั่งเล็ก: replicate ทุกแถวให้ครบทุกค่าของ salt<br>small_salted = small.withColumn(&quot;salt&quot;, F.explode(F.array(*[F.lit(i) for i in range(SALT)]))<br>)<br>result = big_salted.join(small_salted, [&quot;key&quot;, &quot;salt&quot;]).drop(&quot;salt&quot;)</pre><p>ข้อแลกเปลี่ยนก็คือฝั่งเล็กจะบวมขึ้นตาม SALT และโค้ดซับซ้อนขึ้น จึงควรเก็บไว้ใช้เมื่อวิธีอื่นไม่พอเท่านั้นครับ</p><h3>AQE: ให้ Spark ปรับแผนตอนรัน</h3><blockquote>Adaptive Query Execution (AQE)</blockquote><p>ปกติ Spark วางแผนก่อนรันโดยอาศัยการประเมินขนาดข้อมูล ซึ่งถ้าประเมินพลาดแผนก็พลาดตาม AQE จึงเข้ามาแก้ตรงนี้ โดยใช้สถิติจริงที่ได้หลังแต่ละ Shuffle Stage จบ แล้วปรับแผนส่วนที่เหลือใหม่ระหว่างทาง เปิดใช้งานเป็น default มาตั้งแต่ Spark 3.2 แล้ว และมีสามความสามารถหลักที่เกี่ยวกับ join ครับ</p><ul><li>Coalesce Shuffle Partitions: รวม Partition เล็กๆ หลังการ Shuffle ให้มีขนาดพอเหมาะ (ขนาดเป้าหมายคือ spark.sql.adaptive.advisoryPartitionSizeInBytes default 64 MB) ช่วยแก้เรื่อง spark.sql.shuffle.partitions ที่ default ไว้ 200 ซึ่งมักไม่พอดีกับข้อมูลจริง</li><li>แปลง Sort Merge Join เป็น Broadcast Hash Join: ถ้าตอนรันจริงพบว่าฝั่งหนึ่งเล็กกว่าที่ประเมินไว้ (เช่น หลังผ่าน Filter ไปแล้ว) AQE จะสลับไปใช้ BHJ ให้เอง ประหยัดการ Sort ทั้งสองฝั่ง นอกจากนี้ยังสามารถแปลงเป็น Shuffled Hash Join ได้เมื่อทุก Partition หลัง Shuffle มีขนาดเล็กพอ</li><li>Skew Join Optimization: ตรวจจับ Partition ที่ใหญ่ผิดปกติแล้วแตกออกเป็นชิ้นย่อยๆ (และ replicate ข้อมูลฝั่งตรงข้ามถ้าจำเป็น) โดย Partition จะถูกมองว่า Skew เมื่อใหญ่กว่าค่ามัธยฐานคูณ skewedPartitionFactor (default 5) และใหญ่กว่า skewedPartitionThresholdInBytes (default 256 MB) ทั้งสองเงื่อนไข และมีข้อจำกัดว่าบาง Join Type ก็ช่วยได้ฝั่งเดียว เช่น Left Outer จะเพิ่มประสิทธิภาพได้เฉพาะ Skew ฝั่งซ้าย</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WbmoB5Nxw-G6Q4W-" /></figure><pre>spark.conf.set(&quot;spark.sql.adaptive.enabled&quot;, &quot;true&quot;)            # เปิดอยู่แล้วโดย default<br>spark.conf.set(&quot;spark.sql.adaptive.skewJoin.enabled&quot;, &quot;true&quot;)   # เปิดอยู่แล้วโดย default</pre><p>ถ้าอยากดูว่า AQE ทำอะไรไปบ้าง ให้ลองเรียก .explain() ดูครับ จะเห็น Node ชื่อ AdaptiveSparkPlan พร้อมแฟลก isFinalPlan ที่เป็น false ก่อนรัน และกลายเป็น true หลังรันเสร็จ</p><p>อย่างไรก็ดี เอกสารของ Spark เองก็บอกไว้ว่า การที่ AQE สลับมาเป็น Broadcast ตอนรันนั้นไม่ได้มีประสิทธิภาพเท่ากับการวางแผน Broadcast ตั้งแต่แรก (เพราะ Shuffle ฝั่งใหญ่ไปแล้วส่วนหนึ่ง) ดังนั้นถ้าเรารู้แน่ว่าฝั่งไหนเล็ก การใส่ Hint ก็ยังมีประโยชน์อยู่ครับ</p><h3>ลดต้นทุนก่อนจะ Join</h3><p>ก่อนไปปรับจูนที่ Strategy ลองดูสิ่งที่ทำได้ตั้งแต่ก่อน join ซึ่งมักได้ผลมากกว่าด้วยซ้ำ</p><ul><li>Filter และ Select เฉพาะคอลัมน์ที่ต้องใช้ให้เร็วที่สุด ข้อมูลที่ต้อง Shuffle ลดลงโดยตรงเลย</li><li>Aggregate ล่วงหน้า ถ้าอีกฝั่งมีหลายแถวต่อ key แต่เราต้องการแค่ค่าสรุป ให้ GROUP BY ให้เสร็จก่อนค่อย join</li><li>ให้ชนิดข้อมูลของ join key สองฝั่งตรงกัน จะได้ไม่เกิดการ Cast โดยไม่ตั้งใจ</li><li>ใช้ Bucketing (เสริมด้านล่าง) กับตารางใหญ่ที่ join กันบ่อยๆ ด้วย key เดียวกัน เมื่อสองตารางถูกแบ่ง Bucket ด้วย key และจำนวน Bucket ที่สอดคล้องกัน Spark อ่านไฟล์ Bucket ที่คู่กันมา join ได้เลยโดยข้ามการ Shuffle แต่ต้องวางแผนตั้งแต่ตอนเขียนข้อมูล</li><li>ปรับ spark.sql.shuffle.partitions ให้เหมาะกับขนาดข้อมูล หรือเปิดให้ AQE ช่วย Coalesce</li><li>อ่าน Query Plan ด้วย .explain() ก่อนเสมอ เพราะมันบอกชัดๆ ว่า Spark เลือกอะไรไปแล้ว</li></ul><p>อีกมุมหนึ่งที่ฝั่ง Orchestrator ควรตระหนักคือ ถ้า pipeline ถูกสั่งงานโดย Airflow แล้ว job ไหนช้าเพราะ Skew หรือเลือก Strategy ผิด มันก็ไม่ได้ลากแค่ตัวเอง แต่ลากทั้ง DAG ที่ต่อท้ายให้ช้าตามไปด้วยครับ</p><h4>เสริม Bucketing: จ่ายค่า Shuffle ล่วงหน้าตั้งแต่ตอนเขียนข้อมูล</h4><blockquote>Bucketing</blockquote><p>Bucket แปลตรงๆ คือ “ถัง” ครับ Bucketing คือการแบ่งข้อมูลของตารางออกเป็นถังตั้งแต่ตอนเขียนลงดิสก์ โดยเราเลือกคอลัมน์ที่ใช้แบ่ง (เช่น customer_id) กับจำนวนถัง (เช่น 8) จากนั้น Spark จะเอา key ของแต่ละแถวไปผ่าน Hash Function แล้วหารเอาเศษด้วยจำนวนถัง เพื่อดูว่าแถวนี้ต้องตกถังไหน แล้วเขียนลงไฟล์ของถังนั้น ผลคือแถวที่ key เดียวกันจะอยู่ถังเดียวกันเสมอ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*d0tEsQncgRY0hRSp" /></figure><p>ถ้ายังจำ Shuffle ที่แบ่ง Partition ด้วย Hash ของ key ได้ นี่คือหลักการเดียวกันเลยครับ ต่างกันตรงที่ Shuffle ทำตอนรันและต้องทำใหม่ทุกครั้งที่ join ส่วน Bucketing ทำครั้งเดียวตอนเขียน เหมือนจ่ายราคาของ Shuffle ล่วงหน้าไปก่อน แล้ว join รอบหลังๆ ก็ไม่ต้องจ่ายอีก</p><pre>orders.write.bucketBy(8, &quot;customer_id&quot;).sortBy(&quot;customer_id&quot;).saveAsTable(&quot;orders_b&quot;)<br>customers.write.bucketBy(8, &quot;customer_id&quot;).sortBy(&quot;customer_id&quot;).saveAsTable(&quot;customers_b&quot;)<br>spark.table(&quot;orders_b&quot;).join(spark.table(&quot;customers_b&quot;), &quot;customer_id&quot;)</pre><p>สังเกตว่าต้องเขียนด้วย saveAsTable เพราะ Spark ต้องจำข้อมูล Bucket ของตารางไว้ใน Catalog ครับ</p><p>เมื่อสองตารางถูก Bucket ด้วย key เดียวกันและจำนวนถังเท่ากัน Spark รู้ทันทีว่าถังที่ 3 ของ orders จะมี key ชุดเดียวกับถังที่ 3 ของ customers เท่านั้น จึงอ่านถังที่คู่กันมา join กันได้เลย พอเรียก .explain() ก็จะไม่เห็น Exchange อีกต่อไป (ขั้น Sort อาจยังเหลืออยู่ โดยเฉพาะเมื่อแต่ละถังถูกเขียนเป็นหลายไฟล์ แต่ Exchange คือส่วนที่แพงที่สุดครับ)</p><p>ข้อควรรู้ก่อนใช้</p><ul><li>ต้อง join ด้วยคอลัมน์ที่ใช้ Bucket เท่านั้น</li><li>จำนวนถังควรเท่ากัน ถ้าไม่เท่ากัน Spark จะ Shuffle อีกฝั่งอยู่ดี (ถังใหญ่หารด้วยถังเล็กลงตัวและเปิด spark.sql.bucketing.coalesceBucketsInJoin.enabled ก็ยังข้าม Shuffle ได้ แต่ค่า default ปิดอยู่)</li><li>ถ้าอีกฝั่งไม่ได้ Bucket Spark จะ Shuffle แค่ฝั่งนั้น ฝั่งที่ Bucket ไว้ไม่ต้องขยับ</li><li>ต้องวางแผนล่วงหน้า ถ้าอยากเปลี่ยน key หรือจำนวนถังทีหลัง ต้องเขียนข้อมูลใหม่ทั้งตาราง</li><li>ไฟล์เล็กๆ จะเยอะขึ้น เพราะแต่ละ Task ที่เขียนอาจสร้างไฟล์ได้ถึงจำนวนถัง เช่น 2 Task กับ 8 ถังได้ถึง 16 ไฟล์ แทนที่จะเป็น 2 ไฟล์</li><li>Data Skew ไม่ได้หายไป key ที่ร้อนก็ยังตกถังเดียวกันอยู่ดี</li></ul><p>ดังนั้น Bucketing เหมาะกับตารางใหญ่ที่ถูก join ด้วย key เดิมซ้ำๆ เพราะจ่ายครั้งเดียวแล้วคุ้มหลายรอบ แต่ถ้า join ครั้งเดียวจบ ไม่ค่อยคุ้มครับ</p><h3>ทั้งหมดจึงขอสรุปประมาณนี้ว่า</h3><p>Join Type คือสิ่งที่เราต้องการ ส่วน Join Strategy คือวิธีที่ Spark ใช้ทำให้ได้สิ่งนั้น<br>สองอย่างนี้แยกกันคิดได้</p><p>ถ้าทำงานกับตารางเล็กอย่าง Dimension ที่ต้อง join กับตารางใหญ่อย่าง Fact <strong>Broadcast Hash Join คือตัวเลือกแรกที่ควรนึกถึง</strong><br>แต่ถ้าเป็นการ join ใหญ่ชนใหญ่ Sort Merge Join ที่เป็น default ก็ถูกต้องแล้วครับ<br>สิ่งที่ควรเฝ้าระวังกว่าการเปลี่ยน Strategy คือ Data Skew และถ้าแค่ต้องการเช็คว่า<br>“มีหรือไม่มี” อย่าลืมว่า Semi กับ Anti Join นั้นตรงจุดกว่าการ Inner Join แล้วค่อย Distinct ครับ</p><p>ส่วนเรื่อง Hint ผมมองว่า <strong>ไม่ค่อยแนะนำให้ใส่ในทุก query</strong> ถ้ายังไม่ได้ดู Query Plan และยังไม่รู้ขนาดข้อมูลจริง เพราะ Hint ที่ผิดจังหวะ (เช่น Broadcast ฝั่งที่โตขึ้นเรื่อยๆ ตามเวลา) วันนี้ที่ข้อมูลยังน้อยอาจเร็วดี แต่สักวันมันจะกลายเป็นระเบิดเวลา OOM ได้ ในยุคที่ AQE เปิดอยู่เป็น default ปล่อยให้ Spark ตัดสินใจก่อน แล้วใช้ Hint เฉพาะจุดที่เรามั่นใจจริงๆ จะปลอดภัยกว่ามาก และสุดท้าย <strong>Cartesian Product คือสิ่งที่ต้องระวังที่สุด</strong> ถ้าเห็นมันโผล่ใน Plan โดยที่เราไม่ได้ตั้งใจ ให้กลับไปตรวจเงื่อนไข join ทันทีเลยครับ</p><p>เอาละ ประมาณนี้ก่อน ใครที่เพิ่งเริ่มสาย Data Engineering ลองเริ่มจากนิสัยง่ายๆ ที่สุดอย่างการเรียก .explain() ดู Plan ทุกครั้งที่เขียน join ใหม่ ก็จะเห็นภาพชัดขึ้นเยอะเลยครับ</p><p>เอาไว้คราวหน้าค่อยเจาะลึกกันไปทีละอันกันดีกว่า แบบจับมือทำไปเลย🫡</p><p>ref:<br><a href="https://www.youtube.com/watch?v=g23GHqJje40">https://www.youtube.com/watch?v=g23GHqJje40</a><br><a href="https://spark.apache.org/docs/latest/sql-ref-syntax-qry-select-join">https://spark.apache.org/docs/latest/sql-ref-syntax-qry-select-join</a><br><a href="https://apache.googlesource.com/spark/+/master/docs/sql-performance-tuning.md">https://apache.googlesource.com/spark/+/master/docs/sql-performance-tuning.md</a><br><a href="https://docs.databricks.com/optimizations/aqe.html">https://docs.databricks.com/optimizations/aqe.html</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e124c63fc305" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[5 Common Spark Mistakes: How to Spot Them and Fix Them]]></title>
            <link>https://medium.com/@puk.kriangsak/5-common-spark-mistakes-how-to-spot-them-and-fix-them-fd18464b5a6b?source=rss-c50d774af4fc------2</link>
            <guid isPermaLink="false">https://medium.com/p/fd18464b5a6b</guid>
            <category><![CDATA[apache-spark]]></category>
            <category><![CDATA[data-engineering]]></category>
            <dc:creator><![CDATA[Kriangsak Sumthong]]></dc:creator>
            <pubDate>Sun, 25 Oct 2026 17:09:15 GMT</pubDate>
            <atom:updated>2026-10-25T17:09:15.072Z</atom:updated>
            <content:encoded><![CDATA[<p>5 ข้อผิดพลาด Spark ที่พบบ่อย</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wdMYdjLer16OJY9_" /></figure><p>เคยไหมครับที่ Spark job รันผ่านแล้วแต่ช้าจนต้องนั่งรอเป็นชั่วโมง หรือไม่ก็ขึ้น OutOfMemory กลางทางแบบไม่มีสาเหตุที่ชัดเจน</p><p>เรื่องนี้ผมว่าเกือบทุกคนที่ทำ Data Engineering ด้วย Spark น่าจะเคยเจอ ซึ่งส่วนใหญ่ปัญหาไม่ได้อยู่ที่ขนาดของ Cluster แต่อยู่ที่วิธีที่เราเขียนโค้ดเอง และสิ่งที่ช่วยให้เห็นปัญหาได้เร็วที่สุดก็คือ DAG ใน Spark UI นี่แหละครับ</p><p>บทความนี้เลยจะลองรวม 5 ความผิดพลาดที่ Data Engineer มักเจอบ่อยกับ Spark</p><h3>ก่อนจะเริ่ม อ่าน DAG ยังไงให้ไม่งง</h3><p>ใน Spark UI เราจะดู DAG ได้สองที่หลักๆ ครับ</p><ul><li><strong>แท็บ SQL / DataFrame</strong> จะเห็น Query plan เป็นกล่องๆ ต่อกัน มี Exchange (คือ Shuffle) คั่นอยู่ระหว่างกล่อง ดูภาพรวมได้ง่ายที่สุด</li><li><strong>แท็บ Stages</strong> กดเข้าไปในแต่ละ Stage จะเห็น DAG Visualization ระดับ Stage ซึ่งเอาไว้ดูว่ามี Task อะไรบ้าง และมี Metrics ของแต่ละ Task</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/620/0*Hdgaj7VIQcNHWNff" /></figure><p>จำง่ายๆ ว่า <strong>ทุกครั้งที่เห็น Exchange ก็คือมี Shuffle เกิดขึ้น</strong> และ Shuffle ถือเป็น Operation ที่กิน Resource และเสียเวลามากที่สุดตัวหนึ่งใน Spark เลยครับ เพราะต้องเขียน Disk, ส่งผ่าน Network แล้วอ่านกลับมาใหม่</p><h3>ข้อที่ 1: Cache ทุกอย่างที่เห็น</h3><h4>เกิดอะไรขึ้น</h4><p>พอได้ยินว่า cache ช่วยให้เร็วขึ้น หลายคนก็เลยใส่ .cache() หรือ .persist() ให้ทุก DataFrame ที่ผ่านมือ ผลคือ Memory ของ Executor เต็มไปด้วยข้อมูลที่ใช้แค่ครั้งเดียว ข้อมูลที่ควร Cache จริงๆ กลับโดนเตะออก (Eviction) หรือล้นไป Disk ซึ่งช้ากว่าคำนวณใหม่เสียอีก # ใช้ครั้งเดียว ไม่ต้อง cache</p><pre>df_raw = spark.read.parquet(&quot;s3://bucket/raw/&quot;)<br>df_raw.cache()py<br>df_clean = df_raw.filter(&quot;status = &#39;ok&#39;&quot;).cache()   # cache อีกแล้ว<br>df_final = df_clean.groupBy(&quot;user_id&quot;).count().cache()  # และอีก<br>df_final.write.parquet(&quot;s3://bucket/out/&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wlKIMPa-pPW87H3P" /></figure><h4>วิธีสังเกต</h4><ul><li>แท็บ <strong>Storage</strong> มี RDD/DataFrame ที่ถูก Cache เต็มไปหมด และแต่ละตัวมี <strong>Fraction Cached ไม่ถึง 100%</strong> หรือมีขนาดใน Disk เยอะ</li><li>ใน DAG เห็นกล่อง InMemoryTableScan ในจุดที่ข้อมูลถูกอ่านแค่ครั้งเดียว</li><li>แท็บ <strong>Executors</strong> เห็น Storage Memory ใกล้เต็ม และ GC Time สูงขึ้นผิดปกติ</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Hp7qhTpYZN8ugsym" /></figure><h4>วิธีแก้</h4><p>หลักง่ายๆ ครับ <strong>Cache เฉพาะข้อมูลที่ถูกใช้ซ้ำมากกว่าหนึ่ง Action</strong> ถ้าใช้ครั้งเดียวไม่ต้อง Cache และเมื่อใช้เสร็จแล้วอย่าลืม unpersist() ด้วย</p><pre>df_clean = df_raw.filter(&quot;status = &#39;ok&#39;&quot;)<br>df_clean.cache()                    # ใช้ซ้ำสองรอบด้านล่าง เลย cache<br><br>daily = df_clean.groupBy(&quot;dt&quot;).count()<br>by_user = df_clean.groupBy(&quot;user_id&quot;).count()<br><br>daily.write.parquet(&quot;s3://bucket/out/daily/&quot;)<br>by_user.write.parquet(&quot;s3://bucket/out/by_user/&quot;)<br><br>df_clean.unpersist()</pre><p>ถ้าข้อมูลใหญ่กว่า Memory จริงๆ ให้ใช้ persist(StorageLevel.MEMORY_AND_DISK) แทน หรือเขียนผลลัพธ์กลางทางลง Parquet แล้วอ่านกลับมา ซึ่งบางทีก็เร็วและเสถียรกว่า Cache อีกครับ</p><h3>ข้อที่ 2: จำนวน Partition ไม่เหมาะกับข้อมูล</h3><h4>เกิดอะไรขึ้น</h4><p>ค่า Default ของ spark.sql.shuffle.partitions คือ 200 ซึ่งเป็นเลขที่ไม่ได้เหมาะกับข้อมูลของใครเลยครับ ถ้าข้อมูลเล็กก็จะได้ Task จิ๋วๆ 200 ตัวที่เสียเวลา Schedule มากกว่าทำงานจริง แต่ถ้าข้อมูลใหญ่ก็จะได้ Partition ใหญ่เกินไปจน Spill ลง Disk หรือ OOM</p><blockquote><em>ถึงแม้ Spark ยุคหลังจะมี AQE ช่วยปรับขนาดให้อัตโนมัติ แต่ถ้าเข้าใจพื้นฐานตรงนี้ไว้ เวลาเจองานหนักๆ ก็จะจูนได้ตรงจุด</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Rq9Y3agDPr5NmRqI" /></figure><h3>วิธีสังเกต</h3><p>เข้าไปที่หน้า Stage Detail แล้วดู <strong>Summary Metrics for Tasks</strong> ครับ</p><ul><li><strong>Partition เล็กเกินไป:</strong> Duration ต่อ Task ไม่กี่ ms, Shuffle Read ต่อ Task เป็นหลัก KB, ใน Stage มี Task เป็นร้อยเป็นพัน แต่เวลารวมส่วนใหญ่หมดไปกับ Scheduler Delay</li><li><strong>Partition ใหญ่เกินไป:</strong> มีคอลัมน์ <strong>Spill (Memory) / Spill (Disk)</strong> โผล่ขึ้นมา, Task ใช้เวลานานทุกตัว, หรือโดน Executor Lost จาก OOM</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*T3OKngO7xegIX6FB" /></figure><h4>วิธีแก้</h4><pre># ปรับให้เหมาะกับข้อมูลของงานนี้<br>spark.conf.set(&quot;spark.sql.shuffle.partitions&quot;, &quot;800&quot;)<br># หรือถ้าใช้ Spark 3.2 ขึ้นไป ให้ AQE ช่วยรวม Partition เล็กๆ ให้เอง<br>spark.conf.set(&quot;spark.sql.adaptive.enabled&quot;, &quot;true&quot;)<br>spark.conf.set(&quot;spark.sql.adaptive.coalescePartitions.enabled&quot;, &quot;true&quot;)</pre><p>ตอนเขียนไฟล์ก็ระวังเรื่องนี้เหมือนกันครับ ถ้า repartition(1) เพื่อให้ได้ไฟล์เดียว ทุกอย่างจะไหลเข้า Task เดียวและช้ามาก ถ้าแค่อยากลดจำนวนไฟล์ใช้ coalesce(n) จะไม่เกิด Shuffle เพิ่ม</p><h3>ข้อที่ 3: Join แล้วข้อมูลเอียง (Skewed Join)</h3><h4>เกิดอะไรขึ้น</h4><p>ข้อมูลจริงมักไม่กระจายเท่ากันครับ เช่นมี user_id = NULL หรือ country = &#39;TH&#39; เป็น 60% ของทั้งตาราง พอ Join ด้วย Key นั้น Spark จะส่งทุกแถวที่ Key เดียวกันไปที่ Task เดียว ทำให้ Task นั้นหนักกว่าตัวอื่นเป็นสิบเท่า ส่วน Task ที่เหลือก็นั่งรอเฉยๆ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Oquyk5QBCyEAXc8B" /></figure><h4>วิธีสังเกต</h4><ul><li>ในหน้า Stage Detail ดู <strong>Summary Metrics</strong> ถ้า <strong>Max ของ Duration หรือ Shuffle Read Size ห่างจาก Median หลายเท่า</strong> นั่นคืออาการคลาสสิกของ Skew</li><li>Progress Bar ของ Stage ค้างที่ 198/200 อยู่นานมาก</li><li>ในแท็บ <strong>Event Timeline</strong> จะเห็น Task ตัวเดียวยาวกว่าตัวอื่นแบบเห็นได้ชัด</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/0*ZLrAIOsDJtgtRNuI" /></figure><h4>วิธีแก้</h4><p>เรียงตามความง่ายนะครับ</p><ol><li><strong>เปิด AQE Skew Join</strong> (Spark 3.x) ให้ Spark แตก Partition ที่เอียงออกเป็นชิ้นเล็กๆ เอง</li><li><strong>Broadcast ตารางเล็ก</strong> ถ้าอีกฝั่งเล็กพอ จะไม่ต้อง Shuffle ตารางใหญ่เลย</li><li><strong>กรอง Key ที่เอียงออกมาจัดการแยก</strong> เช่น NULL มักไม่ต้อง Join อยู่แล้ว</li><li><strong>Salting</strong> เป็นทางสุดท้าย เติมเลขสุ่มต่อท้าย Key เพื่อกระจายข้อมูล</li></ol><pre># 1. AQE<br>spark.conf.set(&quot;spark.sql.adaptive.enabled&quot;, &quot;true&quot;)<br>spark.conf.set(&quot;spark.sql.adaptive.skewJoin.enabled&quot;, &quot;true&quot;)<br># 2. Broadcast<br>from pyspark.sql.functions import broadcast<br>result = big_df.join(broadcast(small_df), &quot;country&quot;)<br># 3. กรอง NULL ก่อน Join<br>result = big_df.filter(&quot;user_id IS NOT NULL&quot;).join(users, &quot;user_id&quot;)</pre><h3>ข้อที่ 4: Shuffle ที่ไม่จำเป็น</h3><h4>เกิดอะไรขึ้น</h4><p>หลายครั้งที่ Shuffle เกิดขึ้นทั้งๆ ที่ไม่ต้องมี เช่น repartition() ที่ใส่ไว้ตามความเคยชิน, groupBy แล้ว join ด้วย Key เดียวกันซ้ำๆ, distinct() หลายรอบ, หรือ Join ตารางเล็กด้วย Sort Merge Join แทนที่จะเป็น Broadcast</p><pre>df = (<br>    events<br>    .repartition(200)                       # shuffle ไม่จำเป็น<br>    .groupBy(&quot;user_id&quot;).agg(...)            # shuffle<br>    .join(users, &quot;user_id&quot;)                 # shuffle อีก ทั้งที่ users เล็กมาก<br>    .distinct()                             # shuffle อีกรอบ<br>)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xkQXG8PRi0CI1W_h" /></figure><h4>วิธีสังเกต</h4><ul><li>นับกล่อง <strong>Exchange</strong> ใน DAG ครับ ยิ่งเยอะยิ่งกิน Resource ลองถามตัวเองว่าแต่ละตัวมีเหตุผลไหม</li><li>แท็บ Stages ดูคอลัมน์ <strong>Shuffle Read / Shuffle Write</strong> ว่าสูงเกินกว่าขนาดข้อมูลจริงหรือเปล่า</li><li>ใช้ df.explain() ดู Physical plan แล้วหา Exchange hashpartitioning และ SortMergeJoin ที่ฝั่งหนึ่งเป็นตารางเล็ก</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*eH_43XYYFa2YilF3" /></figure><h4>วิธีแก้</h4><pre>df = (<br>    events<br>    .groupBy(&quot;user_id&quot;).agg(...)<br>    .join(broadcast(users), &quot;user_id&quot;)      # ตารางเล็ก ใช้ broadcast ไม่ต้อง shuffle<br>)<br># distinct ออกถ้า groupBy แล้วไม่มีแถวซ้ำอยู่แล้ว</pre><p>เทคนิคที่ใช้บ่อยคือ</p><ul><li>ลบ repartition() ที่ไม่ได้มีเหตุผลรองรับ</li><li>ใช้ coalesce() แทน repartition() เมื่อต้องการลดจำนวน Partition อย่างเดียว</li><li>ปรับ spark.sql.autoBroadcastJoinThreshold ให้เหมาะกับขนาดตารางเล็กของเรา</li><li>ถ้า Join ตารางใหญ่ด้วย Key เดิมซ้ำๆ ลองพิจารณา Bucketing หรือเขียน Partition ตาม Key นั้นตั้งแต่ตอนเก็บข้อมูล</li><li>จัดลำดับให้ filter และ select เอาเฉพาะคอลัมน์ที่ใช้มาก่อน Shuffle เพื่อให้ข้อมูลที่ถูกส่งผ่าน Network น้อยลง</li></ul><h3>ข้อที่ 5: Collect ข้อมูลก้อนใหญ่เข้า Driver</h3><h4>เกิดอะไรขึ้น</h4><p>collect(), toPandas() หรือ .rdd.collect() จะดึงข้อมูลทั้งหมดจากทุก Executor มารวมกันใน Driver ตัวเดียว ซึ่งปกติ Memory ของ Driver เล็กกว่า Executor รวมกันมาก ผลคือ Driver OOM หรือค้างไปเลยครับ และที่แย่คือโค้ดมักรันผ่านบน Dev ที่ข้อมูลน้อย แล้วไปพังบน Production</p><pre>rows = df.collect()                 # ดึงทั้งตารางมา Driver<br>for r in rows:<br>    process(r)<br>pdf = df.toPandas()                 # ก็เหมือนกัน</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*kGZ3-V5VT24FEq25" /></figure><h4>วิธีสังเกต</h4><ul><li>Error อย่าง java.lang.OutOfMemoryError: Java heap space ที่ Driver หรือ Total size of serialized results ... is bigger than spark.driver.maxResultSize</li><li>แท็บ <strong>Executors</strong> แถว driver ใช้ Memory เกือบเต็ม และ GC Time พุ่ง</li><li>ในแท็บ Jobs เห็น Job ที่ Stage สุดท้ายมี <strong>Result Serialization / Getting Result Time</strong> สูง</li><li>ค้นโค้ดหา collect(), toPandas(), .count() ใน Loop แล้วจะเจอตัวการเร็วมาก</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BP8jdOZdvy81DIRt" /></figure><h4>วิธีแก้</h4><p>หลักคือ <strong>ให้ข้อมูลอยู่บน Executor ให้นานที่สุด</strong> แล้วค่อยเอาเฉพาะผลลัพธ์ที่เล็กพอมาที่ Driver</p><pre># ดูตัวอย่าง<br>df.show(20)<br>sample = df.limit(1000).toPandas()<br># ทำ Aggregate บน Cluster ก่อน ค่อยดึงผลลัพธ์เล็กๆ มา<br>summary = df.groupBy(&quot;country&quot;).count().toPandas()<br># ต้องวนทีละแถวจริงๆ ใช้ iterator แทน collect<br>for row in df.toLocalIterator():<br>    process(row)<br># ผลลัพธ์ใหญ่ เขียนลง Storage ตรงๆ<br>df.write.mode(&quot;overwrite&quot;).parquet(&quot;s3://bucket/out/&quot;)</pre><p>ถ้าจะใช้ toPandas() จริงๆ เปิด Arrow ช่วยลดทั้งเวลาและ Memory ได้ด้วย spark.sql.execution.arrow.pyspark.enabled=true แต่ก็ยังควรจำกัดขนาดข้อมูลก่อนเสมอครับ</p><h3>สรุปส่งท้าย</h3><p>ทั้ง 5 ข้อนี้ถ้าสังเกตดีๆ จะเห็นว่าเรามองเห็นมันได้จาก Spark UI ทั้งหมดเลยครับ ไม่ต้องเดาให้เมื่อยตั้งแต่แรก เริ่มจากเปิดแท็บ SQL ดูว่ามี Exchange กี่ตัว แล้วเข้าไปดู Stage ที่ช้าที่สุดว่า Task กระจายตัวเท่ากันไหม มี Spill ไหม ส่วน Storage กับ Executors เอาไว้เช็คเรื่อง Cache และ Driver</p><p>ถ้าต้องเลือกลำดับความสำคัญ ลองไล่ตามนี้ดู</p><ul><li>ถ้างานช้าแบบ <strong>Task ตัวเดียวค้างอยู่นาน</strong> ให้สงสัยเรื่อง <strong>Skewed Join</strong> ก่อน</li><li>ถ้างานช้าแบบ <strong>Task เยอะมากแต่เสร็จไวทุกตัว</strong> หรือ <strong>Spill เยอะ</strong> ให้ไปดู <strong>Partition Count</strong></li><li>ถ้าเห็น <strong>Exchange เต็มไปหมด</strong> ให้ไล่เช็ค <strong>Shuffle ที่ไม่จำเป็น</strong> และลอง Broadcast</li><li>ถ้า <strong>Memory เต็มแต่ทำงานช้า</strong> ให้ลดการ <strong>Cache</strong> ลง</li><li>ถ้า <strong>Driver พัง</strong> ให้หา collect() / toPandas() ในโค้ดได้เลย</li></ul><p>และข้อที่ผม <strong>ไม่ค่อยจะแนะนำ</strong> เลยคือการแก้ปัญหาด้วยการเพิ่มขนาด Cluster อย่างเดียว เพราะส่วนใหญ่แค่ทำให้ค่าใช้จ่ายสูงขึ้นแต่ปัญหาเดิมยังอยู่ ลองเปิด DAG ดูก่อนสักรอบ น่าจะประหยัดได้มากกว่าที่คิดครับ</p><p>ref:<br><a href="https://spark.apache.org/docs/latest/web-ui.html">https://spark.apache.org/docs/latest/web-ui.html</a><br><a href="https://spark.apache.org/docs/latest/sql-performance-tuning.html">https://spark.apache.org/docs/latest/sql-performance-tuning.html</a><br><a href="https://spark.apache.org/docs/latest/rdd-programming-guide.html#rdd-persistence">https://spark.apache.org/docs/latest/rdd-programming-guide.html#rdd-persistence</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Mv0ESZMfQ8cWY-em" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fd18464b5a6b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LINE in the front, AWS Strands in the back: How to build AI agents that actually scale.]]></title>
            <link>https://medium.com/@puk.kriangsak/line-in-the-front-aws-strands-in-the-back-how-to-build-ai-agents-that-actually-scale-631f35051926?source=rss-c50d774af4fc------2</link>
            <guid isPermaLink="false">https://medium.com/p/631f35051926</guid>
            <category><![CDATA[clouddatalabor]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[strands-agents]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Kriangsak Sumthong]]></dc:creator>
            <pubDate>Tue, 15 Sep 2026 18:42:45 GMT</pubDate>
            <atom:updated>2026-09-15T18:42:45.304Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*QqNiV0QkiDsGJVU1" /></figure><p>อยากมี AI Agent ของตัวเองสักตัว ที่ตอบคำถามได้ ค้นข้อมูลปัจจุบันให้ได้ แล้วก็อยากให้คนคุยด้วยง่ายๆ ไม่ต้องไปโหลดแอปใหม่ ไม่ต้องสมัครอะไรเพิ่ม เพราะ LINE นั้นเป็น แอพยอดฮิตที่ในไทยที่ยังไงก็ได้เสมอ</p><p>ผมเลยลองทำโปรเจกต์เล็กๆตัวหนึ่งขึ้นมา เอา AI Agent ไปต่อกับ LINE ให้มันกลายเป็นเพื่อนแชทที่ตอบได้ทั้งเรื่องทั่วไปและเรื่องที่ต้องเช็คข้อมูลสดๆจากเว็บ เพื่อเป็นการส่งต่อความรู้และที่สำคัญคือเน้นเรื่องเอาขึ้น AWS แบบใช้งานจริงได้ยังไง แบบที่ใช้ใน Production เลย ไปกันต่อ!</p><h3>Strands คืออะไร ทำไมต้องเป็นตัวนี้</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/413/0*KO7vyH6fWDNWDhA-" /></figure><p>ก่อนจะไปถึง LINE ต้องมาทำความรู้จักตัวหลักกันก่อน นั่นก็คือ AWS Strands Agents SDK ครับ</p><blockquote><em>Strands Agents คือ open source SDK จาก AWS สำหรับสร้าง AI Agent ด้วยแนวคิดแบบ model-driven เขียนโค้ดไม่กี่บรรทัดก็ได้ Agent ที่เรียกใช้ Tool เองได้ทันที</em></blockquote><p>จุดที่ผมชอบของ Strands คือมันไม่ได้ผูกติดกับ Model ค่ายไหนค่ายหนึ่ง จะยิงไป Bedrock, Gemini, OpenAI หรือค่ายอื่นก็สลับได้ผ่าน Config ไม่ต้องเขียนโค้ด Agent ใหม่ทั้งหมด แล้วเรื่อง Tool ก็ง่ายมาก แค่เขียนฟังก์ชัน Python ธรรมดาแล้วแปะ @tool ไว้ด้านบน Agent ก็รู้จักเรียกใช้เองว่าเมื่อไหร่ควรเรียก เมื่อไหร่ไม่ต้องเรียก</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/0*Gh4n6rgmLypK7aMw" /></figure><p>ในโปรเจกต์นี้ผมให้ Agent มี Tool เดียวคือ web_search ที่ยิงไป DuckDuckGo ผ่านไลบรารี ddgs ข้อดีคือไม่ต้องขอ API Key เลยครับ เหมาะกับตอนที่อยากได้ Agent ที่ค้นเว็บได้แบบเริ่มต้นเร็วๆ ถ้าอยากได้ผลลัพธ์ที่แม่นขึ้นทีหลังก็มี strands_tools.tavily หรือ .exa เป็นตัวเลือกสลับได้เหมือนกัน</p><blockquote>ข้อเสียคือความแม่นยำในการ Search ต้อง validate ให้ดีนะครับ</blockquote><p>Agent ทั้งตัวถูกประกอบขึ้นจากฟังก์ชันเดียวใน agent/core.py ชื่อ build_agent() ประมาณนี้</p><pre>def build_agent() -&gt; Agent:<br>    return Agent(system_prompt=SYSTEM_PROMPT, tools=[web_search], model=_select_model())</pre><p>สั้นๆแค่นี้เลยครับ แล้วจุดที่สำคัญมากคือฟังก์ชันนี้ตัวเดียวถูกเรียกใช้ทั้งฝั่ง Local และฝั่งที่ Deploy ขึ้น AWS ไม่มีการเขียน Agent แยกสองชุด เพราะงั้นพฤติกรรมของ Agent จะไม่มีวันเพี้ยนกันระหว่างสองโหมดเลยครับ</p><h3>แล้วทำไมต้องเป็น LINE</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6g8NkNeq0vEfCyqi" /></figure><p>พอพูดถึง Chatbot คนไทยส่วนใหญ่คงนึกถึง LINE เป็นอันดับแรกใช่ไหมครับ ต่างจากประเทศอื่นที่อาจจะใช้ Telegram, WhatsApp หรือ Slack เป็นหลัก แต่บ้านเราแทบทุกคนมี LINE อยู่ในเครื่องอยู่แล้ว ถ้าอยากทำ Agent ที่คนไทยหยิบมาใช้ได้จริงโดยไม่ต้องอธิบายอะไรเพิ่ม การไปโผล่ใน LINE จึงเป็นทางเลือกที่เข้าท่าที่สุดสำหรับผมครับ</p><p>แต่ทีนี้ LINE Messaging API มีข้อจำกัดสำคัญอย่างหนึ่งที่ต้องรู้ไว้ก่อนออกแบบระบบ นั่นคือ LINE ให้ตั้งค่า Webhook URL ได้แค่ URL เดียวต่อหนึ่ง Channel และมันจะยิง JSON แบบ HTTPS POST มาตรงๆ ในขณะที่ Amazon Bedrock AgentCore Runtime ซึ่งเป็นที่ที่ผมจะเอา Agent ไปรันนั้น ไม่ได้เป็น Webhook Target แต่ต้องเรียกผ่าน invoke_agent_runtime ที่เซ็น SigV4 ด้วย boto3 เท่านั้น ซึ่ง LINE เรียกตรงๆแบบนี้ไม่ได้เลยครับ</p><p>เพราะงั้นสิ่งที่ต้องมีเพิ่มคือ Adapter ตัวเล็กๆที่ทำหน้าที่เป็นคนกลาง รับ Webhook จาก LINE ตรวจลายเซ็น แล้วค่อยไปเรียก Agent อีกที ไม่ว่า Agent จะรันอยู่ที่ไหนก็ตาม</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/0*S4p9ryyFeBQQMbMl" /></figure><h3>โครงสร้างโปรเจกต์แบบคร่าวๆ</h3><p>โปรเจกต์นี้แบ่งเป็นสองส่วนหลักที่ทำงานแยกกันชัดเจนครับ</p><ul><li>agent/ เก็บตัว Agent เอง มี core.py (สร้าง Agent), search_tool.py (Tool ค้นเว็บ) และ respond.py ซึ่งเป็นจุดต่อระหว่าง Agent กับ Backend สองแบบ คือ respond_local() กับ respond_agentcore()</li><li>adapter/ เก็บตัว Webhook เอง มี app.py (FastAPI endpoint POST /callback) กับ line_client.py (ยิงกลับไปหา LINE ทั้ง reply, push, mark-as-read, loading animation)</li></ul><p>จุดที่ออกแบบไว้ตั้งแต่แรกและผมว่าสำคัญมากคือเรื่อง Reply timing ครับ การให้ Agent ตอบหนึ่งครั้งอาจใช้เวลา 5 ถึง 20 วินาที เพราะมันต้องเรียก LLM แล้วอาจจะเรียก web_search แล้วเรียก LLM อีกรอบ ถ้าปล่อยให้ Webhook Handler รอจนตอบเสร็จค่อยส่ง Response กลับ LINE จะ Timeout ก่อน เพราะงั้นในโค้ดจะ Return &quot;OK&quot; กลับ LINE ทันทีหลังจากตรวจลายเซ็นผ่าน แล้วค่อยประมวลผล Agent เป็น Background Task แยกไปต่างหาก จากนั้นค่อยส่งคำตอบกลับไปด้วย Reply Token ถ้ายังไม่หมดอายุ หรือ Fallback ไปใช้ Push Message API แทนถ้า Token หมดอายุไปแล้วครับ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/964/0*oY3PyxACoG5Q-AIX" /></figure><blockquote><em>วิธีการเปิด Line developer หรือ จะใช้ Line official account แนะนำให้ไปศึกษาที่นี่ครับ 👇🏽</em></blockquote><blockquote><a href="https://developers.line.biz/en/docs/messaging-api/building-bot"><em>https://developers.line.biz/en/docs/messaging-api/building-bot</em></a></blockquote><h3>การ Deploy ขึ้น AWS</h3><p>เอาละ มาถึงส่วนที่ตั้งใจจะเล่าให้ละเอียดที่สุดกันดีกว่า นั่นคือการเอาโปรเจกต์นี้ขึ้นไปรันจริงบน AWS ครับ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/0*XvhT_8bZ7JfQfO77" /></figure><p>โหมด Cloud ของโปรเจกต์นี้ใช้บริการ AWS สองตัวคู่กัน คือ</p><blockquote><em>Amazon Bedrock AgentCore Runtime สำหรับรัน Agent เอง กับ AWS Lambda + Function URL สำหรับรัน Adapter ที่เป็น Webhook</em></blockquote><h3>สิ่งที่ต้องเตรียมก่อน</h3><ul><li>ติดตั้ง <a href="https://docs.astral.sh/uv/">uv</a> เป็นตัวจัดการ Package ของโปรเจกต์นี้</li><li>มี AWS Account ที่เปิดใช้ Bedrock Model Access ใน Region ที่จะ Deploy แล้ว พร้อม Credential ในเครื่อง (aws configure หรือใช้ AWS_PROFILE)</li><li>มี LINE Messaging API Channel จาก LINE Developers Console พร้อม Channel Secret กับ Channel Access Token</li><li>เปิด Docker ไว้ในเครื่อง เพราะสคริปต์ Deploy จะ Build Image เองอัตโนมัติ</li></ul><p>ตั้งค่าเริ่มต้นก่อนครับ</p><pre>uv sync<br>cp .env.example .env   # แล้วกรอก LINE_CHANNEL_SECRET, LINE_CHANNEL_ACCESS_TOKEN, AWS_PROFILE, AWS_REGION</pre><p>อยากลองว่า Agent ตอบเป็นยังไงก่อนโดยยังไม่ต้องยุ่งกับ LINE เลยก็ได้ครับ แค่รัน uv run demo.py &quot;your question&quot;</p><h3>Deploy ตัว Agent ขึ้น Bedrock AgentCore Runtime</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*qXRwqWd50pjXj7gw" /></figure><p>ขั้นแรกคือเอา Agent ขึ้นไปรันบน AgentCore Runtime ก่อน ตัวนี้จะแพคเกจ Agent เป็น Docker Image สถาปัตยกรรม ARM64 (AgentCore บังคับ ARM64 เท่านั้น) แล้วห่อด้วย BedrockAgentCoreApp ซึ่งจะสร้าง Endpoint /invocations กับ /ping ให้เองอัตโนมัติ ไม่ต้องเขียน FastAPI เพิ่มเลยครับ</p><pre>app = BedrockAgentCoreApp()<br>agent = build_agent()</pre><pre>@app.entrypoint<br>def invoke(payload: dict) -&gt; dict:<br>    prompt = payload.get(&quot;prompt&quot;, &quot;&quot;)<br>    result = agent(prompt)<br>    return {&quot;result&quot;: str(result)}</pre><p>รันคำสั่งเดียวจบครับ</p><pre>uv run scripts/deploy.py</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UjF632DgosjmELx4" /></figure><p>สคริปต์ตัวนี้ Idempotent คือรันซ้ำได้เรื่อยๆอย่างปลอดภัย เบื้องหลังมันจะทำให้ครบทุกอย่างที่ต้องใช้ คือสร้าง IAM Role สำหรับ AgentCore, สร้าง ECR Repository ถ้ายังไม่มี, Build Docker Image แบบ --platform linux/arm64, Push ขึ้น ECR แล้วสร้างหรืออัปเดต AgentCore Runtime ให้ ถ้ามีของเดิมอยู่แล้วก็แค่อัปเดต Image ในตัวเดิม ไม่สร้างซ้ำ พอเสร็จมันจะเขียน ARN ของ Runtime กลับเข้าไปใน .env ให้อัตโนมัติเป็นตัวแปร AGENTCORE_AGENT_RUNTIME_ARN ด้วย สะดวกมากครับ ไม่ต้องมานั่งก็อปวางเอง</p><h3>Deploy ตัว Adapter ขึ้น Lambda</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/506/0*zbY9DgCWEtJ_3ejQ" /></figure><p>ขั้นต่อมาคือ Adapter ตัวที่รับ Webhook จาก LINE ต้องมี Public URL ให้ LINE ยิงมาได้จริง ตัวนี้เลือกใช้ AWS Lambda คู่กับ Function URL ครับ เพราะเบามาก ไม่ต้องมี API Gateway ให้ยุ่งยาก ใช้ Mangum ห่อ FastAPI App ตัวเดิมให้กลายเป็น Lambda Handler ได้เลยแบบไม่ต้องแก้โค้ด Adapter อะไรเพิ่ม</p><pre>from mangum import Mangum<br>from adapter.app import app</pre><pre>handler = Mangum(app)</pre><p>แล้วรันอีกคำสั่งเดียว</p><pre>uv run scripts/deploy_adapter.py</pre><p>ตัวนี้จะอ่าน ARN ของ AgentCore Runtime ที่ Deploy ไปก่อนหน้านี้จาก .env มาใช้เลย เบื้องหลังจะสร้าง IAM Role ที่มีสิทธิ์เรียก invoke_agent_runtime เฉพาะ Runtime ตัวนี้เท่านั้น (ไม่ได้ให้สิทธิ์กว้างเกินจำเป็น)</p><p>สร้าง ECR Repository แยกสำหรับ Adapter, Build Image จาก Dockerfile.lambda ซึ่งเป็นคนละไฟล์กับ Dockerfile ตัวแรก เพราะ Lambda ใช้ Runtime API ไม่ใช่ Server แบบ :8080 ที่รันค้างตลอดเวลาแบบ AgentCore</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/0*ozLgyX_bYSUX-Cox" /></figure><p>แล้วก็สร้าง Lambda Function พร้อม Function URL แบบ Public ให้เสร็จสรรพ Adapter ตัวนี้ถูกตั้งค่าให้ใช้ AGENT_BACKEND=agentcore ตายตัวเลย เพราะ Lambda แต่ละ Invocation อาจรันคนละ Execution Environment กัน จะเก็บ Session แบบ In-memory ต่อ User เหมือนโหมด Local ไม่ได้อยู่แล้วครับ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/0*AjeTJ8MtbjLBE1SR" /></figure><p>ระหว่างทำจริงผมเจอบั๊กเล็กๆสามตัวที่น่าเก็บไว้เตือนใจคนอื่นด้วย</p><ul><li>Docker Builder ตัวใหม่แนบ OCI Attestation/SBOM Manifest มาด้วยโดยอัตโนมัติ ซึ่ง Lambda ไม่รองรับ Format นี้ ต้อง Build ด้วย --provenance=false --sbom=false ถึงจะผ่าน</li><li>ไฟล์ __init__.py บางไฟล์ติด Permission แบบ 600 มาจากตอนสร้างไฟล์ พอ Copy เข้า Docker Image แล้ว Lambda รันด้วย User ที่ไม่ใช่ Root เลยอ่านไฟล์ไม่ได้ ต้อง chmod -R a+rX ใน Dockerfile กันไว้เลย</li><li>Lambda Function URL ที่สร้างหลังช่วงปลายปี 2025 ต้องมีทั้ง lambda:InvokeFunctionUrl และ Resource Policy แยกสำหรับ lambda:InvokeFunction ถึงจะเปิด Public แบบ AuthType=NONE ได้จริง มีแค่ตัวแรกจะเจอ 403 อยู่ดี</li></ul><p>พอ Deploy เสร็จสคริปต์จะ Print Function URL ออกมาให้ครับ เอา URL นั้นต่อท้ายด้วย /callback แล้วเอาไปวางใน LINE Developers Console ช่อง Webhook URL จบแล้วครับ ทีนี้ก็ไปเปิด LINE แล้วลองพิมพ์คุยกับ Bot ได้เลย จุดดีของโหมด Cloud คือ URL นี้เป็น URL ถาวร ไม่เหมือนโหมด Local ที่ URL เปลี่ยนทุกครั้งที่รันใหม่</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/843/0*yiqlosXiouflyVdv" /></figure><p>ที่นี้เราก็มาลอง Chat ได้เลย</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/928/0*QtqmAg-4p94rNlV8.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/928/0*GQddCUfBenT8yRA4.jpeg" /></figure><h3>ค่าใช้จ่ายและการทำลายทิ้ง</h3><p>ทั้งสองบริการเป็นแบบจ่ายตามการใช้งานจริงครับ ไม่ได้แพงอะไร แต่ถ้าอยากหยุดจ่ายชั่วคราวก็มีสคริปต์ Teardown ให้ครบ</p><pre>uv run scripts/teardown.py           # ลบ AgentCore Runtime ตัวที่คิดเงินตาม Session<br>uv run scripts/teardown_adapter.py   # ลบ Lambda + Function URL</pre><p>ทั้งสองสคริปต์จะเก็บ ECR Repository กับ IAM Role ไว้ตามเดิมโดยดีฟอลต์ เพราะของสองอย่างนี้แทบไม่มีค่าใช้จ่ายตอน Idle และช่วยให้ Deploy รอบหน้าเร็วขึ้น ถ้าอยากลบทิ้งให้หมดจริงๆก็ใส่ Flag --all เพิ่มเข้าไปได้ครับ</p><h3>ส่วนของโหมด Local สั้นๆ</h3><p>นอกจากขึ้น AWS แล้ว โปรเจกต์นี้ยังรันบนเครื่องตัวเองล้วนๆได้เหมือนกัน เอาไว้ใช้ตอนพัฒนาหรือทดลองไอเดียเร็วๆ โดยรัน Agent ในโปรเซสเดียวกับ Adapter เลย แล้วเปิด Public ผ่าน Cloudflare Quick Tunnel (ไม่ต้องสมัครอะไรเพิ่ม) ด้วยคำสั่งเดียว</p><pre>./scripts/dev-up.sh</pre><p>ข้อเสียคือ URL จาก Tunnel จะเปลี่ยนทุกครั้งที่รันใหม่ เลยต้องไปวางใน LINE Console ใหม่ทุกรอบ เหมาะกับตอนกำลังพัฒนาหรือทดสอบไอเดียเร็วๆเท่านั้น ถ้าจะใช้งานจริงหรือปล่อยให้รันค้างไว้ยาวๆ แนะนำให้ไปทางโหมด Cloud ที่เล่าไปข้างบนดีกว่าครับ</p><h3>สรุป</h3><p>ถ้าใครอยากลองสร้าง AI Agent ตัวแรกของตัวเองแบบจับต้องได้จริง ไม่ใช่แค่ Demo ใน Notebook โปรเจกต์แนวนี้เหมาะมากครับ เพราะ Strands ทำให้ส่วนของ Agent เขียนง่าย ไม่ต้องยุ่งกับรายละเอียดของ LLM Provider เยอะ แล้วพอเลือกต่อกับ LINE คนที่มาทดสอบก็ไม่ต้องเรียนรู้อะไรใหม่เลย เปิดแชทที่มีอยู่แล้วก็คุยได้ทันที</p><p>ส่วนเรื่อง Deploy ถ้าจะทำให้จริงจังและปล่อยให้ใช้งานได้ต่อเนื่อง <strong>แนะนำให้ไปทางโหมด Cloud</strong> เพราะได้ URL ถาวร ไม่ต้องมานั่งเปลี่ยน Webhook ทุกวัน แถมยัง Scale ตามการใช้งานแบบ Pay-per-use ด้วย ส่วนโหมด Local เก็บไว้ใช้ตอน Dev หรือ Debug เร็วๆพอครับ</p><p>บทความนี้เป็นตอนแรกของซีรีส์ Strands Agent นะครับ ตอนต่อไปจะพาไปดูวิธีใช้พลังของ Agent ตัวนี้ให้เก่งขึ้นไปอีก โดยจะเจาะลึกฝั่ง Amazon Bedrock AgentCore กันมากขึ้น ทั้งเรื่อง Memory, Identity, Gateway และความสามารถอื่นๆที่ AgentCore มีให้ ใครสนใจเรื่อง AI Agent บน AWS รอติดตามตอนต่อไปได้เลยครับ 🚀</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yRM8Z4G_QbDcR-bx" /></figure><p><strong>GitHub</strong>:<br><a href="https://github.com/kriangsak-puk/strand-agent-line-application">https://github.com/kriangsak-puk/strands-agent-line-application</a></p><p><strong>ref:</strong><br> <a href="https://strandsagents.com/">https://strandsagents.com/</a><br> <a href="https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-getting-started.html">https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-getting-started.html</a><br> <a href="https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-permissions.html">https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-permissions.html</a><br> <a href="https://developers.line.biz/en/docs/messaging-api/">https://developers.line.biz/en/docs/messaging-api/</a><br> <a href="https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/do-more-with-tunnels/trycloudflare/">https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/do-more-with-tunnels/trycloudflare/</a></p><p><strong>Follow me here!<br></strong>Linkedin:<br><a href="https://www.linkedin.com/in/kriangsak-sumthong/">https://www.linkedin.com/in/kriangsak-sumthong/</a><br>Facebook page:<br><a href="https://www.facebook.com/profile.php?id=61563097228247">https://www.facebook.com/profile.php?id=61563097228247</a><br>Medium:<br><a href="https://medium.com/@puk.kriangsak">https://medium.com/@puk.kriangsak</a><br>Website:<br><a href="https://clouddatalabor.com/">https://clouddatalabor.com/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=631f35051926" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[DuckLake on AWS | The Lakehouse without Spark!]]></title>
            <link>https://medium.com/@puk.kriangsak/ducklake-on-aws-the-lakehouse-without-spark-628805ca278e?source=rss-c50d774af4fc------2</link>
            <guid isPermaLink="false">https://medium.com/p/628805ca278e</guid>
            <category><![CDATA[ducklake]]></category>
            <category><![CDATA[clouddatalabor]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[duckdb]]></category>
            <dc:creator><![CDATA[Kriangsak Sumthong]]></dc:creator>
            <pubDate>Sun, 06 Sep 2026 16:34:12 GMT</pubDate>
            <atom:updated>2026-09-06T16:34:12.745Z</atom:updated>
            <content:encoded><![CDATA[<p>พอพูดถึงคำว่า Data Lakehouse ทีไร ภาพแรกที่ผุดขึ้นมาในหัวคือ Apache Spark, Apache Iceberg, Delta Lake แล้วก็ Cluster ตัวเป้งๆ ที่ต้องมีทีมคอย Maintain กันยาวๆ ทั้งที่จริงแล้วหลายๆ Use Case มันไม่ได้ต้องการขนาดนั้นเลย</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HUzbyx42hLEhPB9O" /></figure><p>ทุกวันนี้พอพูดถึง Lakehouse คนก็มักจะนึกถึง Apache Iceberg หรือ Delta Lake เป็นอันดับแรกๆ ซึ่งก็ไม่แปลกเพราะสองตัวนี้ครองตลาดจริง แต่ทั้งคู่ถูกออกแบบมาให้ทำงานคู่กับ Compute Engine ขนาดใหญ่แบบ Spark, Trino หรือ Flink ซึ่งเหมาะกับองค์กรที่มีข้อมูลระดับ Petabyte มีทีม Data Engineer คอยดูแล Cluster ตลอดเวลา และต้องการ Concurrent Write จากหลายทีมพร้อมกัน</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/0*CKmj1UT6M1zHyhch" /></figure><p>แต่ถ้าเราเป็นทีมเล็กๆ หรือกำลังสร้าง Data Platform ขนาด Small ถึง Medium ที่ข้อมูลอาจจะอยู่แค่หลัก GB ไปจนถึง TB ต้นๆ การแบก Spark Cluster มาทั้งก้อนตั้งแต่วันแรกก็ดูจะเกินความจำเป็นไปหน่อยนะครับ ทั้งค่า Cluster ที่วิ่งตลอดเวลา ทั้ง Operational Overhead ที่ต้องมานั่งดูแล Job, Tuning Memory, จัดการ Autoscaling เอง สุดท้ายทีมเล็กๆ ก็อาจจะเสียเวลาไปกับการดูแล Infrastructure มากกว่าการทำ Data Product จริงๆ ซะอีก ยังไม่รวมที่ Spark จะทำงานได้ช้ามากถ้าต้องไปทำงานกับข้อมูลขนาดเล็ก</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/0*rK_N7Dne0Sy84pPv" /></figure><p>เอาละ แล้วถ้าไม่ใช้ Spark-based Lakehouse จะมีทางเลือกอะไรบ้าง วันนี้เลยจะขอพาไปรู้จักกับ DuckLake ตัวเลือกที่กำลังมาแรงในกลุ่มคนที่อยากได้ Lakehouse Features แต่ไม่อยากแบก Cluster กันดีกว่าครับ</p><h3>DuckLake คืออะไร</h3><blockquote>DuckLake is an integrated data lake and catalog format</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*tmGGFLUQZV35vsq3" /></figure><p>พูดง่ายๆ DuckLake คือ Table Format ตัวใหม่จากทีม DuckDB Labs เจ้าของ DuckDB นั่นแหละครับ จุดที่ต่างจาก Iceberg หรือ Delta Lake อย่างชัดเจนคือเรื่อง Metadata เพราะ Iceberg กับ Delta Lake เก็บ Metadata (Manifest, Snapshot, Transaction Log) เป็นไฟล์ JSON หรือ Avro กระจัดกระจายอยู่บน Object Storage เอง ซึ่งพอไฟล์เยอะขึ้นเรื่อยๆ การ List และ Parse ไฟล์พวกนี้ก่อน Query ทุกครั้งก็กลายเป็นคอขวดได้</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xPOOESSre8eYgSS_" /></figure><p>แต่ DuckLake เลือกเก็บ Metadata พวกนี้ไว้ใน SQL Database แทน จะเป็น PostgreSQL, MySQL, SQLite หรือแม้แต่ DuckDB เองก็ได้ ส่วนข้อมูลจริงยังคงเก็บเป็น Parquet บน Object Storage เหมือนเดิม พอ Metadata อยู่ในฐานข้อมูลที่รองรับ ACID Transaction อยู่แล้ว DuckLake ก็เลยได้ Feature ของ Lakehouse มาแบบครบๆ ทั้ง ACID Transaction, Time Travel, Schema Evolution, และ Partitioning โดยไม่ต้องมานั่งเขียน Manifest File เองเลยครับ</p><p>จุดที่ผมชอบคือ ประโยคที่ทีม DuckDB Labs ใช้อธิบายตัวเองตรงๆ ว่า</p><blockquote>DuckLake delivers advanced data lake features without traditional lakehouse complexity by using Parquet files and your SQL database</blockquote><p>แปลว่าสิ่งที่ต้องมีจริงๆ แค่ Database สักตัวไว้เป็น Catalog กับที่เก็บไฟล์ Parquet เท่านั้น ไม่ต้องมี Spark Cluster หรือ Metastore Service แยกต่างหากเลยครับ</p><h3>ตัวอย่างการ Attach DuckLake</h3><pre>ATTACH &#39;ducklake:postgres:dbname=ducklake_catalog host=rds-endpoint&#39; AS my_ducklake<br>    (DATA_PATH &#39;s3://my-bucket/curated/&#39;);<br>USE my_ducklake;<br>SELECT * FROM my_table;</pre><p>แค่นี้ DuckDB ก็จะรู้แล้วว่า Catalog อยู่ที่ Postgres ตัวไหน และข้อมูล Parquet จริงๆ อยู่ที่ S3 Path ไหน ครับ</p><h3>Let’s Try Implement: DuckLake บน AWS</h3><p>ทีนี้พอเข้าใจ DuckLake แล้ว มาดูกันว่าถ้าจะเอามาวางเป็น Data Platform จริงบน AWS แบบที่เน้น Cost-efficient ที่สุดสำหรับทีม Small ถึง Medium จะหน้าตาเป็นยังไงครับ ผมออกแบบ Architecture นี้ไว้โดยเลือกใช้ Serverless แทบทั้งหมด</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/0*Q5EDmsSMeIlZA9UO" /></figure><p><strong>Data Sources</strong> ฝั่ง Input ก็มีทั้ง App Database, SaaS API/Events, หรือไฟล์ CSV/Log ทั่วไป</p><p><strong>Orchestration</strong> ใช้ AWS Step Functions แบบ Express Workflow เพราะราคาคิดเป็น Sub-cent ต่อ Execution เหมาะกับ Pipeline ที่รันสั้นๆ บ่อยๆ ตัว Step Functions จะคอยสั่ง Lambda แต่ละตัวให้ทำงานตามลำดับ</p><p><strong>Compute</strong> เป็น Lambda ทั้งหมด 4 ตัว แบ่งหน้าที่กันชัดเจน</p><ul><li><strong>Ingest</strong> ดึงข้อมูลจาก Source มาลง S3 Raw Zone</li><li><strong>Transform</strong> รัน DuckDB พร้อม Extension ducklake แปลงข้อมูลเป็น Parquet ลง S3 Curated Zone แล้ว Update Catalog ที่ RDS</li><li><strong>Compact/Maintain</strong> รันตามรอบ Schedule ไว้ Compact ไฟล์เล็กๆ และ Expire Snapshot เก่า เพราะ DuckLake ก็ยังต้องการ Maintenance แบบนี้อยู่เพื่อให้ Query เร็ว</li><li><strong>Query</strong> ไว้ตอบ SQL Query แบบ Ad-hoc ให้ฝั่ง Consumer</li></ul><p>ข้อดีของการใช้ Lambda ทั้งหมดคือ Pay-per-invocation ไม่มี Idle Cost เลย แต่ก็ต้องรู้ Limit ไว้ด้วยนะครับว่า Lambda รันได้สูงสุด 15 นาที Memory 10GB และ /tmp อีก 10GB ถ้า Query ไหนหนักเกินนี้ค่อยผลักไปรันบน Fargate Task แทน</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-CL_4ijwk-nrKaJH" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/0*cWL8ZYYflvvuhvY5" /></figure><p><strong>Consumption</strong> แบ่งเป็นสองทางตามกลุ่มผู้ใช้ ฝั่ง Notebook หรือ Internal App ที่อยากยิง SQL แบบ Programmatic ก็ผ่าน API Gateway ไปเรียก Lambda Query ส่วนฝั่ง Business User ที่อยากได้ Dashboard แบบ Point-and-click ผมใส่ Apache Superset รันบน Fargate เข้าไป โดย Superset ต่อ DuckDB ผ่าน duckdb-engine ตรงๆ แล้ว ATTACH Catalog ของ DuckLake เลย ไม่ต้องผ่าน Lambda อีกชั้นด้วยซ้ำ ส่วน Metastore ของ Superset เองก็ใช้ RDS ตัวเดียวกันแค่แยก Schema ประหยัดไปอีกก้อนหนึ่งครับ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/0*PCm79CE5mQd_zfkr" /></figure><h3>ทำไมเลือก Superset ไม่ใช้ Athena หรือ Redshift ไปเลย</h3><p>พออ่านมาถึงตรงนี้หลายคนอาจจะสงสัยว่า ทำไมไม่ใช้ Athena หรือ Redshift Spectrum ต่อเข้ากับ S3 ไปเลย ในเมื่อทั้งคู่ก็เป็น Serverless Query Engine ของ AWS เองเหมือนกัน คำตอบสั้นๆ คือทั้ง Athena และ Redshift Spectrum ผูกกับ AWS Glue Data Catalog เป็นหลัก ซึ่งเข้าใจ Table Format แบบ Iceberg หรือ Hive Style เป็นหลัก แต่ไม่ได้เข้าใจ Catalog ของ DuckLake ที่เก็บอยู่ใน Postgres โดยตรง ถ้าจะใช้จริงต้องมี Step แปลง Metadata จาก DuckLake ไปเป็น Iceberg ก่อน ซึ่งเป็นการเพิ่ม Moving Part เข้ามาโดยไม่จำเป็น ทั้งที่จุดขายของ DuckLake คือการไม่ต้องมี Catalog Service แยกต่างหากตั้งแต่แรก (หวังว่าอนาคต Athena และ Redshift จะสามารถอ่านได้นะ หลังจากที่ AWS ซื้อกิจการ DuckDB Labs ไปแล้ว)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/0*1C-7m6hOOOqGMc2y" /></figure><p>พอเทียบกันแล้ว Superset ต่อ DuckDB ตรงๆ DuckDB คือ Engine ตัวเดียวกับที่เขียนข้อมูล DuckLake ขึ้นมาตั้งแต่แรก ไม่มี Step แปลง Format ระหว่างทางเลย แถมได้ Dashboard UI มาในตัวเดียวจบ ไม่ต้องแยกเป็น Query Engine หนึ่งตัวกับ BI Tool อีกตัว และค่าใช้จ่ายก็คุมง่ายกว่าเพราะเป็น Container ราคาคงที่ที่ Scale-to-zero ได้ ไม่ใช่ Pay-per-TB-scanned แบบ Athena ที่ถ้า Dashboard Refresh บ่อยๆ โดยไม่ทำ Partition ให้ดี ค่าใช้จ่ายอาจจะพุ่งแบบไม่ทันตั้งตัวได้เหมือนกันครับ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ER9dG1vTyk82tXCj" /></figure><p>แต่ช้าก่อน! Fargate เป็น Container ที่รันค้างไว้ ไม่ใช่ Pay-per-invocation แบบ Lambda จุดนี้เลยเป็นจุดเดียวใน Architecture ที่มี Cost แบบ Always-on ผมเลยแนะนำให้ทำ <strong>Scale-to-zero</strong> ด้วย Application Auto Scaling ตั้ง Scheduled Action ให้ Desired Count เป็น 1 ตอนเข้างาน แล้วปรับเป็น 0 ตอนเลิกงานกับวันหยุด ใครอยากได้แบบ Advanced กว่านั้นก็ทำ Wake-on-request ผ่าน Lambda เช็คสถานะ Service แล้วสั่ง Start ให้อัตโนมัติเมื่อมีคน Request เข้ามาได้เหมือนกัน แบบนี้ทีม Small-Medium ก็จะจ่ายค่า Fargate แค่ช่วงที่มีคนใช้งานจริงๆ เท่านั้นเองครับ</p><blockquote>ผมอาจจะไม่ได้เขียนลงรายละเอียดเกี่ยวกับ Deploy Ducklake on AWS มากนัก ผมมีทำ Github Repository เอาไว้ ซึ่งสามารถศึกษาหรือเอาไปลองเล่นได้เลย</blockquote><h3>สรุปให้ชัดๆว่าทำไม Architecture นี้ถึงประหยัด</h3><p>เหตุผลที่ Architecture นี้มีความ Cost-efficient สูง มาจากปัจจัยเหล่านี้</p><ul><li><strong>Lambda</strong> จ่ายแบบ Pay-per-invocation ไม่มี Idle Cost เลย</li><li><strong>Step Functions Express</strong> คิดเงินแบบ Sub-cent ต่อ Execution</li><li><strong>S3</strong> ตั้ง Lifecycle Rule ย้ายข้อมูลเย็นไป Glacier ให้อัตโนมัติ</li><li><strong>RDS</strong> ใช้ Instance เล็กๆ ตัวเดียว ทำหน้าที่ทั้งเป็น Catalog ของ DuckLake และ Metastore ของ Superset ไปพร้อมกัน ไม่ได้มีความจำเป็นต้องใช้ Compute อะไรมาก</li><li><strong>Fargate (Superset)</strong> เป็นจุดเดียวในนี้ที่รันค้างไว้ แต่ก็ตั้ง Scale-to-zero นอกเวลาทำงานได้เหมือนกัน *แต่ถ้าทีมไหนไม่ได้มีความจำเป็นที่จะต้องใช้ Superset ในการ Query สามารถเชื่อมต่อเองได้ผ่าน CLI หรือ Local script ก็จะประหยัดตรงนี้ไปได้อีก</li></ul><p>พูดง่ายๆ คือแทบไม่มีอะไรใน Architecture นี้ที่รันตลอดเวลาเลยครับ นอกจาก RDS และ Fargate ที่ก็ยังคุมด้วย Schedule ให้ประหยัดขึ้นได้อีกที</p><h3>แล้ว Cost จริงๆ ประมาณเท่าไหร่</h3><p>พูดมาเยอะเรื่อง Cost-efficient แล้ว ลองมาดูตัวเลขคร่าวๆ กันดีกว่าครับ ว่าสำหรับทีม Small-Medium ที่ข้อมูลอยู่หลัก GB ถึง TB ต้นๆ ค่าใช้จ่ายรายเดือนหน้าตาจะประมาณไหน (อิงราคาโซน US East, N. Virginia ซึ่งถูกที่สุด ส่วนภูมิภาคอื่นอาจแพงกว่านี้ 10–30% และตัวเลขจริงจะขยับตาม Data Volume กับความถี่ในการ Query ของแต่ละทีมด้วยนะครับ)</p><ul><li><strong>Lambda + Step Functions Express</strong>: ทีมเล็กๆ ที่ Pipeline รันไม่บ่อยมาก มักจะอยู่ในหรือใกล้ Free Tier เลยครับ (Lambda ให้ฟรี 1 ล้าน Requests กับ 400,000 GB-seconds ต่อเดือน) ถ้าเกินก็ยังอยู่หลักไม่กี่ดอลลาร์ต่อเดือนเท่านั้น</li><li><strong>S3</strong>: Storage แบบ Standard อยู่ที่ประมาณ $0.023 ต่อ GB ต่อเดือน ถ้าตั้ง Lifecycle Rule ย้าย Raw Zone เก่าๆ ไป Glacier ก็ถูกลงไปอีก</li><li><strong>RDS db.t4g.micro (Postgres)</strong>: ค่า Compute อยู่ที่ประมาณ $12–15 ต่อเดือน (ยังไม่รวม Storage อีกไม่กี่ดอลลาร์) ตัวเดียวรับหน้าที่ทั้ง DuckLake Catalog และ Superset Metastore เลย</li><li><strong>Fargate (Superset)</strong>: ที่ Spec 0.5 vCPU / 1GB ถ้ารันตลอด 24/7 จะอยู่ที่ประมาณ $18 ต่อเดือน แต่ถ้าทำ Scale-to-zero เหลือแค่ช่วงเวลาทำงาน (Weekday 8 โมงเช้าถึง 5 โมงเย็น) จะลดลงเหลือประมาณ $5–6 ต่อเดือนเท่านั้นเอง</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_vsJeP9JCV1vKpt7" /></figure><p>รวมๆ แล้วทีม Small-Medium น่าจะจ่ายอยู่ที่หลักสิบดอลลาร์ต่อเดือนเท่านั้นครับ ถูกกว่า Spark Cluster ขั้นต่ำที่ต้องมี 2 Worker วิ่งตลอดเวลาเยอะมาก ตัวเลขนี้เป็นแค่ตัวอย่างคร่าวๆ นะครับ อย่าลืมเช็คราคาจริงจาก AWS Pricing Calculator อีกทีก่อนตัดสินใจด้วยนะครับ</p><h3>สรุป</h3><p>DuckLake บวกกับ Architecture แบบ Lambda + Step Functions + Fargate Scale-to-zero แบบนี้ เหมาะมากสำหรับทีมหรือ Data Platform ขนาด Small ถึง Medium ที่อยากได้ Feature ของ Lakehouse จริงๆ ทั้ง ACID, Time Travel, Schema Evolution แต่ไม่อยากมีภาระดูแล Cluster หรือจ่ายค่า Infrastructure ที่ไม่ได้ใช้เต็มประสิทธิภาพ <strong>ถ้างบจำกัดและทีมเล็ก นี่คือทางเลือกที่คุ้มมากครับ</strong></p><p>แต่ถ้าองค์กรมีข้อมูลระดับ Petabyte ต้องการ Concurrent Write จากหลายทีมพร้อมกันจำนวนมาก หรือ Ecosystem เดิมผูกกับ Spark/Trino/Presto อยู่แล้ว <strong>DuckLake ก็อาจจะยังไม่ใช่คำตอบที่เหมาะที่สุด</strong> เพราะ Ecosystem รอบๆ Iceberg หรือ Delta Lake ยังกว้างกว่ามากในตอนนี้</p><p>ทีนี้พอพูดถึง AWS โดยเฉพาะ หลายคนอาจจะคุ้นกับ Lakehouse แบบดั้งเดิมที่ใช้ Glue Data Catalog เก็บ Metadata แบบ Iceberg แล้วต่อกับ Athena, EMR, หรือ Redshift Spectrum ซึ่งเป็นสาย Spark/Presto Ecosystem เต็มตัว คำถามที่น่าคิดต่อคือแล้วระหว่าง DuckLake Architecture แบบที่เล่าวันนี้ กับ AWS Lakehouse สาย Iceberg แบบดั้งเดิม ต่างกันตรงไหนบ้างในแง่ Cost, Performance, และ Use Case ที่เหมาะสม เดี๋ยวขอเก็บไปเขียนเปรียบเทียบกันแบบละเอียดในบทความหน้านะครับ เพราะเนื้อหาน่าจะยาวพอจะแยกเป็นอีกบทความหนึ่งได้เลย</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xA6aJSYB6g5zScJc" /></figure><p><strong>Github Repo:<br></strong><a href="https://github.com/kriangsak-puk/serverless-ducklake">https://github.com/kriangsak-puk/serverless-ducklake</a></p><p><strong>REF</strong>:<br><a href="https://ducklake.select/">https://ducklake.select</a><br><a href="https://motherduck.com/glossary/ducklake/">https://motherduck.com/glossary/ducklake/</a></p><p><strong>Follow me here!<br></strong>Linkedin:<br><a href="https://www.linkedin.com/in/kriangsak-sumthong/">https://www.linkedin.com/in/kriangsak-sumthong/</a><br>Facebook page:<br><a href="https://www.facebook.com/profile.php?id=61563097228247">https://www.facebook.com/profile.php?id=61563097228247</a><br>Medium:<br><a href="https://medium.com/@puk.kriangsak">https://medium.com/@puk.kriangsak</a><br>Website:<br><a href="https://clouddatalabor.com/">https://clouddatalabor.com/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=628805ca278e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Top 5 Airflow DAG Mistakes and How You Can Prevent Them!]]></title>
            <link>https://medium.com/@puk.kriangsak/top-5-airflow-dag-mistakes-and-how-you-can-prevent-them-194c77735da2?source=rss-c50d774af4fc------2</link>
            <guid isPermaLink="false">https://medium.com/p/194c77735da2</guid>
            <category><![CDATA[clouddatalabor]]></category>
            <category><![CDATA[airflow]]></category>
            <dc:creator><![CDATA[Kriangsak Sumthong]]></dc:creator>
            <pubDate>Sat, 29 Aug 2026 17:04:13 GMT</pubDate>
            <atom:updated>2026-08-29T17:04:13.296Z</atom:updated>
            <content:encoded><![CDATA[<p>5 ข้อผิดพลาดที่เจอบ่อยที่สุดใน Airflow DAG</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZkmygTK3pSpq4LUd" /></figure><h3>Introduction</h3><p>ทำไม Airflow Scheduler ของทีมถึงช้าลงเรื่อยๆ ทั้งที่จำนวน DAG ก็ไม่ได้เยอะขนาดนั้น หรือทำไมพอ Task พังกลางดึกแล้วกด Retry ไปกลับได้ข้อมูลซ้ำซ้อนแทนที่จะได้ผลลัพธ์เดิม</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Hj_1H1d49KKh0Dja" /></figure><p>มีโอกาสได้ไล่รีวิว Airflow DAG มาหลายตัวจากหลายๆที่ก็เริ่มเห็น Pattern ที่ซ้ำกันจนสังเกตได้ว่าปัญหาส่วนใหญ่ที่ทำให้ Cluster ช้าลง Debug ยากขึ้น หรือ Resource ไม่พอ ไม่ได้มาจากเรื่องซับซ้อนอะไรเลยครับ แต่มาจาก 5 เรื่องนี้ที่เจอซ้ำแล้วซ้ำอีก วันนี้เลยขอรวบรวมมาเล่าให้ฟัง พร้อมตัวอย่างโค้ดแบบ Bad กับ Good เทียบกันให้เห็นชัดๆ</p><h3>Top 5 common mistakes</h3><h3>1. Top-level Code</h3><p>อันนี้เจอบ่อยที่สุดเลยครับ คนมักลืมไปว่าไฟล์ DAG ไม่ได้ถูกรันแค่ตอน Deploy ครั้งเดียวแบบสคริปต์ปกติ แต่ Scheduler จะ Parse ไฟล์นี้ซ้ำๆ ตามรอบ dag_dir_list_interval (Default ทุก 30 วินาที) เพื่อเช็คว่ามี DAG ใหม่หรือมีการแก้ไขไหม ซึ่งหมายความว่าโค้ดตัวไหนที่อยู่นอก Task หรือ Operator (เรียกว่า Top-level Code) จะถูกรันซ้ำทุก 30 วินาทีแบบไม่มีวันหยุดครับ</p><pre># Bad: เรียก API ตอน Parse DAG ทุกครั้ง<br>import requests<br>from airflow import DAG<br>from airflow.operators.python import PythonOperator<br>from datetime import datetime<br>config = requests.get(&quot;https://api.internal.company.com/dag-config&quot;).json()<br>with DAG(<br>    dag_id=&quot;bad_top_level_call&quot;,<br>    start_date=datetime(2024, 1, 1),<br>    schedule=&quot;@daily&quot;,<br>) as dag:<br>    task = PythonOperator(<br>        task_id=&quot;process&quot;,<br>        python_callable=lambda: print(config),<br>    )</pre><pre># Good: ย้าย Logic ที่หนักไปไว้ใน Task ให้รันตอน Execute จริงเท่านั้น<br>import requests<br>from airflow import DAG<br>from airflow.operators.python import PythonOperator<br>from datetime import datetime<br>def process(**context):<br>    config = requests.get(&quot;https://api.internal.company.com/dag-config&quot;).json()<br>    print(config)<br>with DAG(<br>    dag_id=&quot;good_top_level_call&quot;,<br>    start_date=datetime(2024, 1, 1),<br>    schedule=&quot;@daily&quot;,<br>    catchup=False,<br>) as dag:<br>    task = PythonOperator(<br>        task_id=&quot;process&quot;,<br>        python_callable=process,<br>    )</pre><p>ถ้าใน Top-level Code นั้นมีการยิง API เรียก DB หรืออ่านไฟล์ นั่นแปลว่าระบบปลายทางโดนยิงถี่ยิบตลอดเวลาโดยที่ DAG ยังไม่ได้ทำงานจริงด้วยซ้ำ แถม Scheduler เองก็จะช้าลงเพราะต้อง Parse โค้ดหนักๆ ซ้ำไปเรื่อยๆ ลองมาดูตัวอย่างเวลาของ DAG parsing จะเห็นเลยว่าต่างกันขนาดไหน (อันนี้ขนาดว่ามีแค่อันเดียวนะ ถ้าเป็นร้อย เป็นพันละ</p><p>)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/0*rfyrylAhTd6XlKTk" /></figure><p>เสริมอีกนิดเรื่อง Airflow Architecture จะได้เข้าใจมากขึ้นว่าทำไมการ parse ซ้ำๆของโค้ดที่ไม่ดีจะส่งผลกระทบกับ resource ยังไง โดยจะเห็นว่า Scheduler จะทำงานเป็นทั้งตัวอ่านไฟล์และส่งงานไปที่ worker ทำให้ถ้า DAG parsing ยิ่งนานก็ยิ่งกระทบไปเรื่อยๆ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/576/0*DMGUVSpQZYqr5dxo" /></figure><h3>2. Sensor ที่ไปจับ Worker Slot ค้างไว้ ทั้งที่มี Deferrable Operator ให้ใช้แล้ว</h3><blockquote>Deferrable Operator คือ Operator ที่พักตัวเองแล้วปล่อย Worker Slot คืนระหว่างรอ แทนที่จะจับ Slot ไว้เฉยๆ จนกว่าเงื่อนไขจะเป็นจริง</blockquote><p>Sensor แบบ Standard (Mode poke หรือ reschedule แบบเก่า) จะจับ Worker Slot ไว้ตลอดเวลาที่รอ ต่อให้ไม่ได้ทำอะไรเลยก็ตาม ลองนึกภาพว่ามี Worker 100 Slot แล้วมี 100 DAG ที่รอ Sensor ตัวเดิมพร้อมกัน Cluster ทั้งก้อนจะโดนล็อกจนรันอย่างอื่นไม่ได้เลยทั้งที่จริงๆแล้วแทบไม่มีอะไรทำงานอยู่เลยครับ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*f2CGPWQEfrmtgYry" /></figure><p>ทางแก้คือใช้ Deferrable Sensor ซึ่ง Airflow มีให้ใช้แทนตัวเดิมแบบ Drop-in ได้เลยในหลาย Operator (ผ่าน Parameter deferrable=True หรือใช้ Class รุ่น Async เช่น TimeSensorAsync) โดยงานรอจะถูกโยนไปให้ Triggerer จัดการแทน Worker</p><pre># Bad: Sensor จับ Worker Slot ไว้ 5 ชั่วโมงเต็มๆ ระหว่างรอ<br>from airflow.sensors.external_task import ExternalTaskSensor<br>wait_for_upstream = ExternalTaskSensor(<br>    task_id=&quot;wait_for_upstream&quot;,<br>    external_dag_id=&quot;upstream_dag&quot;,<br>    poke_interval=60,<br>    timeout=60 * 60 * 5,<br>    mode=&quot;poke&quot;,<br>)</pre><pre># Good: เปิด deferrable ปล่อย Worker Slot คืนระหว่างรอ ใช้ Triggerer แทน<br>from airflow.sensors.external_task import ExternalTaskSensor<br>wait_for_upstream = ExternalTaskSensor(<br>    task_id=&quot;wait_for_upstream&quot;,<br>    external_dag_id=&quot;upstream_dag&quot;,<br>    poke_interval=60,<br>    timeout=60 * 60 * 5,<br>    deferrable=True,<br>)</pre><h3>3. Task ที่ไม่ Atomic ไม่ Idempotent และไม่ Modular</h3><p>อันนี้เป็นเรื่องที่ทำให้ Debug กับ Retry กลายเป็นฝันร้ายเลยครับ หลายทีมชอบยัด Extract, Transform, Load รวมเป็น Function เดียวใน PythonOperator ตัวเดียว พอ Step ท้ายๆพังจะต้องรันใหม่ทั้งหมดตั้งแต่ต้น แถมถ้า Load เป็นการ INSERT ธรรมดาไม่ใช่ Upsert พอ Retry ก็จะได้ข้อมูลซ้ำเข้าไปอีกชุดทันที</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZFSJv_b58BtDETjS" /></figure><p>Task ที่ดีควรทำงานเดียวจบในตัว (Atomic) และรันซ้ำกี่ครั้งก็ได้ผลลัพธ์เหมือนเดิมเป๊ะ (Idempotent) ไม่ใช่ยิ่งรันยิ่งพังข้อมูลมากขึ้น</p><pre># Bad: รวม Extract + Transform + Load ไว้ Function เดียว และ Insert ตรงๆ<br>def extract_transform_load():<br>    data = extract_from_api()<br>    df = transform(data)<br>    load_to_warehouse(df)  # Insert ตรงๆ, Retry ทีก็ได้ข้อมูลซ้ำที<br>etl_task = PythonOperator(<br>    task_id=&quot;etl_all_in_one&quot;,<br>    python_callable=extract_transform_load,<br>)</pre><pre># Good: แยกเป็น Task ย่อย Atomic แต่ละตัว และ Load แบบ Upsert ตาม Partition<br>from airflow.decorators import task<br>@task<br>def extract(logical_date=None):<br>    partition = logical_date.format(&quot;YYYY-MM-DD&quot;)<br>    return extract_from_api(partition=partition)<br>@task<br>def transform(raw_data):<br>    return transform_fn(raw_data)<br>@task<br>def load(transformed_data, logical_date=None):<br>    partition = logical_date.format(&quot;YYYY-MM-DD&quot;)<br>    upsert_to_warehouse(transformed_data, partition=partition)<br>load(transform(extract()))</pre><h3>4. Over-provisioning และ Concurrency ที่ไม่มีขอบเขต</h3><p>ข้อนี้จริงๆแยกได้เป็นสองปัญหาที่มักเกิดคู่กันครับ เลยขอแยกอธิบายทีละอย่างให้ชัดๆ</p><p>Over-provisioning คือการตั้ง Resource Request (CPU/Memory) ให้ Task สูงเกินความจำเป็นจริงมาก เช่นใช้ KubernetesPodOperator แล้ว Request CPU 4 Core Memory 16Gi ทั้งที่ Task จริงๆใช้ Resource แค่เสี้ยวเดียว พอมี Task แบบนี้เยอะขึ้นเรื่อยๆ Cluster ก็จะเต็มเร็วกว่าที่ควรจะเป็น เพราะ Kubernetes Scheduler จอง Resource ตาม Request ไม่ใช่ตาม Usage จริง ทำให้ Task อื่นต้องรอคิวทั้งที่ Resource จริงยังเหลือเฟืออยู่เลยครับ</p><pre># Bad: Request CPU/Memory เกินความจำเป็นจริงของ Task<br>from airflow.providers.cncf.kubernetes.operators.pod import KubernetesPodOperator<br>from kubernetes.client import models as k8s<br>heavy_request_task = KubernetesPodOperator(<br>    task_id=&quot;transform_small_file&quot;,<br>    image=&quot;my-transform-image:latest&quot;,<br>    container_resources=k8s.V1ResourceRequirements(<br>        requests={&quot;cpu&quot;: &quot;4&quot;, &quot;memory&quot;: &quot;16Gi&quot;},  # Task จริงใช้ไม่ถึง 10%<br>        limits={&quot;cpu&quot;: &quot;4&quot;, &quot;memory&quot;: &quot;16Gi&quot;},<br>    ),<br>)</pre><pre># Good: Profile Usage จริงก่อน แล้วตั้ง Resource ให้ใกล้เคียงของจริง<br>from airflow.providers.cncf.kubernetes.operators.pod import KubernetesPodOperator<br>from kubernetes.client import models as k8s<br>right_sized_task = KubernetesPodOperator(<br>    task_id=&quot;transform_small_file&quot;,<br>    image=&quot;my-transform-image:latest&quot;,<br>    container_resources=k8s.V1ResourceRequirements(<br>        requests={&quot;cpu&quot;: &quot;250m&quot;, &quot;memory&quot;: &quot;512Mi&quot;},<br>        limits={&quot;cpu&quot;: &quot;500m&quot;, &quot;memory&quot;: &quot;1Gi&quot;},<br>    ),<br>)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PZgbWCfbKu-InQFj" /></figure><p>ส่วน Concurrency ที่ไม่มีขอบเขต คือทีมเปิด Catchup ทิ้งไว้ หรือไม่ตั้ง Limit อะไรเลย พอ Deploy DAG ใหม่หรือแก้ start_date ปุ๊บ Airflow ก็จะพยายามรัน Backfill ย้อนหลังทีเดียวหลายร้อย Run พร้อมกัน แต่ละ Run ก็ยิง Connection เข้า Database หรือ API ปลายทางพร้อมๆกันจนระบบเป้าหมายรับไม่ไหว</p><p>ปัญหาคือสองอย่างนี้พอมาเจอกันจะยิ่งหนักขึ้นไปอีก เพราะ Task ที่ Over-provisioned อยู่แล้ว พอมารันพร้อมกันแบบไม่มี Limit ก็จะกิน Resource เกินจริงไปหลายเท่าตัว กลายเป็น Resource Contention ทั้ง Cluster ไม่ใช่แค่ DAG ตัวเดียวที่ได้รับผลกระทบด้วยครับ</p><pre># Bad: ไม่จำกัด Concurrency เลย แถมเปิด Catchup ทิ้งไว้<br>with DAG(<br>    dag_id=&quot;bad_unbounded_concurrency&quot;,<br>    schedule=&quot;@hourly&quot;,<br>    start_date=datetime(2024, 1, 1),<br>    catchup=True,<br>) as dag:<br>    ...</pre><pre># Good: จำกัดทั้งจำนวน Run พร้อมกัน, Task พร้อมกัน และ Connection ผ่าน Pool<br>with DAG(<br>    dag_id=&quot;good_bounded_concurrency&quot;,<br>    schedule=&quot;@hourly&quot;,<br>    start_date=datetime(2024, 1, 1),<br>    catchup=False,<br>    max_active_runs=1,<br>    max_active_tasks=10,<br>) as dag:<br>    query_task = PythonOperator(<br>        task_id=&quot;query_warehouse&quot;,<br>        python_callable=query_fn,<br>        pool=&quot;warehouse_connections&quot;,<br>    )</pre><h3>5. เรื่องเล็กๆที่ดูไม่สำคัญ แต่พอสะสมหลายร้อย DAG กลายเป็นปัญหาใหญ่</h3><p>พวกนี้แยกเป็นเรื่องเดียวไม่คุ้มเขียนหัวข้อ แต่พอเจอรวมกันในหลาย DAG พร้อมกันก็สร้างความปวดหัวได้ไม่แพ้ 4 ข้อข้างบนเลยครับ</p><ul><li><strong>Owner ไม่ชัดเจน</strong> DAG ส่วนใหญ่ปล่อย owner เป็น &quot;airflow&quot; ตาม Default พอ DAG พังกลางดึกไม่มีใครรู้ว่าต้อง Ping ใคร</li><li><strong>Schedule ไม่ Timezone-aware</strong> ใช้ datetime.utcnow() หรือ Naive Datetime ตรงๆ พอทีมอยู่คนละ Timezone จะงงกันหมดว่า DAG รันตอนกี่โมงกันแน่ในเวลาท้องถิ่น (โดยเฉพาะทำงานกับบริษัทที่เป็น International)</li><li><strong>Retry Config ตั้งผิด</strong> บางทีตั้ง retries=0 ทำให้ Task ที่พังจาก Network Blip เล็กๆน้อยๆ ล้มทันทีไม่มีโอกาสลองใหม่ หรือตรงข้ามคือตั้ง retry_delay สั้นเกินไปจน Retry รัวใส่ระบบปลายทางที่กำลังมีปัญหาอยู่แล้วซ้ำเข้าไปอีก</li></ul><pre># Bad<br>default_args = {<br>    &quot;owner&quot;: &quot;airflow&quot;,<br>    &quot;retries&quot;: 0,<br>}<br>start_date = datetime(2024, 1, 1)  # Naive, ไม่มี Timezone<br>...</pre><pre># Good<br>import pendulum<br>default_args = {<br>    &quot;owner&quot;: &quot;team-data-platform&quot;,<br>    &quot;retries&quot;: 3,<br>    &quot;retry_delay&quot;: pendulum.duration(minutes=5),<br>    &quot;retry_exponential_backoff&quot;: True,<br>}<br>start_date = pendulum.datetime(2024, 1, 1, tz=&quot;Asia/Bangkok&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GB4dv0LYCTi6SPU6" /></figure><h3>Checklists ตรวจ DAG ของตัวเองก่อน Deploy</h3><p>ตัวอย่าง Checklist สำหรับให้ทีมใช้ตรวจสอบ DAG</p><ul><li>ไม่มี Network Call, DB Query หรือ File Read อยู่นอก Task/Operator (ไม่มี Top-level Code หนักๆ)</li><li>Sensor ทุกตัวเช็คแล้วว่ามี Deferrable Mode ให้ใช้ไหม ถ้ามีให้เปิด deferrable=True</li><li>แต่ละ Task ทำงานเดียวจบ (Atomic) และรันซ้ำได้โดยไม่ทำข้อมูลซ้ำหรือพัง (Idempotent)</li><li>Resource Request (CPU/Memory) ของแต่ละ Task ผ่านการ Profile Usage จริงแล้ว ไม่ใช่ตั้งกันเผื่อไว้ก่อนแบบเดาสุ่ม</li><li>ตั้ง max_active_runs, max_active_tasks และใช้ Pool คุม Connection ที่จำกัดแล้ว</li><li>owner ใน default_args เป็นชื่อทีมหรือ Alias ที่ Ping ได้จริง ไม่ใช่ &quot;airflow&quot; เฉยๆ</li><li>start_date เป็น Timezone-aware Object (เช่นผ่าน pendulum) ไม่ใช่ Naive Datetime</li><li>retries และ retry_delay ตั้งเหมาะสม ไม่ใช่ 0 และไม่ถี่จนซ้ำเติมระบบปลายทาง</li><li>catchup ปิดไว้ (False) เว้นแต่ตั้งใจจะ Backfill จริงๆ และรู้ว่าต้องจำกัด Concurrency ตอน Backfill ด้วย</li></ul><h3>Summary</h3><p>5 ข้อนี้ไม่มีอะไรซับซ้อนเลยสักข้อ แต่เป็นสิ่งที่หลุดง่ายที่สุดเพราะทีมมักมอง DAG File เหมือน Python Script ธรรมดาที่รันครั้งเดียวจบ ทั้งที่จริงๆ Scheduler มัน Parse ซ้ำตลอดเวลา และ Task แต่ละตัวก็มีโอกาสถูก Retry ได้เสมอ</p><p>ถ้าจะให้เรียงลำดับว่าควรแก้อะไรก่อน ผมมองว่า <strong>ข้อ 1 (Top-level Code) กับข้อ 2 (Sensor แบบเก่า) ควรแก้ก่อนสุด</strong> เพราะสองอย่างนี้กระทบ Performance ของ Scheduler และ Cluster ทั้งก้อน ไม่ใช่แค่ DAG ตัวเดียวที่มีปัญหา ส่วนเรื่อง Atomic/Idempotent กับ Concurrency ก็ตามมาติดๆเพราะเกี่ยวกับความถูกต้องของข้อมูลโดยตรง ส่วนข้อ 5 ที่ดูเป็นเรื่อง Hygiene เล็กๆนั้น <strong>อย่ามองข้าม</strong> เพราะพอมี DAG เป็นร้อยเป็นพันตัวในองค์กร ความไม่เป๊ะเล็กๆพวกนี้คือสิ่งที่ทำให้ทีม On-call ปวดหัวที่สุดตอนกลางดึกครับ</p><p>ตัวอย่าง DAG แบบเต็มที่รวมการแก้ทั้ง 5 ข้อไว้ใน Github Repo นี้เลย<br><a href="https://github.com/kriangsak-puk/top-airflow-common-mistake">https://github.com/kriangsak-puk/top-airflow-common-mistake</a></p><p><strong>REF</strong>:<a href="https://airflow.apache.org/docs/apache-airflow/stable/authoring-and-scheduling/deferring.html">https://airflow.apache.org/docs/apache-airflow/stable/authoring-and-scheduling/deferring.html</a><br><a href="https://airflow.apache.org/docs/apache-airflow/stable/core-concepts/sensors.html">https://airflow.apache.org/docs/apache-airflow/stable/core-concepts/sensors.html</a><br><a href="https://airflow.apache.org/docs/apache-airflow/stable/best-practices.html">https://airflow.apache.org/docs/apache-airflow/stable/best-practices.html</a></p><p><strong>Follow me here!<br></strong>Linkedin:<br><a href="https://www.linkedin.com/in/kriangsak-sumthong/">https://www.linkedin.com/in/kriangsak-sumthong/</a><br>Facebook page:<br><a href="https://www.facebook.com/profile.php?id=61563097228247">https://www.facebook.com/profile.php?id=61563097228247</a><br>Medium:<br><a href="https://medium.com/@puk.kriangsak">https://medium.com/@puk.kriangsak</a><br>Website:<br><a href="https://clouddatalabor.com/">https://clouddatalabor.com/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=194c77735da2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Get Started with RPU | AWS Redshift Serverless]]></title>
            <link>https://medium.com/@puk.kriangsak/get-started-with-rpu-aws-redshift-serverless-4cd56b0cf7ba?source=rss-c50d774af4fc------2</link>
            <guid isPermaLink="false">https://medium.com/p/4cd56b0cf7ba</guid>
            <category><![CDATA[clouddatalabor]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[aws-redshift]]></category>
            <dc:creator><![CDATA[Kriangsak Sumthong]]></dc:creator>
            <pubDate>Sun, 23 Aug 2026 15:38:02 GMT</pubDate>
            <atom:updated>2026-08-23T15:38:02.767Z</atom:updated>
            <content:encoded><![CDATA[<p>A Beginner’s Guide to Understanding RPUs in AWS Redshift Serverless, Let’s go!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Zm_NANj6Fu2in_aM" /></figure><h3>Introduction</h3><p>เปิดหน้า Pricing ของ AWS Redshift Serverless แล้วเจอคำว่า RPU โผล่มาเต็มไปหมด แต่ไม่รู้จะตั้งเท่าไหร่ดีถึงจะพอดีกับงานที่ทำอยู่ แล้วสุดท้ายบิลจะออกมาเท่าไหร่กันแน่ วันนี้เลยจะขอพามาถอดรหัสตัวเลขตัวนี้กัน</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/0*DmgKy4W943B0gOdd" /></figure><p>ปกติเวลาเราใช้ Redshift แบบ Provisioned เราก็ต้องมานั่งเลือก Node type เลือกจำนวน Node เอง ซึ่งเป็นการตัดสินใจที่ปวดหัวไม่น้อย แต่พอมาเป็น Serverless ทาง AWS ตัดเรื่องพวกนี้ทิ้งไปเลย เหลือแค่ตัวเลขตัวเดียวที่เราต้องตั้งคือ RPU เท่านั้นเองครับ ฟังดูเหมือนง่ายขึ้นเยอะ แต่คำถามที่ตามมาคือ แล้วตัวเลขนี้มันคืออะไรกันแน่ และเราจะรู้ได้ไงว่าต้องตั้งเท่าไหร่ถึงจะพอดี ไม่จ่ายแพงเกินจำเป็น</p><h3>RPU คืออะไรกันแน่</h3><blockquote>Redshift Processing Unit (RPU)</blockquote><p>พูดง่ายๆ RPU ก็คือหน่วยของ Compute capacity ที่ Redshift Serverless ใช้วัดกำลังการประมวลผล โดย 1 RPU จะให้ Memory มา 16 GB พร้อม Compute และ I/O ที่ Scale ตามสัดส่วนกันไปด้วย เราไม่ต้องมาแยกตั้งค่า Memory กับ Compute เองแบบ Provisioned เลยครับ ตัวเลข RPU ตัวเดียวกำหนดทั้งสองอย่างพร้อมกัน</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1015/0*IGXIR2sgiN3WJyyZ" /></figure><p>สิ่งที่เราตั้งได้จริงๆ เรียกว่า Base capacity คือระดับ RPU ที่ Workgroup ของเราวิ่งอยู่เป็นค่าเริ่มต้น แล้วพอเวลามี Query ที่ต้องการทรัพยากรมากขึ้น ตัว Redshift ก็จะ Scale ขึ้นให้เองอัตโนมัติ แล้วค่อยลดกลับมาที่ Base เหมือนเดิมเมื่องานเสร็จ ตอนนี้ช่วงที่ตั้งได้กว้างมากตั้งแต่ 4 ไปจนถึง 1024 RPU เลยครับ (ขึ้นอยู่กับ Region ด้วยนะ บาง Region ยังไม่รองรับค่าต่ำสุดแบบนี้ และส่วน RPU ถ้ากังวลว่า RPU จะ scale เกินไปสามารถตั้งค่า Limit ได้เช่นกัน)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/0*jXJuDU2hOG8fTYpM" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/809/0*dwT87AUEthsub2Y2" /></figure><h3>สูตรคิดเงินง่ายๆ ที่ต้องจำให้ขึ้นใจ</h3><p>ตัว Compute ของ Serverless จะคิดเงินแบบ Per-second โดยมีขั้นต่ำอยู่ที่ 60 วินาทีทุกครั้งที่ Warehouse ถูกเรียกใช้งาน ถ้าไม่มี Query วิ่งเลยก็ไม่เสียตังค์ครับ ส่วนสูตรที่อยู่เบื้องหลังทุกอย่างคือ</p><blockquote>Cost = RPU x ชั่วโมงที่ Active x Rate ต่อ RPU-ชั่วโมง</blockquote><p>ถ้าอยู่ที่ US East (N. Virginia) Rate แบบ On-demand จะอยู่ที่ $0.375 ต่อ RPU-ชั่วโมง ซึ่งตัวเลขนี้เปลี่ยนได้ตามแต่ละ Region และตามเวลา อันนี้แนะนำให้เช็คหน้า Pricing จริงก่อนเอาไปประเมินงบจริงๆนะครับ อย่าเพิ่งจำตัวเลขไปใช้ตรงๆ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/565/0*Hk-pKnKQupR4xLGu" /></figure><p>ลองดูตัวอย่างจริงจากหน้า Pricing ของ AWS เองก็ได้ครับ สมมติมี Job ที่รันด้วย 128 RPU วันละ 13 รอบ รอบละ 10 นาที 30 วินาที รวมเวลา Active ทั้งวันคือ 8,190 วินาที (2.275 ชั่วโมง) พอเอาเข้าสูตรจะได้ค่าใช้จ่ายวันละ $109.20 พอดี หรืออีกตัวอย่างที่ซับซ้อนขึ้น เป็น Dashboard app ที่ตั้ง Base ไว้ 64 RPU แต่ช่วงเช้าและบ่ายมีคน Query เยอะจน Scale ขึ้นไปถึง 192 RPU และ 128 RPU ตามลำดับ พอรวมทั้งวันแล้วจะได้ 1,344 RPU-ชั่วโมง คิดเป็นเงินวันละ $504 ครับ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/357/0*xEDvBuVDaCoCYY6j" /></figure><p>จุดที่น่าสนใจจากตัวอย่างที่สองคือ ตัวเลขที่กำหนดค่าใช้จ่ายจริงๆไม่ใช่ Base RPU เพียงอย่างเดียว แต่เป็น “พื้นที่ใต้กราฟ” ของ RPU คูณเวลาที่ Active ต่างหาก Workgroup สอง Workgroup ที่ตั้ง Base เท่ากันเป๊ะ อาจมีบิลต่างกันมากได้เลยถ้า Scale ขึ้นไม่เท่ากัน</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/490/0*bvp3vz2CK07H36P5" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*v0DlHsfHeKHlz5H9" /></figure><h3>แล้วจะรู้ได้ไงว่าต้องตั้งกี่ RPU</h3><p>อันนี้แหละที่หลายคนติดปัญหาที่สุดครับ ทาง AWS มีแนวทางคร่าวๆให้ตามช่วงของโปรเจกต์ ถ้าเพิ่งเริ่มโปรเจกต์ใหม่ยังไม่รู้ Pattern การใช้งานที่แน่ชัด แนะนำให้เริ่มที่ค่าต่ำสุดของ Base RPU ในโซนของเราไปก่อน (ประมาณ 4 ถึง 24 RPU) แล้วค่อยสังเกตว่า Query ช้าหรือมีการ Spill ลง Disk ไหม ถ้าเจอปัญหาค่อยขยับ Base ขึ้นไปทีละสเต็ป</p><p>พอโปรเจกต์เริ่มโตขึ้นมาหน่อย แนะนำให้ขยับไป Base 32 RPU แล้วเปิด AI-driven scaling ที่ Price-performance target 50 หรือที่เรียกว่า Balanced เพราะ AI-driven scaling ต้องการ Base ขั้นต่ำ 32 RPU ถึงจะเปิดใช้ได้ครับ ส่วนถ้าเป็น Workload ที่นิ่งแล้ว ใช้งานมานานพอสมควร ก็แนะนำให้เริ่มที่ AI-driven scaling ตรงๆเลยที่ Target 50 แล้วค่อยขยับขึ้นไปทาง 75–100 ถ้ายังช้าอยู่ หรือขยับลงมาทาง 25 ถ้ารู้สึกว่าจ่ายแพงเกินความจำเป็น</p><p>ถ้าอยากได้ตัวเลขคร่าวๆอ้างอิงจากขนาดข้อมูลที่ Query สแกน ทาง AWS แนะนำประมาณนี้ครับ 32 RPU รองรับ Query ที่สแกนข้อมูลได้ราวๆ 100 GB, 64 RPU รองรับได้ราวๆ 250 GB และ 128 RPU รองรับได้ราวๆ 500 GB แต่ย้ำว่าเป็นแค่จุดเริ่มต้นให้ลองเทียบเท่านั้นนะครับ เพราะความต้องการจริงขึ้นกับรูปแบบ Query ด้วย ทั้ง Join, Aggregation หรือจำนวน Column ไม่ใช่แค่ขนาดข้อมูลอย่างเดียว</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*OD-7yb_F7en-9RPu" /></figure><h3>จุดที่หลายคนเข้าใจผิด ตั้ง RPU สูงไม่ได้แปลว่าแพงขึ้นเสมอไป</h3><p>ตรงนี้ผมว่าเป็นจุดที่คนงงกันเยอะที่สุดเลยครับ</p><p>เพราะโดยสัญชาตญาณเราจะคิดว่ายิ่งตั้ง RPU สูง ยิ่งต้องจ่ายแพงขึ้น แต่จริงๆแล้วเราจ่ายตาม RPU คูณเวลา ไม่ใช่ RPU เฉยๆ ลองดูตัวอย่างนี้ครับ Query เดียวกันเป๊ะ รันที่ 32 RPU ใช้เวลา 60 นาที กับรันที่ 128 RPU ใช้เวลาแค่ 15 นาที ทั้งสองแบบคิดเป็นเงินเท่ากันคือ $11.52 พอดี</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/163/0*qxsOLY3RmnnChUBE" /></figure><p>เพราะฉะนั้นการตั้ง RPU ต่ำเกินไปไม่ได้แปลว่าจะประหยัดเสมอไป ถ้ามันทำให้ Query กินเวลานานขึ้นจนรวมแล้ว RPU-ชั่วโมงเท่าเดิม แถมยังอาจเจอปัญหา Query Spill ลง Disk ซึ่งช้ากว่าการทำงานใน Memory ถึง 5 ถึง 10 เท่าอีกด้วย การประหยัดจะเกิดขึ้นจริงก็ต่อเมื่อ Workload ต้องการทรัพยากรน้อยจริงๆเท่านั้น ไม่ใช่แค่เราตั้งค่าต่ำไว้เฉยๆครับ</p><h3>แล้วเมื่อไหร่ควรใช้ Provisioned Reserved Instance แทน Serverless</h3><p>Serverless ไม่ได้ถูกที่สุดเสมอไปนะครับ ถ้า Workload ของเรานิ่งมากๆ ทำงานปริมาณเท่าเดิมตลอด 24 ชั่วโมง 7 วันแบบไม่ค่อยมี Variability เลย เช่นระบบรับข้อมูล IoT ที่ไหลเข้ามาต่อเนื่อง กรณีแบบนี้ตัว Provisioned cluster แบบ Reserved 3 ปี อาจถูกกว่า Serverless จริงๆ เพราะเราไม่ได้ใช้ความยืดหยุ่นแบบ On-demand ของ Serverless เลย</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MxoYLxcyDCFqv_fF" /></figure><p>ลองดูตัวอย่างเทียบราคาแบบ 8 RPU Serverless กับ Provisioned cluster 4 Node ที่ให้ Memory เท่ากันครับ ถ้าใช้แบบ On-demand ทั้งคู่ Serverless จะถูกกว่าราว 50% แต่พอ Provisioned ไป Reserve 1 ปีแบบ No upfront ราคาจะใกล้เคียงกันมาก ต่างกันแค่ประมาณ 5% เท่านั้น และถ้า Reserve ยาวไป 3 ปีเลย Provisioned จะถูกกว่า Serverless ถึง 35% เลยทีเดียว</p><blockquote>แต่ประเด็นคือ การ Reserve 3 ปีเป็นการผูกมัดระยะยาวมาก ซึ่งเทคโนโลยีเปลี่ยนเร็วทุกปี เพราะฉะนั้นควรมั่นใจจริงๆว่า Workload จะนิ่งแบบนี้ไปอีกนานก่อนตัดสินใจครับ</blockquote><p>อีกจุดหนึ่งที่อยากแทรกไว้ตรงนี้คือเรื่อง Cold start ครับ ถึงแม้ Serverless จะไม่คิดเงินตอน Idle เลยก็จริง แต่ถ้า Workgroup ว่างจนถูก Scale ลงไปเหลือศูนย์ พอมี Query แรกเข้ามาใหม่ ตัว Warehouse ต้อง Spin ขึ้นมาก่อน ซึ่งจากการทดสอบของหลายที่มักเจอ Latency เพิ่มขึ้นประมาณ 10 ถึง 30 วินาทีก่อนที่จะกลับมาทำงานความเร็วปกติ (ตัวเลขนี้ไม่ใช่ตัวเลขทางการจาก AWS โดยตรงนะครับ เป็นผลจากการทดสอบของ Third-party อีกที) ถ้าเป็น Batch job ที่รันตอนกลางคืนแบบไม่มีคนรอผลอยู่ อีก 10–30 วินาทีก็ไม่ใช่เรื่องใหญ่อะไร แต่ถ้าเป็น Dashboard ที่มีคนนั่งจ้องหน้าจอรอ Loading อยู่ อันนี้ควรทดสอบให้ดีก่อนตัดสินใจใช้ Serverless เต็มตัว หรือจะตั้ง Query เล็กๆรันเป็นระยะเพื่อ Keep warm ไว้ก็ช่วยได้เหมือนกันครับ ส่วน Provisioned cluster ที่รันอยู่ตลอดจะไม่เจอปัญหานี้เลย เพราะไม่มีสถานะ Idle ที่ต้อง Scale ลงศูนย์แบบ Serverless</p><h3>สรุปประมาณนี้ว่า</h3><p>ถ้าใครกำลังเริ่มโปรเจกต์ใหม่ หรือยังไม่รู้ Pattern การใช้งานที่ชัดเจน แนะนำให้เริ่มที่ Serverless ตั้ง Base RPU ต่ำๆไว้ก่อน แล้วค่อยสังเกตและปรับขึ้นตามจริง <strong>ไม่ต้องรีบเดา RPU สูงๆไว้ล่วงหน้า</strong> เพราะเสี่ยงจ่ายแพงเกินความจำเป็นโดยไม่จำเป็นเลยครับ ส่วนถ้าโปรเจกต์เริ่มโตแล้ว อยากได้ Performance ที่สม่ำเสมอโดยไม่ต้องมานั่งปรับ RPU เอง AI-driven scaling ที่ Target 50 คือคำตอบที่ตอบโจทย์ที่สุด</p><p>แต่ถ้า Workload ของใครนิ่งมากจริงๆ ทำงานเดิมๆตลอด 24 ชั่วโมงแบบไม่มี Peak ไม่มี Idle เลย อันนี้ <strong>ควรลองเทียบราคากับ Provisioned แบบ Reserved 3 ปีดูก่อน</strong> เพราะมีโอกาสสูงที่จะถูกกว่า Serverless จริงๆ</p><p>สุดท้ายอย่าลืมว่าตัวเลข Rate และช่วง RPU ที่ตั้งได้ เปลี่ยนแปลงได้เรื่อยๆตามที่ AWS อัปเดต ก่อนเอาไปทำ Estimate งบจริงจัง แนะนำให้ย้อนกลับไปเช็คหน้า Pricing อีกทีเสมอนะครับ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*p669WVipeTxm2t8D" /></figure><p><strong>REF</strong>:<br><a href="https://aws.amazon.com/redshift/pricing/">https://aws.amazon.com/redshift/pricing/</a> <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-billing.html">https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-billing.html</a> <a href="https://repost.aws/articles/ARPo2EYjL6ST-Cr9ysyPp07w/how-should-i-size-amazon-redshift-for-my-project">https://repost.aws/articles/ARPo2EYjL6ST-Cr9ysyPp07w/how-should-i-size-amazon-redshift-for-my-project</a></p><p><strong>Follow me here!<br></strong>Linkedin:<br><a href="https://www.linkedin.com/in/kriangsak-sumthong/">https://www.linkedin.com/in/kriangsak-sumthong/</a><br>Facebook page:<br><a href="https://www.facebook.com/profile.php?id=61563097228247">https://www.facebook.com/profile.php?id=61563097228247</a><br>Medium:<br><a href="https://medium.com/@puk.kriangsak">https://medium.com/@puk.kriangsak</a><br>Website:<br><a href="https://clouddatalabor.com/">https://clouddatalabor.com/</a></p><p><strong>Follow me here!<br></strong>Linkedin:<br><a href="https://www.linkedin.com/in/kriangsak-sumthong/">https://www.linkedin.com/in/kriangsak-sumthong/</a><br>Facebook page:<br><a href="https://www.facebook.com/profile.php?id=61563097228247">https://www.facebook.com/profile.php?id=61563097228247</a><br>Medium:<br><a href="https://medium.com/@puk.kriangsak">https://medium.com/@puk.kriangsak</a><br>Website:<br><a href="https://clouddatalabor.com/">https://clouddatalabor.com/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4cd56b0cf7ba" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Data Quality in Lakehouse: มาลองใช้งาน Deequ ตรวจสอบ Data Quality บน AWS Lakehouse]]></title>
            <link>https://medium.com/@puk.kriangsak/data-quality-in-lakehouse-%E0%B8%A1%E0%B8%B2%E0%B8%A5%E0%B8%AD%E0%B8%87%E0%B9%83%E0%B8%8A%E0%B9%89%E0%B8%87%E0%B8%B2%E0%B8%99-deequ-%E0%B8%95%E0%B8%A3%E0%B8%A7%E0%B8%88%E0%B8%AA%E0%B8%AD%E0%B8%9A-data-quality-%E0%B8%9A%E0%B8%99-aws-lakehouse-fbeaefc1e095?source=rss-c50d774af4fc------2</link>
            <guid isPermaLink="false">https://medium.com/p/fbeaefc1e095</guid>
            <category><![CDATA[clouddatalabor]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[data-quality]]></category>
            <dc:creator><![CDATA[Kriangsak Sumthong]]></dc:creator>
            <pubDate>Wed, 19 Aug 2026 18:02:02 GMT</pubDate>
            <atom:updated>2026-08-19T18:02:02.306Z</atom:updated>
            <content:encoded><![CDATA[<p>ทำความรู้จักกับ Deequ และเมื่อเทียบกับ AWS Glue DQ แล้ว มาลองใช้งานกับ Iceberg บน EMR กันเถอะ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3Wc6SXrWJ_IJNQ3_" /></figure><h3>Intro</h3><p>เคยไหมครับที่เขียน Pipeline ดึงข้อมูลเข้า Data Lake ไปเรื่อย ๆ จนวันหนึ่งมี Dashboard พังเพราะจู่ ๆ ก็มีค่า Null โผล่มาในคอลัมน์ที่ไม่ควรมี Null เลย หรือแย่กว่านั้นคือไม่มีใครรู้ตัวจนกว่าฝั่ง Business จะมาทักว่าตัวเลขดูแปลก ๆ</p><p>ปัญหานี้ไม่ใช่เรื่องใหม่หรอกครับ แต่บน Data Lakehouse มันจะยิ่งเกิดง่ายกว่า Data Warehouse แบบดั้งเดิมมาก เพราะ Schema เปลี่ยนได้ตลอดเวลา มีทั้ง Batch Job และ Streaming Job หลายตัวเขียนเข้าตารางเดียวกัน แถมตอนเขียนข้อมูลก็แทบไม่มีการบังคับ Constraint เหมือนฐานข้อมูลแบบเดิมเลยด้วยซ้ำ วันนี้เลยอยากพาไปรู้จักกับ Deequ เครื่องมือ Data Quality จาก Amazon เทียบให้ดูกับ AWS Glue Data Quality ที่หลายคนอาจสับสนว่ามันคือของคนละตัวกัน แล้วปิดท้ายด้วยการลองรัน Deequ กับตาราง Iceberg บน EMR จริง ๆ กันเลยครับ</p><h3>Data Quality สำคัญยังไง</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*LQcpjH9FWDmaoHuA" /></figure><p>มิติหลัก ๆ ที่เราใช้วัด Data Quality กันก็หนีไม่พ้น Completeness (ข้อมูลครบไหม มี Null เยอะไหม), Uniqueness (มีข้อมูลซ้ำไหม), Validity (ค่าที่เก็บอยู่ในขอบเขตที่ควรจะเป็นไหม), Consistency (ข้อมูลจาก Source ต่างกันขัดแย้งกันไหม) และ Timeliness (ข้อมูลมาตรงเวลาที่ควรจะเป็นไหม) ครับ ฟังดูเป็นเรื่องพื้นฐาน แต่พอ Data มันไหลเข้ามาเป็น Pipeline อัตโนมัติทุกวัน การจะมานั่งเช็คด้วยตาหรือรัน Query สุ่ม ๆ มันไม่ Scale เลยครับ นี่แหละคือจุดที่ Deequ กับ AWS Glue Data Quality เข้ามาช่วยกันดีกว่า</p><p>Deequ คืออะไร</p><blockquote><em>Deequ is a library built on top of Apache Spark for defining “unit tests for data”</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*jFbTbuQX5lt2eWmz" /></figure><p>พูดง่าย ๆ Deequ ก็คือ Library โอเพนซอร์สจาก Amazon ที่เอาไว้เขียน “Unit Test ให้ข้อมูล” นั่นเองครับ ตัว Engine เขียนด้วย Scala แล้วรันบน Apache Spark โดยตรง ส่วนถ้าใครถนัด Python ก็มี PyDeequ เป็นตัว Wrapper ให้เรียกใช้งานได้เหมือนเดิมโดยที่ Engine เบื้องหลังยังเป็นตัวเดียวกันครับ</p><p>โครงสร้างของ Deequ แบ่งเป็นสี่ส่วนหลัก ๆ ที่เราจะได้ใช้กันในบทความนี้ ได้แก่</p><ul><li><strong>Analyzer / AnalysisRunner</strong> คำนวณ Metric พื้นฐานของข้อมูล เช่น จำนวน Row, Completeness ของแต่ละคอลัมน์, ค่าเฉลี่ย</li><li><strong>Check / VerificationSuite</strong> ประกาศกฎที่ข้อมูลต้อง “ผ่าน” แล้วรันตรวจจริง ได้ผลลัพธ์เป็น Pass หรือ Fail แบบตรงไปตรงมา</li><li><strong>ConstraintSuggestionRunner</strong> ให้ Deequ ช่วย Profile ข้อมูลแล้วเดา Rule ที่น่าจะเหมาะให้เราแบบอัตโนมัติ ไม่ต้องนั่งคิดเองทุกกฎ</li><li><strong>Metrics Repository</strong> เก็บผลลัพธ์ย้อนหลังไว้ดู Trend ของคุณภาพข้อมูลตามเวลา</li></ul><h3>แล้ว AWS Glue Data Quality ล่ะ ต่างกันตรงไหน</h3><p>อันนี้คือจุดที่คนมักเข้าใจผิดกันบ่อยครับ หลายคนคิดว่า Deequ กับ AWS Glue Data Quality เป็นคนละตัว แต่จริง ๆ แล้ว <strong>AWS Glue Data Quality ถูกสร้างขึ้นบน Deequ โดยตรง</strong> ครับ พูดง่าย ๆ คือ Glue DQ เอา Engine ของ Deequ มาห่อเป็นบริการ Managed Service ที่ใช้งานง่ายขึ้น มี UI ให้กดคลิก มีภาษาเฉพาะของตัวเองเรียกว่า DQDL (Data Quality Definition Language) สำหรับเขียน Rule แบบไม่ต้องเขียนโค้ด Spark เอง แถมยังมี ML-based Anomaly Detection และปุ่ม Recommend Rule ที่ช่วยแนะนำกฎให้แบบสองคลิกจบ ซึ่งพอเข้าใจแบบนี้แล้วคำถามที่ถูกต้องจึงไม่ใช่ “จะเลือก Deequ หรือ Glue DQ ดี” แต่เป็น “จะเข้าถึง Engine ตัวเดียวกันนี้แบบ Raw Code หรือแบบ Managed Service ดีมากกว่าครับ”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qwsLScXnfcQ8wc8T" /></figure><h4>ความเหมือนที่แตกต่าง</h4><ul><li><strong>การควบคุม (Control)</strong>: Deequ เขียนโค้ดเองได้เต็มที่ ผูก Logic ซับซ้อนแค่ไหนก็ได้ ส่วน Glue DQ ถูกจำกัดด้วยภาษา DQDL ที่ทำได้ตาม Rule ที่รองรับเท่านั้น</li><li><strong>ที่รัน</strong>: Deequ รันได้ทุกที่ที่มี Spark ไม่ว่าจะ EMR, Glue Job, หรือ Databricks ส่วน Glue DQ ผูกอยู่กับ AWS Glue โดยเฉพาะ</li><li><strong>โมเดลค่าใช้จ่าย</strong>: Deequ ฟรีเพราะเป็นโอเพนซอร์ส แต่คุณต้องจ่ายค่า Compute เอง ส่วน Glue DQ คิดเงินตาม DPU ที่ใช้รันแบบ Managed Service</li><li><strong>การรองรับ Iceberg</strong>: Glue DQ รองรับตาราง Iceberg, Delta Lake, Hudi ที่จัดการผ่าน Lake Formation ได้ตรง ๆ ในขณะที่ Deequ จะรองรับ Iceberg ผ่าน Spark DataFrame ธรรมดา ต้อง Config Catalog เองก่อน</li><li><strong>เหมาะกับใคร</strong>: ถ้ากำลัง Prototype, อยากผูกเข้ากับ Pipeline ที่มี Logic เฉพาะทาง หรือทำงานใน Jupyter Notebook อยู่แล้ว Deequ จะยืดหยุ่นกว่า แต่ถ้าอยากได้ระบบ Managed ที่ดูแล Infra น้อยลง มี UI ให้ทีมที่ไม่ถนัดโค้ดใช้งานได้ Glue DQ จะตอบโจทย์กว่าครับ</li></ul><p>พอเห็นภาพเปรียบเทียบกันแล้ว มาลองของจริงกันดีกว่าครับ คราวนี้จะพาไปตั้งค่า EMR ให้รองรับ Iceberg ผ่าน Glue Catalog แล้วรัน Deequ ตรวจสอบข้อมูลบนตารางนั้นผ่าน Jupyter Notebook กันเลย</p><h3>ตั้งค่า EMR ให้พร้อมใช้ Iceberg และ Deequ</h3><p>ก่อนอื่นต้องบอกก่อนว่า EMR ตั้งแต่เวอร์ชัน 6.5.0 เป็นต้นมารองรับ Iceberg แบบ Native อยู่แล้วครับ ไม่ต้องยุ่งกับ Bootstrap Action เพื่อลง Jar เองเหมือนสมัยก่อน แค่เปิด Classification iceberg-defaults ตอนสร้าง Cluster เท่านั้นเอง</p><pre>[<br>  {<br>    &quot;Classification&quot;: &quot;iceberg-defaults&quot;,<br>    &quot;Properties&quot;: { &quot;iceberg.enabled&quot;: &quot;true&quot; }<br>  },<br>  {<br>    &quot;Classification&quot;: &quot;spark-defaults&quot;,<br>    &quot;Properties&quot;: {<br>      &quot;spark.sql.catalog.glue_catalog&quot;: &quot;org.apache.iceberg.spark.SparkCatalog&quot;,<br>      &quot;spark.sql.catalog.glue_catalog.catalog-impl&quot;: &quot;org.apache.iceberg.aws.glue.GlueCatalog&quot;,<br>      &quot;spark.sql.catalog.glue_catalog.io-impl&quot;: &quot;org.apache.iceberg.aws.s3.S3FileIO&quot;,<br>      &quot;spark.sql.catalog.glue_catalog.warehouse&quot;: &quot;s3://BUCKET-NAME/iceberg-warehouse/&quot;,<br>      &quot;spark.sql.defaultCatalog&quot;: &quot;glue_catalog&quot;,<br>      &quot;spark.sql.extensions&quot;: &quot;org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions&quot;,<br>      &quot;spark.jars&quot;: &quot;s3://BUCKET-NAME/jars/deequ-2.0.7-spark-3.5.jar&quot;,<br>      &quot;spark.yarn.appMasterEnv.SPARK_VERSION&quot;: &quot;3.5&quot;,<br>      &quot;spark.executorEnv.SPARK_VERSION&quot;: &quot;3.5&quot;<br>    }<br>  }<br>]</pre><p>จุดสำคัญอยู่ที่ spark.sql.catalog.glue_catalog ครับ เรากำลังบอก Spark ว่าให้ใช้ AWS Glue Data Catalog เป็น Catalog ของ Iceberg โดยตั้งชื่อ Catalog นี้ว่า glue_catalog ส่วนบรรทัดสุดท้ายคือการใส่ Jar ของ Deequ เข้าไปในเครื่อง Spark เลย ตั้งแต่ตอน Cluster เริ่มทำงาน จะได้ไม่ต้อง Config อะไรเพิ่มตอนอยู่ใน Notebook อีก</p><p>ส่วน pydeequ เป็น Python Package ที่ต้องลงแยกผ่าน Bootstrap Action เพราะมันไม่ใช่ Jar ที่ Spark โหลดเองได้ ต้องให้มีอยู่บนทุก Node ของ Cluster</p><pre>set -euo pipefail<br>PYDEEQU_VERSION=&quot;${PYDEEQU_VERSION:-1.4.0}&quot;<br># pydeequ installs fine with the image&#39;s stock pip.<br>sudo pip3 install &quot;pydeequ==${PYDEEQU_VERSION}&quot;<br>sudo yum reinstall -y python3-dateutil<br>echo &quot;pydeequ installed:&quot;<br>pip3 show pydeequ | grep -E &quot;^(Name|Version)&quot;</pre><p>จากนั้นก็สั่ง Create Cluster ผ่าน AWS CLI พร้อมเปิด Application JupyterHub ไว้เลย จะได้มี Notebook ให้เปิดใช้งานได้ทันทีที่ Cluster พร้อม</p><pre>aws emr create-cluster \<br>  --name &quot;deequ-iceberg-demo&quot; \<br>  --release-label emr-7.2.0 \<br>  --applications Name=Hadoop Name=Spark Name=JupyterHub Name=Livy \<br>  --configurations file://01_emr-configurations.json \<br>  --use-default-roles \<br>  --ec2-attributes SubnetId=subnet-xxxxxxxx,KeyName=your-ec2-keypair \<br>  --instance-type m5.xlarge \<br>  --instance-count 3 \<br>  --bootstrap-actions Path=s3://YOUR-BUCKET/bootstrap/bootstrap-pydeequ.sh \<br>  --log-uri s3://YOUR-BUCKET/emr-logs/ \<br>  --region us-east-1</pre><p>พอ Cluster ขึ้นสถานะ WAITING แล้ว ก็เปิด JupyterHub ผ่าน https://&lt;master-public-dns&gt;:9443 ได้เลยครับ</p><h3>มาเขียน Notebook ตรวจข้อมูลกันจริง ๆ</h3><p>เริ่มจากสร้าง Spark Session แบบธรรมดา เพราะ Config ทั้งหมดถูกฝังไว้ที่ระดับ Cluster ตั้งแต่ต้นแล้ว ไม่ต้องมานั่ง Config ซ้ำใน Notebook อีก (ต่อจากอันนี้จะเป็น Screenshot จาก jupyter notebook ครับ โค้ดสามารถดูได้ที่ Github repo ที่อยู่ด้านล่างสุด)</p><blockquote><em>ในรูปอาจจะมีชื่อ Bucket หรือ Account ติดไปด้วย แต่ไม่ต้องด่าผมนะครับ เป็น Account ส่วนตัว แล้วก็หลังจากเขียน Blog ผมก็ลบหมดเลย 😎</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/0*NssVI7QBZ5I_zNIP" /></figure><p>ต่อมาลองสร้างตาราง Iceberg ตัวอย่างชื่อ orders ผ่าน glue_catalog โดยจงใจใส่ข้อมูลที่มีปัญหาปนเข้าไปด้วย เช่น customer_id เป็น Null, order_id ซ้ำกัน และ amount ติดลบ เพื่อให้เห็นว่า Deequ ตรวจจับได้จริง</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/0*m3ANoW5UF6gp6QrW" /></figure><p>ก่อนจะเริ่มทำการ Check Data Quality ก็มาลองดู Data Profile กันก่อน เช่นพวก Average, Completeness และ Uniqueness เป็นต้น</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*v5thV_BJRru9bJQF" /></figure><p>จากนั้นก็มาถึงส่วนหลักครับ ประกาศ Check แล้วรัน VerificationSuite ตรวจตารางนี้</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4iTVoG2SRRZQmDha" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Sv6gMkrq1zWgE0pq" /></figure><p>รันแล้วจะเห็นเลยครับว่า isComplete(&quot;customer_id&quot;), isUnique(&quot;order_id&quot;) และ isNonNegative(&quot;amount&quot;) ขึ้น Failure ตามที่เราจงใจใส่ปัญหาไว้ตั้งแต่แรก</p><p>ส่วนใครขี้เกียจนั่งคิด Rule เองทั้งหมด ก็ให้ Deequ ช่วย Suggest ให้ได้เหมือนกัน ผ่าน ConstraintSuggestionRunner ซึ่งแนวคิดนี้คล้ายกับปุ่ม Recommend Rule ของ Glue DQ เลยครับ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/0*zabh79KkJndcBZb-" /></figure><p>แต่ที่น่าสนใจกว่านั้นคือพอเป็นตาราง Iceberg เราสามารถ Append ข้อมูลชุดใหม่เข้าไปแล้วรัน Check เดิมซ้ำเพื่อจับ Regression ของคุณภาพข้อมูลได้ทันที</p><p>โดยดู Snapshot History ของ Iceberg ประกอบไปด้วยว่า Snapshot ไหนที่ทำให้คะแนนตก ซึ่งเป็นจุดที่ Deequ กับ Iceberg เข้ากันได้ดีกว่า Flat File ทั่วไปมากครับ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/0*GnEFRV8qJpFrBg1d" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-3oSB0JGaCHlEM9_" /></figure><h3>สรุป</h3><p>Deequ กับ AWS Glue Data Quality เป็น Engine เดียวกันที่ให้เข้าถึงคนละแบบครับ ถ้ากำลังอยู่ในช่วง Prototype, อยากผูก Logic เฉพาะทางเข้ากับ Pipeline ที่มีอยู่แล้ว หรือทำงานบน Jupyter Notebook เป็นหลักอยู่แล้ว <strong>แนะนำให้ใช้ Deequ ตรง ๆ ผ่าน EMR</strong> เพราะควบคุมได้เต็มที่และไม่มีค่าใช้จ่ายเพิ่มจากตัว Engine เอง แต่ถ้าทีมไม่อยากดูแล Infra เอง อยากได้ UI ให้คนที่ไม่ถนัดโค้ดมาช่วยตั้ง Rule ได้ หรือมีตาราง Iceberg ที่จัดการผ่าน Lake Formation อยู่แล้ว <strong>Glue Data Quality จะสะดวกกว่ามาก</strong> เพราะมันคือ Deequ ตัวเดิมที่ห่อให้ใช้ง่ายขึ้นนั่นเองครับ</p><p>**แล้วก็ต่อให้ไม่ได้รันบน Service ของ AWS ก็สามารถนำ <strong>Deequ</strong> ไปใช้กับ Spark Cluster อื่นๆ ได้เช่นกันนะครับ😇</p><p>ส่วนเรื่อง Iceberg เองก็เป็นตัวช่วยสำคัญที่ทำให้เรื่อง Data Quality สนุกขึ้นไปอีกขั้น เพราะมี Snapshot History ให้ย้อนดูได้ว่า Data Quality เริ่มเน่าไปตอนไหน</p><p>แถมตัวอย่างจาก AWS Production Deployment:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*oD7E3xYkiuhkk_Gl" /></figure><p>Github repo:</p><p><a href="https://github.com/kriangsak-puk/clouddatalabor-demo-aws-deequ-emr">GitHub - kriangsak-puk/clouddatalabor-demo-aws-deequ-emr: Deequ + Iceberg on EMR - one-script demo</a></p><p>ref:<br><a href="https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-iceberg-use-spark-cluster.html">https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-iceberg-use-spark-cluster.html</a><br><a href="https://github.com/awslabs/python-deequ">https://github.com/awslabs/python-deequ</a> <a href="https://docs.aws.amazon.com/glue/latest/dg/glue-data-quality.html">https://docs.aws.amazon.com/glue/latest/dg/glue-data-quality.html</a></p><p><strong>Follow me here!<br></strong>Linkedin:<br><a href="https://www.linkedin.com/in/kriangsak-sumthong/">https://www.linkedin.com/in/kriangsak-sumthong/</a><br>Facebook page:<br><a href="https://www.facebook.com/profile.php?id=61563097228247">https://www.facebook.com/profile.php?id=61563097228247</a><br>Medium:<br><a href="https://medium.com/@puk.kriangsak">https://medium.com/@puk.kriangsak</a><br>Website:<br><a href="https://clouddatalabor.com/">https://clouddatalabor.com/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fbeaefc1e095" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ลองใช้ Open Knowledge Format (OKF) กับ BigQuery | จะทำให้ AI Agent เก่งขึ้นจริงหรือเปล่า?]]></title>
            <link>https://medium.com/@puk.kriangsak/%E0%B8%A5%E0%B8%AD%E0%B8%87%E0%B9%83%E0%B8%8A%E0%B9%89-open-knowledge-format-okf-%E0%B8%81%E0%B8%B1%E0%B8%9A-bigquery-%E0%B8%88%E0%B8%B0%E0%B8%97%E0%B8%B3%E0%B9%83%E0%B8%AB%E0%B9%89-ai-agent-%E0%B9%80%E0%B8%81%E0%B9%88%E0%B8%87%E0%B8%82%E0%B8%B6%E0%B9%89%E0%B8%99%E0%B8%88%E0%B8%A3%E0%B8%B4%E0%B8%87%E0%B8%AB%E0%B8%A3%E0%B8%B7%E0%B8%AD%E0%B9%80%E0%B8%9B%E0%B8%A5%E0%B9%88%E0%B8%B2-6d24f134a3c8?source=rss-c50d774af4fc------2</link>
            <guid isPermaLink="false">https://medium.com/p/6d24f134a3c8</guid>
            <category><![CDATA[google-okf]]></category>
            <category><![CDATA[open-knowledge-format]]></category>
            <category><![CDATA[bigquery]]></category>
            <dc:creator><![CDATA[Kriangsak Sumthong]]></dc:creator>
            <pubDate>Tue, 11 Aug 2026 06:47:08 GMT</pubDate>
            <atom:updated>2026-08-11T06:50:02.211Z</atom:updated>
            <content:encoded><![CDATA[<p>OKF — Open Knowledge Format การเติมเต็มบริบท (Context) จะช่วย AI Agent ได้แค่ไหนกัน?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KSCrVo4pKX6gF4gB2QAMDg.png" /><figcaption>How to let your AI know — generated by GPT image2</figcaption></figure><h3>Introduction</h3><p>ที่ผ่านมาเราก็ต่างมี Use case ของ AI Agent ออกมาเรื่อยๆ ทั้งในด้าน personal AI Agent หรือ AI ในองค์กรต่างก็มีเป้าหมายคนละแบบ อย่างใน Personal use ก็อาจจะเป็นเรื่อง Agent ที่เอามาทำ second brain หรือ เอาไปจัดการงานบางอย่างให้เป็น Automate — ส่วนในองค์กรก็เป็นการใช้ HR agent ถามตอบเกี่ยวกับกฎ ระเบียบต่างๆ หรือเอาไปใช้ถามตอบเกี่ยวกับข้อมูลขององค์กร ไม่ว่า Data ที่อยู่ใน Database หรือ Data warehouse.</p><p>แต่อย่างที่รู้ AI มันเก่งนะ แต่ปัญหาก็คือ AI สำหรับถามตอบข้อมูลที่เป็นข้อมูลภายในนั้น AI จะยังดึงข้อมูลไม่ค่อยแม่นยำเท่าไหร่ — ในปัจจุบันที่เราไม่ต้องมาห่วงเรื่อง AI เขียนโค้ดเท่าไหร่แล้ว ไม่ว่าจะเป็น SQL PYTHON etc… <br>แล้วทำไมมันถึงไม่แม่นยำละ? ก็เพราะ AI ขาดบริบท(Context) ยังไงล่ะ</p><blockquote>บริบท(Context) — สภาพแวดล้อมที่เกี่ยวข้องและมีผลต่อการประมวลผลข้อมูลต่างๆ | ปัจจุบัน Context มีความสำคัญมากถึงขนาดว่า อาจจะกำลังมี Context engineer แล้วด้วย.</blockquote><p>สาเหตุเกิดจากว่า AI ไม่รู้ว่าหน้าตาข้อมูลของเรา หน้าตาเป็นยังไง ไม่ว่าจะเป็น Table description, Table schema หรือ Path endpoint ต่างๆ ซึ่ง Context ของเหล่านี้สำคัญมากเลยครับ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kZIkHXmtV-tc8vyq-hEUQQ.png" /><figcaption>Example of Contexts — generated by GPT image2</figcaption></figure><h3>OKF — Open Knowledge Format</h3><p>ด้วยการพัฒนา AI Foundation Models ในตอนนี้พัฒนาได้เก่งขึ้นเรื่อยๆ แต่เพราะการขาด Context(จากนี้ขอเขียนคำนี้เป็น eng นะครับ) ทำให้ AI ที่เก่งนั้นไม่สามารถทำงานได้อย่างเต็มที่ อย่างการบอกให้ AI ไปทำการสรุปหรือวิเคราะห์ข้อมูลก็ทำได้ยากที่จะแม่นยำ นี้แหละคือหนึ่งในแนวทางที่ Google นำเสนอเพื่อทำให้ Knowledge และ Metadata สามารถถูกนำไปใช้โดยทั้งมนุษย์และ AI Agent ได้ง่ายขึ้น ก็คือ Open Knowledge Format (OKF)</p><h4>OKF — Open Knowledge Format คืออะไร?</h4><p>อย่างที่ได้เขียนไปว่าตัว OKF นั้นเกิดจากที่ทีม Google เห็นจุดที่ LLM ยังขาดเรื่อง Context จึงได้พัฒนา OKF ขึ้นมา โดยได้ไอเดียจาก <a href="https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f">LLM-wiki</a> ที่หลายๆคนเอาไปทำเป็น Second brain กัน โดยมี Obsidian เป็น Tools หลัก</p><p>โดย Google มีความตั้งใจว่าอยากให้ AI และ มนุษย์ อ่านและใช้งานได้ง่าย OKF จึงไม่ใช้การผูกติดกับ Software หรือ Vendor ไหน จะมีก็แค่ File ที่เป็น Bundle ของ ​OKF เท่านั้น ซึ่งประกอบไปด้วย</p><ul><li>File format เป็น Markdown เป็นหลัก อ่านง่าย และสามารถ Rendered ได้ดีที่ Github หรือ Git เจ้าอื่นๆ</li><li>Files เท่านั้น Google จะบอกว่าเราไม่ได้จำเป็นต้องลง Software หรืออะไรเพิ่มเติมไปให้มากมีแค่ Files ก็พอ</li><li>YAML frontmatter เป็นรูปแบบ Format ที่จะอยู่ในเกือบทุกๆไฟล์ เพื่อให้สามารถ Query ได้ง่าย โดย YAML นี้ประกอบไปด้วย type, title, description, resource, tags, and timestamp</li></ul><p>เพราะงั้นแล้วถ้าใครเคยได้ใช้ Obsidian มาบ้าง ก็น่าจะคุ้นเคยกันบ้างแล้ว แต่ไม่เคยก็ไม่เป็นอะไรไม่ได้ใช้่ยากเลยครับ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_ngMVsVBIcS1U4_D" /><figcaption>OKF ref by <a href="https://www.alphamatch.ai/blog/google-open-knowledge-format-okf-vs-rag-2026">https://www.alphamatch.ai/blog/google-open-knowledge-format-okf-vs-rag-2026</a></figcaption></figure><h4>การใช้งาน OKF — Open Knowledge Format</h4><p>การใช้งานนั้นไม่ได้ยากอะไรเลย เราแค่ต้องรู้จักกับ Folder structure ที่เป็นหัวใจหลักก่อนก็พอ</p><pre>#  Example of OKF bundle - ตัวอย่าง OKF bundle<br>sales/ # Parent folder โครงสร้าง Folder นอกสุด<br>├── index.md<br>├── datasets/<br>│ ├── index.md # index.md ตัวบอกว่าไฟล์ที่อยู่ใน Folder เดียวกัน คืออะไรบ้าง<br>│ └── orders_db.md # File ที่เป็นเนื้อหาเกี่ยวกับ Table นั้นๆ ไม่ว่าเป็น schema หรือ Description<br>├── tables/<br>│ ├── index.md<br>│ ├── orders.md<br>│ └── customers.md<br>└── metrics/<br>  ├── index.md<br>  └── weekly_active_users.md</pre><p>ทั้งหมดนี้จึงถูกเรียกได้ว่าเป็น OKF Bundle</p><h4>การ Extract dataset จาก BigQuery มาเป็น OKF bundle</h4><p>เมื่อเข้าใจโครงสร้าง (Folder Structure) ของ OKF แล้ว ขั้นตอนถัดมาคือการนำข้อมูลจริงจาก Database หรือ Data Warehouse อย่าง <strong>BigQuery</strong> มาสร้างเป็น OKF Bundle เพื่อให้ AI Agent ได้เรียนรู้ context ของตาราง Schema และ Column Descriptions ต่างๆ</p><p>เราสามารถใช้ Script reference_agent ที่มีอยู่ใน Github repo ของ Google ได้เลย เพื่อนำมา Generate bundle ออกมาโดยอัตโนมัติ เนื่องจาก OKF ยังอยู่ในส่วนของการพัฒนาและยังเป็นรูปแบบ Open Format ก็เลยไม่ได้มี Tools หรือ SDK ในตอนนี้ ส่วนวิธีใช้งานคือ:</p><pre># 1 ติดตั้ง reference_agent CLI<br>uv pip install &quot;git+https://github.com/GoogleCloudPlatform/knowledge-catalog.git#subdirectory=okf&quot;<br><br># หรือติดตั้งโดยการ clone repo มาก่อน<br>git clone https://github.com/GoogleCloudPlatform/knowledge-catalog.git<br>cd knowledge-catalog/okf<br>uv pip install -e &quot;.[dev]&quot;</pre><ul><li>หลังจากที่ติดตั้ง script ของ reference_agent แล้ว ตัว Script นี้จะเป็นการใช้งานในส่วนของดึงข้อมูลจาก Bigquery แล้วก็จะมีการใช้ AI ADK ในการ Enrich ข้อมูลของเรา</li><li>การทำงานของ reference_agent จะแบ่งออกเป็น <strong>2 Pass หลัก</strong> ที่ช่วยเติมเต็มทั้งข้อมูลโครงสร้าง (Structured Data) และข้อมูลบริบทภายนอก (Unstructured Context):<br>- <strong>Pass 1 (BQ Pass):</strong> ดึง Schema, Column Types, Table Name จาก BigQuery มาเป็นไฟล์ Markdown/YAML ตั้งต้น<br>- <strong>Pass 2 (Web Pass / Enrichment):</strong> ใช้ LLM อ่านข้อมูลจากเว็บนอก (seeds.txt) เพื่อนำ Business Definition หรือ Domain Context มาเติมใน Description และ Tags ให้อัตโนมัติ</li></ul><pre># script reference_agent จะเป็นการทำงานสองขั้นตอน<br>[ Data Source (BigQuery) ] ──(Pass 1: BQ Pass)──&gt;  [ Basic OKF Bundle ]<br>                                                              │<br>[ External Web / Docs ]    ──(Pass 2: Web Pass)─&gt; [ Reference Agent ]<br>                                                              │<br>                                             (Enrichment From external knowledge)<br>                                                              ▼<br>                                                   [ Enriched OKF Bundle ]<br># สิ่งที่ต้องทำก่อนก็คือ <br># เชื่อมต่อกับ GCP<br>gcloud auth application-default login<br><br># AI API key - แนะนำให้ใช้ free tier ของ Google AI studio - https://aistudio.google.com/<br>export GEMINI_API_KEY=****************</pre><ul><li>หลังจากทำด้านบนเสร็จแล้วเราจะสามารถทำขั้นตอนถัดไปได้นั้นก็คือการสร้าง bundle แล้ว</li></ul><pre># 2. Extract Metadata และ Schema จาก BigQuery Export มาเป็น OKF Bundle<br>uv run python -m reference_agent enrich \<br>    --source bq \<br>    --dataset &lt;project&gt;.&lt;dataset&gt; \<br>    --web-seed-file &lt;path/to/seeds.txt&gt; \<br>    --out ./bundles/&lt;name&gt;<br># web-seed-file คือไฟล์ที่จะบอก AI ว่าให้ไปเอาข้อมูลที่ไหนมาช่วย enrich ข้อมูลเพื่อเติมเต็มบริบทข้อมูลให้มากขึ้น<br># ตัวอย่างข้อมูลที่มีใน BQ เป็นข้อมูล Pokemon แล้วเราอยากได้บริบทจากเว็บ Pokemon มาเติม<br>cat &lt;&lt; &#39;EOF&#39; &gt; seeds.txt<br>https://pokeapi.co/docs/v2<br>https://bulbapedia.bulbagarden.net/wiki/Pokémon_data_structure<br>https://pokemondb.net/pokedex/all<br>EOF</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/790/1*CetdhqD7YZaH3v07aRHGaw.png" /><figcaption>OKF bundle หลังจากใช้คำสั่ง uv run python -m reference_agent enrich</figcaption></figure><ul><li>มาลองเทียบทั้งสองรูปว่า AI ได้ทำการ enrich ข้อมูลอะไร</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F4NmlrsW7UAly0y8qjJ-vQ.png" /><figcaption>ข้อมูล Table ที่ไม่มีอะไรเลยจาก Bigquery</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z73NdHI4uHre6RGY3Rer1g.png" /><figcaption>ข้อมูล frontmatter ที่มีการ enrich แล้ว</figcaption></figure><ul><li>ถ้าได้ดูข้อมูลใน Frontmatter ใน Markdown file แล้วจะเห็นว่าได้มีการเติมข้อมูลเพิ่มเข้าไปไม่ว่าจะเป็น Description, tag, source data และ อื่นๆอีก ทำให้เราได้ข้อมูลของ Table ครบถ้วนมากขึ้น</li></ul><p>ยังไม่พอ เจ้าตัว script reference_agent ยังมีหนึ่ง function ก็คือการสร้าง Interactive Visualization: OKF มีคำสั่ง visualize เพื่อแปลงทั้ง Bundle ให้กลายเป็น HTML file แบบ Interactive Force-directed Graph ทำให้ทั้งมนุษย์และ Agent มองเห็นความสัมพันธ์ระหว่างตาราง, Metrics และเอกสารอ้างอิงได้อย่างชัดเจน</p><pre><br># เลือก OKF bundle เพื่อสร้าง visualize<br>uv run python -m reference_agent visualize --bundle ./bundles/&lt;name&gt;</pre><p>แล้วเราก็จะได้ไฟล์ viz.html</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*hR-M835GW9vl9nPiWjZ29Q.png" /><figcaption>ไฟล์ viz.html หลังจากรันคำสั่ง reference_agent visualize</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I_xEmnCobTt0J1dpmPPhlg.png" /><figcaption>ภาพจากไฟล์ viz.html ประกอบไปด้วย dataset และ table</figcaption></figure><h4>ทดสอบให้ AI Agent Query ข้อมูลผ่าน Antigravity</h4><p>เมื่อเราได้ OKF Bundle มาแล้ว เรามาทดสอบว่า AI Agent จะสามารถใช้ Context จาก Bundle นี้ร่วมกับ <strong>Antigravity</strong> ในการแปลงคำถามภาษาธรรมชาติ (Natural Language) เป็น SQL Query แล้วไปดึงข้อมูลจริงได้แม่นยำขึ้นแค่ไหน</p><p><strong>Prompt ทดสอบ:</strong></p><blockquote>“ช่วย query ข้อมูล pokemon ที่เป็นเลขคู่”</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*djWAdLhm9fDmEEt8_Ca3XQ.png" /></figure><p><strong>การทำงานเบื้องหลัง (Behind the Scenes)</strong></p><ul><li>Context Traversal: Agent อ่าน index.md ใน OKF Bundle</li><li>Schema &amp; Rule Understanding: Agent ตรวจสอบ YAML Frontmatter และ Column Description ทำให้รู้ทันทีว่าต้อง Query อะไร</li><li>Execution via Antigravity: Agent สร้าง SQL และส่งคำสั่งไปรันบน BigQuery ผ่าน Antigravity Execution Environment</li></ul><p><strong>ผลลัพธ์:</strong> AI Agent สามารถสร้าง Query ได้ถูกต้องเกือบ 100% โดยไม่ต้องเดาชื่อ Column หรือ Schema แบบผิดๆ ถูกๆ อีกต่อไป</p><h3>สรุป (Conclusion)</h3><p>การเติมเต็มบริบท (Context) ด้วย <strong>Open Knowledge Format (OKF)</strong> ช่วยแก้ปัญหาจุดสำคัญของ AI Agent ได้อย่างน่าประทับใจ และประโยชน์อื่นๆได้อีกด้วย:</p><ul><li><strong>Standardized &amp; Portable:</strong> รูปแบบ Markdown + YAML ทำให้ไม่ยึดติดกับ Vendor เจ้าใดเจ้าหนึ่ง คนอ่านเข้าใจง่าย Agent นำไปใช้ต่อได้ทันที</li><li><strong>ช่วยลด Hallucination:</strong> เมื่อ Agent ได้รับ Schema Description และ Relationship ที่ชัดเจน การสร้าง SQL หรือ Code เพื่อ Query ข้อมูลจึงแม่นยำขึ้นอย่างเห็นได้ชัด (ไว้มีโอกาศจะทำ Benchmark)</li><li><strong>สามารถเขียนโดยคนหรือ AI:</strong> ไม่จำเป็นต้องผ่าน SDK หรือ Tools อะไร แล้วยังสามารถนำไปใช้ต่อกับ Obsidian ก็ทำได้</li><li><strong>Data Catalog Documentation</strong>: จัดทำ Data catalog เพื่อเป็นส่วนกลางในการแชร์ Metadata ให้กับทางทีมหรือ องค์กรได้ดีเช่นกัน</li></ul><p>นอกจากนี้แล้วตัว OKF เองก็สามารถนำไปใช้กับสิ่งอื่นๆได้อีกมากมาย บางคนเอาไปทำ RAG ก็มี(แต่เขาเอาไปดัดแปลงกันยังไงนี่สิ) แต่ถึงยังงั้นแล้วผมคิดว่าการที่มีบริบทเพิ่มเติมให้กับ AI Agent จะทำให้ความแม่นยำในการเข้าถึงข้อมูลดีขึ้นอย่างแน่นอน</p><p>*ตอนที่เขียนนี้ OKF มี version 0.2 แล้วนะครับ</p><p>REF: <a href="https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing">https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CmDtvQ8WoE6lMuE9uAeAnA.png" /></figure><p><strong>Follow me here!<br></strong>Linkedin:<br><a href="https://www.linkedin.com/in/kriangsak-sumthong/">https://www.linkedin.com/in/kriangsak-sumthong/</a><br>Facebook page:<br><a href="https://www.facebook.com/profile.php?id=61563097228247">https://www.facebook.com/profile.php?id=61563097228247</a><br>Medium:<br><a href="https://medium.com/@puk.kriangsak">https://medium.com/@puk.kriangsak</a><br>Website:<br><a href="https://clouddatalabor.com/">https://clouddatalabor.com/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6d24f134a3c8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Omnigent | Meta-Harness AI Agent]]></title>
            <link>https://medium.com/@puk.kriangsak/omnigent-meta-harness-ai-agent-30a4288ebf7c?source=rss-c50d774af4fc------2</link>
            <guid isPermaLink="false">https://medium.com/p/30a4288ebf7c</guid>
            <category><![CDATA[databricks]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[clouddatalabor]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Kriangsak Sumthong]]></dc:creator>
            <pubDate>Sat, 25 Jul 2026 17:58:15 GMT</pubDate>
            <atom:updated>2026-07-25T17:58:15.845Z</atom:updated>
            <content:encoded><![CDATA[<p>รวม Agentic coding ให้อยู่ในที่เดียวกันได้ยังไง และผมใช้มันแล้วเป็นยังไงบ้าง</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sGMsdYV6zeedCRKz" /></figure><p>ไหนใครมี Subscription เจ้า Agent coding (Claude code, Codex, Pi etc..) มากกว่า 1 ตัวบ้างยกมือหน่อยยยย</p><p>ผมแล้วหนึ่ง ซึ่งก็จะมีปัญหาที่คล้ายๆกันคือ บางทีเราอยากให้ Agent อีกเจ้าทำการ review ให้กับเรา แต่ทีนี้การจะทำแบบนั้น ก็ต้องผ่านหลายขั้นตอนเลยไม่ว่าจะเป็น การเขียนเป็น Markdown หรือส่งทั้ง Repo ให้ Agent ไปอ่านเอง เหล่านี้ล้วนเกิดปัญหามากมาย ยังไม่รวมถึงการที่เราอยากจะให้เพื่อนร่วมงานของเราทำงานต่อจากเราได้ด้วย</p><p>ผมผู้เขียนก็เลยได้ไปเจอ Open source ตัวหนึ่งที่ถูกพัฒนาโดย Databricks Data platform ที่มีชื่อเสียงมากมาย ได้ทำการปล่อยออกมาให้ได้ใช้กันฟรีๆเลยนั้นก็คือ</p><p><strong>Omnigent</strong> <strong>— a Meta-harness</strong></p><p>ปัจจุบันนี้ปี 2026 ปีที่มองไปทางไหนก็เจอแต่คนใช้ AI เขียนโค้ดให้ไม่ว่าจะเป็น Claude code, Codex หรือ Antigravity อื่นๆอีกเยอะมากมาย เขียนได้เป็นแถวเลยครับ ไม่ว่าจะของชาติไหนก็ตาม US หรือจีนก็มีให้เลือก</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*TgjkqaEZoWpgM-9y" /></figure><p>แต่ทีนี้การมีให้เลือกเยอะแบบนี้ก็มีปัญหาสำหรับบางคนอีก เช่นพอเวลามีบางค่ายที่มีการอัพเดท model ใหม่หรือ update agent harness ก็ต้องคอยตามไปเสมอ ทำให้บางคนเกิดมี subscription เยอะแยะมากมาย อย่างผู้เขียนก็มีทั้ง Claude, ChatGPT และ Google แต่ผู้เขียน sub แค่ 20 USD นะครับ เยอะกว่านี้ใช้ไม่คุ้ม งานหลักๆก็ไม่ค่อยได้โค้ดแล้ว</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BWl-JAkAWpBvgrsW" /></figure><p>อย่างที่หลายคนที่ใช้ Agentic coding อย่าง Claude code ก็น่าจะรู้อยู่แล้วว่าเราจะมีสิ่งที่คอยจะหยุดการทำงานของเรา นั้นก็คือ Usage Session อย่าง Claude ก็มี Usage Session รอบละ 5 ชั่วโมง ถ้าเต็มก็ต้องรอ แล้วการจะส่งงานไปทำต่อที่ Model อื่นๆก็ต้องใช้วิธีต่างๆมากมาย อย่างการให้ AI สรุป Session แล้วส่งต่อในรูปแบบ Handoff หรือรูปแบบอื่นๆที่ต่างคนต่างถนัดกันไป และยังไม่รวมถึงการ Collaboration หรือการทำงานร่วมกัน ลองนึกดูถ้าเราต้องพัฒนา Webapp อะไรบางอย่างในองค์กรแล้ว ถ้าเกิดเราอยากจะแชร์ Session ให้เพื่อนทำต่อก็ยากอีก(ไม่รวมมานั้งทำงานที่คอมเครื่องเดียวกัน)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1020/0*Iwkj_MO6uyolFzkQ" /></figure><h3>Omnigent</h3><p>Databricks เห็นว่าปัจจุบันมีการใช้ Agent coding ในบริษัทมีหลายตัวเหลือเกินและการทำงานร่วมกันก็ทำได้ยาก เพราะแต่ละ Model ก็มีความสามารถที่ต่างกันออกไป แต่ละ ​Model ก็เก่งไม่เหมือนกันอีก แบบนี้ก็เลยพัฒนา open source ตัวหนึ่งที่ชื่อว่า Omnigent</p><blockquote><em>Databricks คือใคร ถ้าใครไม่รู้จัก | Databricks คือ Data Platform ที่เป็นที่นิยมมากๆในงาน Data ไม่ว่าจะ AI หรือ Data pipeline ก็มีให้ได้ใช้หมดเลย</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*R03_voKsxScGHHwI" /></figure><p>Omnigent คืออะไร ก็คือ A Meta-Harness ทำหน้าที่เป็นตัวเชื่อม AI Agent เข้าด้วยกัน เปรียบเสมือนหน้าด่านประตูที่รับงานจากผู้ใช้ก่อน แล้วก็ส่งต่อไปที่ Harness Agent coding ที่ผุ้ใช้มีไม่ว่าจะเป็น Claude code, Codex หรือ อื่นๆที่รองรับ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*l6tgPM2pskj17y3Z" /></figure><p>แต่ก่อนไปลงรายละเอียดของ Omnigent ทำงานยังไง มารู้จักกับ Agent harness กันแบบไวๆกันก่อน</p><h3>Agent Harness</h3><p>Agent Harness คือ คือ Runtime System (Layer ที่อยู่ล้อมรอบ AI Model) ทำหน้าที่เป็นโครงสร้างควบคุมหลักที่เปลี่ยนให้ AI ทำงานได้อย่างมีประสิทธิภาพ</p><p>ตัวอย่างองค์ประกอบด้านต่างๆของ <strong>Agent Harness:</strong></p><ul><li><strong>Context Management (การจัดการบริบท):</strong> ควบคุมและป้อนข้อมูลที่จำเป็น เพื่อให้ AI เข้าใจบริบทของงานอย่างถูกต้อง</li><li><strong>Tool Calling (การเรียกใช้เครื่องมือ):</strong> เชื่อมต่อและสั่งการเครื่องมือหรือ API ภายนอก</li><li><strong>Memory System (ระบบความจำ):</strong> จัดเก็บและดึงข้อมูลที่เกี่ยวข้องกลับมาใช้ในการทำงาน</li><li><strong>Permission Control (การควบคุมสิทธิ์):</strong> กำหนดขอบเขตและความปลอดภัยในการเข้าถึงข้อมูลหรือดำเนินการต่างๆ</li><li><strong>Error Recovery (การจัดการข้อผิดพลาด):</strong> เฝ้าระวัง กู้คืนระบบ และแก้ไขปัญหาเมื่อกระบวนการทำงานเกิดข้อผิดพลาด</li><li><strong>Logging &amp; Observability (การติดตามและตรวจสอบ):</strong> บันทึกประวัติและตรวจสอบสถานะการทำงานของ Agent อย่างละเอียด</li><li><strong>Workflow Orchestration (การจัดลำดับขั้นตอน):</strong> ควบคุมและวางลำดับการทำงานทั้งหมดให้เป็นไปตามกระบวนการที่วางไว้</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/680/0*yjieeHHsa1HhmXCY" /></figure><p>ถ้าพูดแบบง่ายๆให้เข้าก็คือระบบที่ทำให้ AI model ทำงานได้อย่างตรงจุดมากขึ้น ถ้า Model ต้องการ Tool ไหนก็จะมี Harness นี่แหละคอยจัดการให้ เปรียบเทียบกับ คอมพิวเตอร์ก็คือ Operating System หรือก็คือ OS นั้นแหละครับ CPU RAM จะทำงานร่วมกันได้ยังไงเวลาจะทำอะไรซักทีหนึ่ง</p><p>ลองไปอ่านกันเพิ่มที่ <a href="https://claude.com/blog/harnessing-claudes-intelligence">https://claude.com/blog/harnessing-claudes-intelligence</a></p><h3>How Omnigent works behind the scenes</h3><p>มาดูกันต่อครับว่า Omnigent ทำงานยังไง หลังจากที่ทุกคนน่าจะพอเข้าใจแล้วกับคำว่า Agent Harness คืออะไร ทีนี้ก็มาดูการทำงานกัน</p><p>แต่ก่อนจะไป มาดูสิ่งทีต้องมีก่อนที่จะไปกันต่อ</p><ul><li>Python 3.12+</li><li>Node.js 22 LTS and npm</li><li>tmux</li></ul><blockquote><em>ในบทความนี้จะไม่ได้ลงลึกมาก จะเขียนในส่วนเบื้องต้นเท่านั้น</em></blockquote><p>Omnigent นั้นอย่างที่บอกว่าเป็น Meta Harness ที่จะทำงานก่อนที่จะส่งต่อให้ Agent อีกทีหนึ่ง โดย Omnigent จะทำตัวเป็นหน้ากากครอบ Agent อีกทีหนึ่ง ถ้าสมมุติว่าเราเลือกที่จะใช้งาน Claude code นั้น แค่กดคำสั่ง</p><pre>omni claude</pre><p>ก็จะได้หน้าต่าง claude code แบบปรกติที่ใช้งานเลย แต่ที่ต่างคือจะมี URL สำหรับหน้า UI Omnigent มาด้วย</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*W94ciZQozl92faiL" /></figure><p>ไม่เพียงแค่นี้ Omnigent จะมีหน้าต่าง UI เพิ่มเข้ามาด้วยพร้อมกับเก็บ Session ให้กับเรา ถ้าเป็นปรกติแล้วถ้าเราอยากจะกลับไปทำงานต่อใน session ก่อน ในตัว claude code นั้นเราต้องบันทึก session id เอง และ resume session เอาเอง แต่ Omnigent ทำให้เราสามารถใช้งานผ่านหน้า UI แล้วเลือก session ที่เราทำค้างไว้ได้เลยด้วย</p><blockquote><em>Omnigent จะมี UI สองแบบ แบบที่เกิดจากการเปิด Code agent ผ่าน terminal หน้า UI จะเปิดผ่าน website เป็นแบบ localhost หรืออีกแบบคือ Download จากหน้า website จะเป็น Desktop Application ที่ทำงานได้ทันทีไม่ได้ต้องทำผ่าน website แต่ทั้งหมดนี้ feature เดียวกัน</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/0*ETL4JIMR5X_kVVw9" /></figure><h3>Omnigent features</h3><p>ผมว่าการจะเข้าใจให้ง่ายขึ้นว่า Omnigent ทำอะไรได้บ้าง ผมว่ามาดู Feature กันทีละส่วนดีกว่า</p><ul><li>Coding Agent</li></ul><p>feature ที่เป็นการเรียกใช้งาน Agent ตามที่เราต้องตามที่เขียนไปก่อนหน้าไม่ว่าจะเป็น Claude code, Codex etc.. โดยที่ Omnigent จะเพิ่ม feature ในการทำงานและหน้า UI ให้</p><ul><li>Polly (Multi-AI Coding)</li></ul><p>Polly agent เป็น orchestrator ที่จะทำหน้าที่ทำความเข้าใจ task งาน ก่อนจะส่งงานต่อไปให้ Agent ตัวอื่นๆ เช่นให้ Claude code เขียนโค้ด และให้ Codex มารีวิวโค้ดให้ ตัว Polly Agent จะเป็นตัวตัดสินใจเอง ดูจากตัวอย่างด้านล่างจากการใช้</p><p>โดย Polly Agent นั้นจะทำงานได้โดยเราเลือกว่าจะเอาอะไรเป็น model ให้ Polly ใช้ถ้ามี Claude code เราก็ใช้ Claude SDK เป็นสมองให้ Polly Agent</p><p>ทั้งหมดนี้ทำให้เราสามารถใช้ Agent ด้วยกันได้ทันที ไม่ต้องไปเปิดปิด agent ใหม่</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/894/0*b_lE9u3OovsYTuB5" /></figure><ul><li>Debby (Brainstorming agent)</li></ul><p>Debby เป็น Agent ที่ทำงานโดยการเอา input ของผู้ใช้ไปให้ Agent ที่เรามีอย่างสมมุติผมมี Claude และ Codex ตัว Debby ก็จะเอา input ไปให้ทั้งสองตัวแล้วทำหน้าที่คนกลางโดยให้ Agent ทั้งสองตัวนั้น Debate กันไปเรื่อยๆจนกว่าจะได้ข้อสรุปกลับมาให้ผู้ใช้ เหมาะกับการวางแผนการทำงานก่อนที่จะนำไปพัฒนาจริงๆ</p><p>โดยตัวอย่างผมให้ Debate กันเรื่องชื่อเล่นผมเอง (เพื่อการทดสอบแบบไวๆ)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/0*_sNkqbrXBxzWMkhn" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/0*kXiwjTDun9ACZsB4" /></figure><ul><li>Collaborate from Anywhere</li></ul><p>Feature ที่ต้องทำการ deploy Omnigent ก่อน โดยต้องทำเป็น Image container แล้วก็ deploy โดยใน Document แนะนำไปใช้ Railway แต่ส่วนใครจะใช้อะไรก็ได้หมด</p><p>สาเหตุที่ต้อง deploy ขึ้นไปก่อนนั้นเพราะเราต้องการให้มีพื้นที่สำหรับเป็น sandbox ให้ Omnigent รวมไปถึงมี Database ที่เอาไว้เก็บ Session ต่างๆ</p><p>พอ Deploy ได้แล้ว ทีนี้ใครก็ตามที่เราอนุญาต จะสามารถเข้าไปใช้งานได้ทันที สามารถทำแบบ</p><p>Share a live session — ที่เพื่อนเราสามารถเห็นเราสั่งงาน Agent ได้เลย</p><p>Co-drive — เป็นการให้เพื่อนเรามาร่วมกันทำงานกับเราได้ อย่างเช่นมาแก้บัคบางอย่างที่เพื่อนเก่งในด้านนั้น เพียงแต่ว่าจะต้องใช้ Agent Credentials ของตัวเองมาเชื่อมต่อ</p><p>Fork — เหมือนกับการ Fork Git นั้นแหละเพียงแต่ว่าเพื่อนสามารถเอา Session เราไปทำต่อในพื่นที่ของตัวเองได้เลย</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*E8EXvEj8WfQ1R6_S" /></figure><h3>Summary — สรุปส่งท้าย</h3><p>Omnigent เป็น open source ที่ดีมากๆอีกตัวหนึ่งที่จะมาช่วยให้การใช้งาน AI Agent หลายๆค่ายนั้นสามารถทำงานร่วมกันได้อย่างดียิ่งขึ้น และอีกทั้งสามารถ Deploy ขึ้นไปใช้บน Cloud เพื่อรองรับการทำงานร่วมกันกับเพื่อนๆของเรา โดยไม่ต้องกังวลเรื่องที่จะต้องมาใช้งานที่เครื่องส่วนตัวเรา หรือจะต้องกังวลว่าจะส่งต่อ Session กันยังไงดี กลัวว่าส่งไปแล้วได้ข้อมูลไม่ครบ ครั้นจะไปเขียนเป็น Markdown แล้วส่งผ่าน Slack Team etc.. ก็กลัวขาดบางอย่างไป ก็ได้นี่แหละครับ Omnigent มาตอบโจทย์ตรงนี้</p><p>แค่นี้การพัฒนาอะไรขึ้นมา ก็สนุกได้อีกเยอะเลย😎</p><p>หวังว่าทุกคนที่อ่านจะได้อะไรกลับไปบ้างนะครับ ยังมี feature ที่ผมพูดไม่หมด ยังมีอีกเยอะมากแนะนำว่าดูใน Document อีกทีนะครับ</p><p>REF: <br><a href="https://omnigent.ai/">https://omnigent.ai</a><br><a href="https://github.com/omnigent-ai/omnigent">https://github.com/omnigent-ai/omnigent</a></p><p>Follow me here!<br>Linkedin:<br><a href="https://www.linkedin.com/in/kriangsak-sumthong/">https://www.linkedin.com/in/kriangsak-sumthong/</a><br>Facebook page:<br><a href="https://www.facebook.com/profile.php?id=61563097228247">https://www.facebook.com/profile.php?id=61563097228247</a><br>Medium:<br><a href="https://medium.com/@puk.kriangsak">https://medium.com/@puk.kriangsak</a><br>Website:<br><a href="https://clouddatalabor.com/">https://clouddatalabor.com/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=30a4288ebf7c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Can Amazon MWAA Serverless replace Amazon MWAA Provisioned?]]></title>
            <link>https://medium.com/@puk.kriangsak/can-amazon-mwaa-serverless-replace-amazon-mwaa-provisioned-ab0c570ce438?source=rss-c50d774af4fc------2</link>
            <guid isPermaLink="false">https://medium.com/p/ab0c570ce438</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[airflow]]></category>
            <dc:creator><![CDATA[Kriangsak Sumthong]]></dc:creator>
            <pubDate>Tue, 24 Feb 2026 18:42:52 GMT</pubDate>
            <atom:updated>2026-02-24T19:03:00.589Z</atom:updated>
            <content:encoded><![CDATA[<p>Airflow แบบ Serverless ที่ทาง AWS จัดมาให้ มันน่าใช้ไหมนะ เอามาแทน Provisioned ดีไหม?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P6As4c2oRVrvipsKbN6erw.png" /><figcaption>Generated by Gemini</figcaption></figure><p>ในโลกของ Data engineering ยังก็ไม่พ้นเรื่องของการทำ data pipeline แต่สิ่งที่มากไปกว่านั้นคือ Orchestrator ด้วย Orchestrator นั้นมีความสำคัญมาก! เพราะเราคงไม่มาสั่งการทำงานของ Data pipeline ด้วยตนเองทุกครั้งใช่ไหมครับ Automate pipeline คือสิ่งจำเป็น แต่เครื่องมือที่เป็น Orchestrator นั้นก็มีให้ใช้มากมายซะเหลือเกิน</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MQWpTfCy53EZi3in.png" /></figure><p>ถ้าจะเรียงรายชื่อออกมาก็มีทั้ง open source และ closed source อย่างใน Open source ก็จะมี Apache Airflow, Dagster หรือ Prefect แต่ที่เป็นที่นิยมมากๆเลยก็คงหนีไม่พ้น Apache Airflow</p><p>และส่วน Closed source นั้นก็มีหลากหลายรูปแบบที่อยู่ใน platform ต่างๆไม่ว่าจะเป็น Google cloud, Microsoft Azure, Amazon Web Services และประเภท Dataplatform อย่าง Databricks etc…</p><h4>การมาถึงของ AWS MWAA Serverless</h4><blockquote>Amazon Managed Workflows for Apache Airflow (MWAA)</blockquote><p>เมื่อปลายปี 2025 ทาง AWS ก็ได้ปล่อย service ใหม่นั้นก็คือ MWAA Serverless ขึ้นมาซึ่ง Concept ของ AWS MWAA Serverless ก็เพื่อให้เหล่า Data user ได้ใช้งานได้สะดวกมากขึ้นโดยไม่ต้องคอยกังวลเรื่องของการจัดการ Infrastructor</p><p>ซึ่งถ้าเป็นตัว Provisioned ที่ไม่ใช่ Serverless เวลาสร้าง Environment ขึ้นมาเบื้องหลังจะทำการสร้าง Infrastructor ขึ้นมาให้ด้วยซึ่งจะมี cost ในระหว่างเปิดทำงานอยู่ตลอด ต่อให้ไม่ได้ทำงานอะไรก็ตาม ก็จะมี cost อยู่ดี</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pPMsme6Oeb7b2CA2.png" /><figcaption>MWAA architecture</figcaption></figure><h4>MWAA is not only orchestrator in AWS.</h4><p>แต่ทีนี้ AWS ไม่ได้มี Orchestrator แค่ MWAA เท่านั้น ยังมี Step function ที่เป็นที่นิยมมากๆอยู่ด้วย แต่เอาละ เดี๋ยวจะเอาไว้เปรียบเทียบคราวหน้าครับ บทความนี้จะเน้น MWAA Serverless แต่ก่อนจะไปดูตัว Serverless เรามาดูตัว Provisioned ก่อนเป็นยังไง</p><p>แต่ช้าก่อน! ทบทวนเรื่อง Airflow นิดหนึ่ง Airflow นั้นเวลาที่เราอยากเขียน script สำหรับการทำงานต่างเราจะเรียกสิ่งนี้ว่า Dag file ซึ่งนี้ก็เป็น script ในการเขียนโครงสร้าง workflow อยู่ในรูปแบบ DAG (<strong>Directed Acyclic Graph</strong>) ภายใน DAG เองก็ประกอบไปด้วย TASK ซึ่งจะเป็นหน่วยย่อยๆภายใน DAG เอาล่ะ ประมาณนี้ก่อนเดี๋ยวจะกลายเป็น Airflow101 ไป 😆</p><h4>Amazon MWAA provisioned</h4><p>สำหรับ Amazon MWAA provisioned เป็นการยกเอา Apache Airflow มา Deployed ที่ AWS โดยทาง AWS จะจัดการเตรียม Resource ไว้ให้ไม่ว่าจะเป็น Compute Storage และ Database พร้อมทั้งจัดการเรื่องเชื่อมต่อเข้ากับ AWS ให้เสร็จสรรพ พร้อมทั้งดูแลเรื่อง scalability, availability, และ security โดยเราจะได้ใช้งาน Airflow เหมือนกับเวลาเรา Deploy บนเครื่องตัวเองเลย</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6ECZxo34x8D4HJEQ-hKmkg.png" /></figure><h4>Amazon MWAA serverless</h4><p>มาถึงเจ้าตัวหลักที่เราต้องการเขียนถึงแล้ว Amazon MWAA serverless ที่มาในรูปแบบที่เราไม่ต้อง Set up infrastructor อะไรเลย แค่โยน Dag ไปไว้ที่ S3 Bucket เท่านั้นก็สามารถใช้ได้ทันทีสะดวกสุดๆ แต่ต้องบอกก่อนว่า Amazon MWAA serverless จะอ่านเฉพาะไฟล์ yaml เท่านั้น ถ้าเราจะใช้งานโดยเอาโค้ด Dag file ที่เป็น python จากที่อื่นมาเราจำเป็นต้องเปลี่ยนให้เป็น yaml ก่อนซึ่ง AWS ก็มี Library เป็นตัวช่วยให้ด้วยแล้ว และถ้าอยากสร้าง Dag ใหม่เลยบน AWS ก็สามารถสร้างได้ที่ Amazon Sagemaker เช่นกัน ซึ่งจะอยู่ในพาร์ทที่เรียกว่า Workflow เราสามารถลากวางได้เลยมีหน้า GUI ให้ใช้ มาลองใช้งานกันดูว่าใช้งานยังไง</p><h4>การเขียน DAG เพื่อใช้งาน Amazon MWAA serverless จะมีอยู่สองแบบหลักๆ</h4><p>1.เขียน DAG file เองแล้วมาโยนไว้ที่ S3<br>ก็เริ่มจากเขียน DAG file ที่ VS code หรือ tool ไหนก็ได้ อย่างตัวอย่างนี้ แล้วก็ upload ไว้ที่ S3</p><pre>simples3test:<br>  dag_id: simples3test<br>  tasks:<br>    list_objects:<br>      operator: airflow.providers.amazon.aws.operators.s3.S3ListOperator<br>      bucket: your-s3-bucket-name<br>      prefix: &quot;&quot;<br>      retries: 0<br>    create_object_list:<br>      dependencies:<br>        - list_objects<br>      operator: airflow.providers.amazon.aws.operators.s3.S3CreateObjectOperator<br>      data: Hello MWAA serverless<br>      s3_bucket: mwaa-serverless-test-cdlb<br>      s3_key: demo_text.txt<br>      replace: true<br>  schedule: 0 0 * * *</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TFgKuAE9YiUjBJMpRPv2mA.png" /></figure><p>หลังจากนำมาวางไว้ที่ S3 แล้วให้ใช้ command AWS CLI เพื่อที่จะบันทึก DAG file เข้าไปที่ Amazon MWAA serverless เพราะไม่ใช่ว่าจะวางปุ๊ปแล้วจะทำงานทันที จะทำการสั่งให้ทำงานได้โดยใช้ AWS CLI เหมือนกัน</p><pre># Create workflow<br>aws mwaa-serverless create-workflow \<br>--name simple_s3_test \<br>--definition-s3-location &#39;{ &quot;Bucket&quot;: &quot;your-s3-bucket-name&quot;, &quot;ObjectKey&quot;: &quot;path/simple_s3_test.yaml&quot; }&#39; \<br>--role-arn arn:aws:iam::111122223333:role/mwaa-serverless-access-role \<br>--region us-east-1<br><br># Execute the workflow<br>aws mwaa-serverless start-workflow-run \<br>--workflow-arn arn:aws:airflow-serverless:us-east-2:111122223333:workflow/simple_s3_test-abc1234def \<br>--region us-east-1<br><br># Update workflow if you have made any changes.<br>aws mwaa-serverless update-workflow \<br>--workflow-arn arn:aws:airflow-serverless:us-east-2:111122223333:workflow/simple_s3_test-abc1234def \<br>--definition-s3-location &#39;{ &quot;Bucket&quot;: &quot;your-s3-bucket-name&quot;, &quot;ObjectKey&quot;: &quot;path/simple_s3_test.yaml&quot; }&#39; \<br>--role-arn arn:aws:iam::111122223333:role/mwaa-serverless-access-role \<br>--region us-east-1</pre><p>เมื่อลองเช็คที่ Amazon MWAA serverless เราก็จะพบกับ DAG ที่เราสร้างเอาไว้</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hOryITXf2pX1MnaWMdHLrg.png" /></figure><p>หลังจากนั้นเราสามารถไปดูที่หน้า UI ได้ว่าการทำงานของ DAG นั้นทำงานถูกต้องไหม และเพื่อที่จะดู view run เราสามารถคลิ๊กเข้าไปดูได้เลย แล้วเราก็จะไปโผล่ที่หน้า AWS Sagemaker หลังจากนั้นก็สามารถเช็ค log ได้ทันที (ดูผ่าน Cloudwatch โดยตรงก็ได้)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lyx3mP4UIszjztToqZq2NA.png" /></figure><p>2.เขียน DAG ผ่าน AWS Sagemaker workflow</p><p>เป็นการสร้าง DAG ผ่านหน้า GUI ที่อยู่ใน AWS Sagemaker workflow ให้ไปที่หน้า Amazon MWAA serverless แล้วคลิ๊กที่ Create workflow เท่านี้เราก็จะถูกพาไปที่หน้า AWS Sagemaker workflow แล้วครับ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X54mUg-pyee3nKM-a7QdMg.png" /></figure><p>เราสามารถลากวางสิ่งที่เราต้องการได้เลย อย่างเช่น Task save file to S3 หรือ Task trigger Glue job อะไรแบบนี้ก็ทำได้เช่นกัน หลังจากกด Save ไว้เรียบร้อยแล้ว เราก็สามารถเช็คได้ที่หน้า Amazon MWAA serverless ง่ายใช่ไหมละครับสะดวกแบบมากขึ้นเยอะ 😎</p><p>Extra: แปลงไฟล์จาก dag.py ให้เป็น dag.yaml หรือก็คือเปลี่ยน python file ให้เป็น yaml เพื่อจะได้ใช้งาน Amazon MWAA serverless เริ่มจาก install library ของ AWS</p><pre># AWS Python to Yaml Dag Converter for MWAA Serverless<br>pip install python-to-yaml-dag-converter-mwaa-serverless<br><br># To convert .py to .yaml<br>dag-converter convert &lt;python-dag-file&gt;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Hgk0_zMI7wha2EybbNXzOw.png" /></figure><h4>ความเหมือนที่แตกต่าง?</h4><p>หลังจากได้พาทดลองทำแล้ว จะเห็นได้ว่าพอเป็น Serverless แล้ว เพียงสั่งงานไม่กี่อย่างก็สามารถใช้งานได้ทันทีไม่ต้อง Set up มากมาย แต่สำหรับเจ้า Amazon MWAA serverless นั้น ก็จะมีข้อดีข้อเสียแตกต่างจาก Amazon MWAA provisioned พอสมควรเลย โดยเฉพาะ feature ต่างๆที่ไม่ได้เหมือนกับ Airflow ทั่วไป</p><p>ข้อแตกต่างที่เห็นได้ชัดๆ</p><ul><li>Dag operator ที่ไม่ได้มีครบเหมือนกับ Airflow ปรกติทั่วไป โดย Amazon MWAA serverless จะเน้นไปที่ Operator ที่เป็น AWS operator ต่างๆ <br>เช่น S3CreateBucketOperator, BedrockCreateKnowledgeBaseOperator, BatchOperator หรือ GlueJobOperator ตัดทิ้งพวก classic operator อย่าง PythonOperator หรือ BashOperator ไปได้เลย ตรงนี้ก็เข้าใจได้ว่าบางอย่างก็ไม่ได้อยากให้มีการ compute อยู่ที่ตัว serverless เอง</li><li>Dag parameter ที่ก็ไม่ได้มีให้ใช้ครบทุกอย่าง และนี้ก็เป็นตัวอย่างของ parameter ที่ใช้ไม่ได้ด้านล่าง โดยถ้าใครคุ้นชิน หรือต้อง Migrate จาก Airflow ดั้งเดิมมาอาจจะปวดหัวได้เพราะอย่างการใช้ email_on_failure ที่เอาไว้แจ้งเตือนก็ต้องไปเปลี่ยนไปใช้แจ้งเตือนผ่าน Service อื่นของ AWS<br>catchup, access_control, jinja_environment_kwargs, render_template_as_native_obj, tags, owner_links, auto_register, fail_fast, dag_display_name, depends_on_past, email_on_failure, email_on_retry, description, max_consecutive_failed_dag_runs, dagrun_timeout, sla_miss_callback, on_failure_callback, on_success_callback, is_paused_upon_creation</li></ul><h4>ทั้งหมดจึงขอสรุปประมาณนี้ว่า</h4><p>ถ้าเรามาใช้งาน AWS แบบใช้เฉพาะ Service AWS ก็มองว่าก็ค่อนข้างตอบโจทย์เลยใช้งานง่ายไม่ต้อง Set up อะไรมากเขียน DAG yaml ก็ใช้งานได้เลย อยากจะสร้างก็ไปใช้ผ่าน Sagemaker เองก็มี GUI ให้ใช้งาน และสำหรับใคร หรือองค์กรที่ใช้งาน Airflow อยู่แล้ว อยากจะย้ายมาใช้งานนั้น <strong>ไม่ค่อยจะแนะนำ </strong>เพราะต้องปรับเยอะมาก จะเป็นการเปลือง resource ในการทำงานเกินไปและยิ่งถ้าของเดิมมีการใช้งานที่ซับซ้อนอย่างเช่น DAG trigger DAG หรือพวก Dynamic task ก็ไม่มีให้ใช้ ถ้าจะใช้ Airflow แบบครบทุก feature ก็คงต้องมองหา <strong>A</strong>mazon MWAA Provisioned อยู่ดี จึงขอสรุปว่าเป็นการใช้งานกันคนละแบบเลยแต่แค่ Concept ของการสร้าง Workflow ยังเหมือนกัน</p><p>ref: <a href="https://docs.aws.amazon.com/mwaa/latest/mwaa-serverless-userguide/mwaas-concepts.html">https://docs.aws.amazon.com/mwaa/latest/mwaa-serverless-userguide/mwaas-concepts.html</a></p><p><strong>ติชมหรือแนะนำอะไรสามารถพูดคุยกันได้เลยนะครับ<br>Follow me here!<br>Linkedin:<br></strong><a href="https://www.linkedin.com/in/kriangsak-sumthong/">https://www.linkedin.com/in/kriangsak-sumthong/</a><br><strong>Facebook page:<br></strong><a href="https://www.facebook.com/profile.php?id=61563097228247">https://www.facebook.com/profile.php?id=61563097228247</a><br><strong>Medium:<br></strong><a href="https://medium.com/@puk.kriangsak">https://medium.com/@puk.kriangsak</a><br><strong>Website:<br></strong><a href="https://clouddatalabor.com/">https://clouddatalabor.com/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ab0c570ce438" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>