DEV Community: Kan Ouivirach

ใช้ Papermill ทำ Automation กับ Jupyter Notebooks

Kan Ouivirach — Mon, 07 Sep 2020 08:53:40 +0000

Background

ในยุคนี้เวลาที่ชาว Data Scientist อยากจะสื่อสารผลที่ได้จากการวิเคราะห์ข้อมูลกับฝั่ง Business หรืออยากที่จะสร้างโมเดลทำนายผลทางธุรกิจสักอย่างหนึ่ง Jupyter Notebooks จะเป็นอาวุธหรือเครื่องมือสำคัญที่ส่วนใหญ่เราจะหยิบเอามาใช้กัน ซึ่งข้อดีของเครื่องมือตัวนี้ก็คือมันสามารถเป็นทั้ง document เป็น live code รวมไปถึง visualization ภายในตัว

Challenges

แต่อย่างไรก็ดี เครื่องมือตัวนี้ยังมีข้อจำกัดอยู่ที่ว่าเวลาที่เรา

อยากจะเปลี่ยนแปลงค่า input บางค่า หรือว่ามีส่วนของโค้ดที่เราอยากไปดึงข้อมูลหลังจากจบเดือนนี้ หรือดึงโค้ดในวันสิ้นปี เราต้องเปิด notebook นั้นๆ ขึ้นมาในวันนั้นๆ แล้วสั่ง execute แต่ละ cell เอง
อยากจะใช้ค่าจากผลการทดลองที่อยู่ใน notebook ของเพื่อนร่วมทีม สิ่งที่เราต้องทำก็คือไปเปิด notebook ของเพื่อน นั่งไล่ execute แต่ละ cell แล้วก็อปปี้ผลที่ได้มาแปะใน notebook ของเราเพื่อนำค่านั้นๆ ไปใช้งานต่อ

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

Introducing Papermill

บทความนี้เลยอยากจะมาแนะนำเครื่องมือ open source ตัวหนึ่งที่ชื่อ Papermill ครับ เค้าว่ามาแบบนี้

Papermill is a tool for parameterizing and executing Jupyter Notebooks.

หมายความว่าเราสามารถที่จะ

กำหนด parameters และส่งเข้า notebook ของเราได้
สั่ง execute ตัว notebook ของเราได้

แน่นอนครับ เมื่อเรามีความสามารถแบบนี้ เราจึงสามารถทำ automation หรือจับเอา notebook ของเราเข้าไปรวมอยู่ใน automated workflow ได้แล้วน่ะสิ! ปัญหาที่เอ่ยถึงด้านบนก็ถูกแก้ไขไปเรียบร้อยแล้วด้วยเครื่องมือตัวนี้ครับ

สิ่งที่ Papermill ทำมีอยู่ 3 ขั้นตอนสั้นๆ คือ

รับ notebook มาพร้อมกับ parameters ที่เรากำหนด
ทำ execute ตัว notebook นั้นๆ ให้
บันทึกผลลัพธ์ไว้ใน notebook ไฟล์ใหม่

อยากลองเล่น? ไปดูหัวข้อถัดไปกันเลย~

Getting Started with Papermill

ติดตั้ง Papermill กับ Jupyter Notebook ก่อนครับ

pip install papermill jupyter

เสร็จแล้วก็ให้เปิด server ของ Jupyter Notebook ขึ้นมา

jupyter notebook

เสร็จแล้วก็เขียนโค้ดตามปกติประมาณนี้

ต่อไปให้เรากำหนด Tags ให้กับ cell ที่เราอยากให้เป็น parameters ครับ วิธีกำหนดก็ตามรูปด้านล่างนี้เลย กดที่ cell นั้นๆ ก่อน

ให้เราใส่ tag เป็นคำว่า parameters ครับ

เสร็จแล้วให้เราไปที่ terminal แล้วสั่ง

papermill -p name 'Kan' -p x 9 -p y 8 main.ipynb output.ipynb

คำสั่งด้านบนนี้แปลว่าเรากำหนด parameters ตามนี้

name ให้มีค่าเป็น string มีค่า 'Kan'
x ให้เป็น integer มีค่า 9
y ให้เป็น integer มีค่า 8

พอรันเสร็จให้เราเปิดไฟล์ notebook ที่เราได้ออกมาใหม่ที่ชื่อ output.ipynb ดูครับ จะเป็นประมาณนี้

เห็นได้ว่า Papermill มาแทรก cell ที่มี tag ชื่อ injected-parameters ไว้ข้างใต้ cell ของเราที่ tag ไว้ก่อนหน้านี้ ซึ่งทำให้ cell ถัดๆ ไปได้ใช้ค่า parameters ที่โดน inject เข้าไปแทนที่จะใช้ parameters ที่เรากำหนดไว้ตอนแรก

ดูเป็นวิธีที่ simple มากๆ แต่แก้ปัญหาได้เยอะเลยนะ งดงามมาก

ใครอยากเห็นโค้ดที่ใช้ในบทความนี้ ตามไปดูกันได้ที่ hello-papermill

ใครที่ใช้ Papermill กันอยู่ อยากรู้จังว่าเอาไปใช้ใน use case ไหนกันบ้าง แชร์กันมาได้นะครับ ^^

ปล. ถ้าเราไม่ tag คำว่า parameters ที่ cell ของเราไว้ Papermill จะใส่ injected-parameters ไว้ที่ cell ด้านบนสุดให้

9 นิสัยเล็กๆ ที่จะเปลี่ยนชีวิต

Kan Ouivirach — Sun, 30 Aug 2020 01:09:27 +0000

ฟังจาก Podcast ของ Mission to the Moon มาตอน นิสัยเล็กๆ มากๆ ที่จะเปลี่ยนชีวิตคุณในหนึ่งปี ขอมาสรุปจดไว้ 😊

นิสัยเล็กๆ เมื่อทำๆ ไปจะเป็นผลดีในระยะยาว และจะเปลี่ยนชีวิตเรา มี 9 ข้อ

อย่าตอบสนอง ตอบโต้เร็วเกินไป
ทำงานให้เสร็จในตอนที่ไม่รู้สึกอยากทำ เช่น ล้างจาน ก็ล้างให้เสร็จๆ ไป
ใช้ชีวิตสัก 1 วันโดยไม่เข้า social media
เตรียมตัว เตรียมของ เตรียมงานในวันถัดไป ก่อนวันรุ่งขึ้นตอนกลางคืน จะทำให้วันรุ่งขึ้นมีพลังมากขึ้น
กินอย่างมีสติ เวลากินก็ให้คิดถึงแต่เรื่องกิน
กำหนดเวลาทำ task แบบ time boxing ต้องมีการจับเวลาเกิดขึ้น
วางมือถือวางไว้ไกลๆ จากตัวที่สุด โดยเฉพาะเวลานอน
เวลาอยากได้อะไร ให้รอก่อน ถ้าต้องการจริงๆ ค่อยกลับมา หรือเวลาเจอป้าย sale ให้ถามตัวเองว่า ถ้าเป็นราคาเต็มยังจะซื้ออีกไหม จะได้รู้ว่าเราต้องการจริงๆ หรือเปล่า
เขียนทุกไอเดียที่เกิดขึ้น

สรุปบทความ Quantity Always Trumps Quality (ในมุมของ Software Development)

Kan Ouivirach — Sun, 12 Jul 2020 13:49:30 +0000

จากบทความ Quantity Always Trumps Quality เค้าบอกว่า quantity (จำนวน) เหนือกว่า quality (คุณภาพ) เคยมี อ. ลองแบ่งกลุ่มนักเรียนเป็น 2 กลุ่ม โดยกลุ่มหนึ่งจะตัดเกรดจาก quantity อีกกลุ่มตัดเกรดจาก quality ปรากฎว่า กลุ่มที่เป็น quantity ทำได้ดีกว่า และที่แปลกก็คือกลุ่ม quantity มีงานที่มี quality สูงกว่า

ในการพัฒนา Software ที่มีมัก deadline เข้ามาเอี่ยวด้วยเสมอ การที่เราเน้นจำนวนเป็นการที่เราทำซ้ำๆ ทำเยอะๆ และเราจะเรียนรู้จากตรงนั้น ถ้ามันไม่ work เราก็สร้างใหม่เรื่อยๆ จนกว่าเราจะเจอที่มัน work ดังนั้นแทนที่จะมานั่งเสียเวลาไปกับการคิดว่าจะทำดีหรือไม่ดี ให้หยุดคิดซะ แล้วลงมือทำ ซึ่งส่วนใหญ่แล้วคนที่ลงมือทำจะผลิตผลงานออกมาได้ดีกว่า (แต่ๆๆ ก็ให้คำนึงถึงเวลาที่เราลองผิดลองถูกกับเวลาที่ทำเป็นงานจริงๆ ด้วยนะ balance กันให้ดีครับ)

Jeff (ผู้เขียน) ได้ให้คำแนะนำไว้ 3 ข้อตามนี้ ลองตามไปอ่านกันดู

เลิกเพ้อฝันแล้วลงมือทำกัน 😉

ปล. บทความนี้พูดถึงมุมของ Software Development เท่านั้นนะ

สรุปบทความ Why You Should Have (at Least) Two Careers

Kan Ouivirach — Fri, 10 Jul 2020 11:47:38 +0000

เห็น @gatukgl แชร์ไว้ในเฟสบุค อ่านแล้วชอบมาก และรู้สึกว่าเป็นอย่างงั้นจริงๆ กับตัวเอง ขอเขียนสรุปไว้ประมาณนี้

คือจากประสบการณ์ของผู้เขียน การเปลี่ยนงานมี cost ค่อนข้างสูง แล้วก็มีน้อยคนที่จะประสบความสำเร็จในชีวิต ซึ่งเค้าบอกว่าแทนที่เราจะมองหางานใหม่ ให้ลองมองหางานที่ 2 แทนอาจจะดีกว่า และทำให้เราได้ประโยชน์จากทั้ง 2 งาน (ผู้เขียนทำงานอยู่ 4 ที่..)

งานหลักช่วย subsidize ทำให้เราสามารถพัฒนาสกิลจากงานที่ 2 ได้ และงานที่ 2 ก็ช่วยเติมเต็ม passion ของเรา
เราได้เจอเพื่อนใหม่ในสังคมที่ต่างออกไป เราจะได้ perspective ที่ต่างออกไป และเรายังมี connection ที่เพิ่มมากขึ้นอีกด้วย
เราจะได้พบกับ innovations จริงๆ เราจะมองเห็นการเชื่อมโยงต่างๆ การผสมผสานกันจนเกิดสิ่งใหม่ๆ ขึ้นมา

ไปอ่านเต็มๆ ได้ที่ลิ้งค์ข้างล่างนี้จ้า 👇

https://hbr.org/2017/04/why-you-should-have-at-least-two-careers

5 Challenges ในการสร้าง Production-Grade Data Pipeline

Kan Ouivirach — Sat, 20 Jun 2020 01:58:51 +0000

เวลาที่มีคนมาปรึกษาว่าอยากจะลงมือสร้าง data pipeline จะเริ่มสร้างอย่างไร ส่วนใหญ่ผมมักจะชวนให้ลองทำ data pipeline แบบ minimal ขึ้นมาก่อน โดยการเขียน script ประมาณนี้

ดึงข้อมูลอะไรก็ได้ที่ดูน่าสนใจจากอินเตอร์เนท หรือจากเว็บ Open Government Data of Thailand ออกมาเก็บอยู่ในฟอร์แมตสักฟอร์แมตหนึ่ง เช่น CSV
จัดการทำความสะอาดข้อมูลสักเล็กน้อย เช่น คอลัมน์ปีเกิด อาจจะเก็บค่าปีเป็น พ.ศ. บ้าง ค.ศ. บ้าง เราก็แปลงให้เป็นปีแบบเดียวกัน หรือพวก timestamp ก็จัดฟอร์แมตให้เราเอาไปใช้ต่อได้ง่าย
สร้างฐานข้อมูลขึ้นมาสัก 1 เครื่อง แล้วโหลดข้อมูลเข้าไป
กำหนดให้ script ถูกรันทุกๆ วันตอนเที่ยงคืน หรือทุกๆ 5 นาทีก็ได้นะ

ที่ว่ามาด้านบนนี้คืออยากให้คนที่เพิ่งเริ่มต้นได้ feeling เบื้องต้นของสายงานด้าน data engineering เรียกได้ว่ามันคือการสร้าง data pipeline แบบ happy path เฉยๆ ทีนี้ถ้าเราจะต่อยอดไปจากนี้ แล้วสร้างให้ดีๆ เราจะเจอความท้าทาย 5 อย่างประมาณนี้ลองไปดูกัน

1. Schema เปลี่ยนแปลงอยู่ตลอด

อันนี้น่าจะเป็นปัญหาอันดับ 1 ที่ทุกคนต้องเจอ ยิ่งในยุคปัจจุบันที่โลกของซอฟต์แวร์นั้นเปลี่ยนแปลงไปเร็วมาก disrupt กันเป็นว่าเล่น ธุรกิจเราก็ evolve ตามไป และแน่นอนว่าจะส่งผลให้ schema ของข้อมูลนั้นเปลี่ยนแปลงไป เราก็ต้องปรับ data pipeline ของเราตาม

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

ระบบ monitoring กับ logging ดีๆ จะช่วยให้เรารู้ตัวได้ไว และการทำ schema version management ก็สามารถช่วยได้เช่นกัน 💪

2. Machine Failure เป็นเรื่องปกติ

งาน data pipeline ไม่ได้มีแค่ส่วนโค้ดที่เราต้องดูแล ยังมีเรื่องของ infrastructure ที่เราใช้อยู่ด้วย ระบบหรือตัวเครื่องเซิฟเวอร์ก็จะมีปัญหาประมาณว่า disk เต็ม เขียนไฟล์ไม่ได้บ้าง เครื่องค้างต้องรีสตาร์ท ระบบ network หรือ DNS ล่ม แล้วยังต้องอัพเกรด patch อีก สิ่งเหล่านี้เกิดขึ้นเป็นเรื่องปกติ 🤣 หาวิธีรับมือไว้เลยแต่เนิ่นๆ

3. การ Scale เพื่อรองรับข้อมูลที่มีขนาดใหญ่ขึ้นเรื่อยๆ

ช่วงแรกๆ ตอนที่มีข้อมูลน้อยๆ เราก็ happy ดีแหละ data pipeline อาจจะใช้เวลาไม่ถึง 10 นาทีก็ทำงานเสร็จ 😊 แต่หลายๆ คน รวมถึงตัว business เอง เรื่องการ scale ตัว data pipeline อาจจะไม่ใช่ priority ขององค์กร เลยไม่ได้นึกถึงเรื่องการ scale เท่าไหร่ ตรงนี้ผมมองว่ามันจะเป็นหลุมพลาง (pitfall) เนื่องจากข้อมูลที่ไหลเข้ามา และเพิ่มขึ้นเรื่อยๆ การทำงานของ data pipeline ก็จะใช้เวลานานขึ้นเรื่อยๆ เช่นกัน ยังไม่จบแค่นั้น.. แต่ละองค์กรก็คงไม่ได้มีแค่ pipeline เดียวแน่ ยิ่งปล่อยทิ้งไว้มันก็ยิ่งเหมือน technical debt ที่สะสม ไปจนวันหนึ่งเราจะไม่สามารถแก้มันได้อีกแล้ว เพราะ cost ของ effort ที่จะลงแรงไปปรับปรุงให้ดีขึ้นมันสูงเกินไป

ดังนั้นให้นึกถึงการ scale เอาไว้ด้วยเลย ยิ่งองค์กรไหนมีข้อมูลเยอะอยู่แล้ว เรื่องการ scale เป็นเรื่องที่สำคัญมาก ตรงนี้จะรวมไปถึงการเลือก technology ที่เหมาะสมมาใช้ด้วยเช่นกัน ใช้แค่ script อย่างที่กล่าวไว้ตอนต้นอย่างเดียวคงจะไม่พอล่ะ

4. Batch vs. Real-Time

เรื่องนี้ก็ตาม business เลย ขึ้นอยู่กับ context ของแต่ละที่ และแต่ละงาน ถึงแม้ว่าตลาดส่วนใหญ่จะเป็นเรื่อง batch processing แต่ก็อยากให้ระลึกไว้เสมอไว้ว่างานในหลายๆ ที่มีแบบ real-time processing เข้ามาแล้ว การทำ data pipeline แบบ batch กับแบบ real-time ก็มีการพัฒนาและการดูแลที่แตกต่างกัน พวกเราชาว data engineer ควรที่จะศึกษาและลองเล่นไว้ทั้ง 2 แบบนะ 🤓

5. การทำ Data Catalog และ Data Lineage

หัวข้อนี้มีความเกี่ยวข้องกับการทำ data lake ด้วยนะ ซึ่งหลายคนมักจะมองข้าม เอาไว้ทำทีหลังก็ได้ แล้วสุดท้ายก็จะลืม.. หรือไม่ก็เกิดอาการ curse of knowledge ของคนทำข้อมูล ที่ว่ามองแว๊บเดียวก็รู้ว่าอะไรคืออะไร อย่าไปตกหลุมพลางเข้าล่ะ ระลึกไว้เสมอเลยว่าเราไม่ได้ทำงานคนเดียว 🙂

ก็อยากจะมาเขียนย้ำครับว่าให้นึกถึงการทำ data catalog (เก็บ metadata ไว้เพื่อให้ค้นหาข้อมูลได้สะดวกและรวดเร็ว) กับ data lineage (รู้ที่มาที่ไปของข้อมูลว่ามาจากไหน ได้มาได้อย่างไร โดน transform มาแบบไหน) ด้วย

สรุปช่วงท้าย

ที่เขียนไว้ด้านบนน่าจะเป็นความท้าทายที่คนทำงานทางด้านข้อมูล โดยเฉพาะสายงาน data engineer 👷🏻‍♀️👷🏻‍♂️ น่าจะต้องเจอกัน งานสร้าง data pipeline ให้ดีๆ ก็จะมีหลายอย่างที่ต้องคิด แล้วก็จะมีอีกหลายอย่างที่เราอาจจะต้องไปเจอหน้างาน แล้วแก้ไปตาม context ณ ตอนนั้นด้วย 😅

คนที่แวะเข้ามาได้เจอความท้าทายอะไรกันบ้างเอ่ย? เล่าให้อ่านกันได้นะ 😘

ปล. ขอบคุณรูป cover สวยๆ จาก JJ Ying

ใช้ Terraform ทำ Blue-Green Deployment แบบง่ายๆ

Kan Ouivirach — Sat, 25 Apr 2020 06:50:23 +0000

Terraform มันคืออาวุธที่ใช้ในการทำ infrastructure as code เพื่อจัดการการวาง infrastructure ต่างๆ เราสามารถสร้างเครื่อง จัดการเครื่อง หรือลบเครื่องได้โดยไม่ต้องไปกดๆ ใน cloud console เลย และที่สำคัญคือมันทำ immutable infrastructure ลองดูวีดีโอด้านล่างนี้ 👇 เค้าอธิบาย mutable กับ immutable infrastructure ว่าต่างกันอย่างไร

ส่วน blue-green deployment มันคืออะไร? ถ้าใครไม่รู้จัก ผมอยากให้ตามไปอ่านโพสต์ BlueGreenDeployment ของ Martin Fowler กันก่อนครับ 😆 ด้านล่างนี่เป็นรูป blue-green deployment ที่ Martin เค้าวาดไว้

มันก็ประมาณว่า เวลาที่เรา deploy server เราจะมอง server ตัวเก่าเป็น blue และตัวที่กำลังจะ deploy เป็น green โดยที่ตัว infrastructure ของเราจะรอให้ green ทำงานได้ก่อน รับ request ได้ก่อน แล้วค่อยฆ่าตัว blue ทิ้ง (ซึ่งแน่นอนครับ ต้องอาศัย load balancer สักตัวหนึ่งมาช่วย)

ซึ่งตัว Terraform ที่เกริ่นมาข้างต้นนี่แหละ สามารถเอามาทำ blue-green deployment ได้นะ โดยหลักการที่เราจะทำเนี่ย เนื่องจาก Terraform ออกแบบมาเพื่อ immutable infrastructure ซึ่งการที่เราจะสร้าง infrastructure stack ทั้งหมด ตั้งแต่ DNS ยัน database เลยเนี่ย มันจะทำให้เราต้องมาทำ load balancer ครอบ stack ของเราอีกรอบ (ย้อนกลับไปดูรูปด้านบนครับ ตัว load balancer ก็คือ Router ในรูปนั่นเอง)

ดังนั้นเราจะสร้างโครงขึ้นมาก่อน แล้วส่วนที่เราต้องการให้มีการเปลี่ยนแปลงอยู่ตลอดเวลา เช่น เครื่อง server เราก็จะแยกออกมาจากโครงนั้นเอามาทำ blue-green deployment ดูโค้ดกันเลย (ในทีนี้ใช้ AWS เป็น cloud provider นะ)

เบื้องต้นผมจะทำไว้ 2 โฟลเดอร์มีหน้าตาประมาณนี้

➜  terraform tree -L 2
.
├── app
│   ├── bootstrap.sh
│   └── main.tf
└── base
    ├── bootstrap.sh
    └── main.tf

2 directories, 4 files

โฟลเดอร์ base จะเป็น folder ที่ผมจะเอาไว้สร้างโครงครับ ซึ่งตรงนี้จะเป็น Terraform ก็ได้ หรือจะสร้างผ่าน CLI ก็ได้ หรือจะไป manual กดๆ ในหน้า AWS console เลยก็ได้ครับ ส่วนโฟลเดอร์ app ผมก็จะมีแค่การสร้าง EC2 instance แล้วก็การเอา instance นั้นไป register เข้ากับ load balancer (ในที่นี้ใช้ ALB)

ส่วนไฟล์ bootstrap.sh ทั้ง 2 ไฟล์ มีหน้าตาเหมือนกันครับ จะเป็นสคริปสำหรับติดตั้งอะไรก็ได้ตอนที่เครื่อง EC2 ถูก provision ขึ้นมา ในที่นี้ผมจะเอาไว้ลง Docker เฉยๆ เนื้อหาในไฟล์จะประมาณนี้

#!/bin/sh

rm -rf /var/lib/cloud/*
sudo apt-get update -y
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh
sudo usermod -aG docker ubuntu
sudo curl -L "https://github.com/docker/compose/releases/download/1.25.5/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

มาดู base/main.tf กัน จะยาวๆ หน่อย

# base/main.tf

provider "aws" {
  access_key = var.access_key_id
  secret_key = var.secret_access_id
  region     = var.region
}

variable "access_key_id" {
  type        = string
  description = "AWS Access Key ID"
}

variable "secret_access_id" {
  type        = string
  description = "AWS Secret"
}

variable "region" {
  type        = string
  default     = "ap-southeast-1"
  description = "AWS Region"
}

variable "product_area" {
  type        = string
  default     = "lost-in-space"
  description = "Product Area"
}

variable "environment" {
  type        = string
  default     = "dev"
  description = "Product Environment"
}

resource "aws_vpc" "lost_in_space" {
  assign_generated_ipv6_cidr_block = true
  cidr_block                       = "10.30.0.0/21"
  enable_dns_hostnames             = true
  enable_dns_support               = true

  tags = {
    Name         = var.product_area
    environment  = var.environment
    product-area = var.product_area
  }
}

resource "aws_internet_gateway" "lost_in_space_internet_gateway" {
  vpc_id = aws_vpc.lost_in_space.id

  tags = {
    Name         = "${var.product_area}-internet-gateway"
    environment  = var.environment
    product-area = var.product_area
  }
}

resource "aws_subnet" "lost_in_space_public_subnet_zone_a" {
  vpc_id = aws_vpc.lost_in_space.id

  assign_ipv6_address_on_creation = true
  availability_zone               = "${var.region}a"
  cidr_block                      = "10.30.0.0/24"
  ipv6_cidr_block                 = cidrsubnet(aws_vpc.lost_in_space.ipv6_cidr_block, 8, 0)

  tags = {
    Name         = "${var.product_area}-public-subnet-zone-a"
    environment  = var.environment
    product-area = var.product_area
  }
}

resource "aws_route_table" "lost_in_space_public_route_table" {
  vpc_id = aws_vpc.lost_in_space.id

  route {
    cidr_block     = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.lost_in_space_internet_gateway.id
  }

  tags = {
    Name         = "${var.product_area}-public-route-table"
    environment  = var.environment
    product-area = var.product_area
  }
}

resource "aws_route_table_association" "lost_in_space_public_route_table_association_zone_a" {
  subnet_id      = aws_subnet.lost_in_space_public_subnet_zone_a.id
  route_table_id = aws_route_table.lost_in_space_public_route_table.id
}

resource "aws_security_group" "lost_in_space" {
  name        = "lost-in-space-dev"
  description = "Security group for Lost In Space (dev)"
  vpc_id      = aws_vpc.lost_in_space.id

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
    description = "Allow SSH inbound traffic"
  }

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
    description = "Allow HTTP inbound traffic"
  }

  ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
    description = "Allow HTTPS inbound traffic"
  }

  ingress {
    from_port   = 5432
    to_port     = 5432
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
    description = "Allow PostgreSQL inbound traffic"
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
    description = "Allow Internet Outbound"
  }

  tags = {
    Name         = "lost-in-space-dev"
    environment  = var.environment
    product-area = var.product_area
  }
}

resource "aws_alb" "lost_in_space" {
  name                       = "lost-in-space-dev"
  security_groups            = [aws_security_group.lost_in_space.id]
  subnets                    = [aws_subnet.lost_in_space_public_subnet_zone_a.id, aws_subnet.lost_in_space_public_subnet_zone_b.id]
  enable_deletion_protection = true
  idle_timeout               = 300

  tags = {
    Name         = "lost-in-space-dev"
    environment  = var.environment
    product-area = var.product_area
  }
}

resource "aws_alb_target_group" "lost_in_space" {
  name     = "lost-in-space-alb-target"
  port     = 80
  protocol = "HTTP"
  vpc_id   = aws_vpc.lost_in_space.id
  stickiness {
    type            = "lb_cookie"
    cookie_duration = 3600
  }
  health_check {
    path = "/"
    port = 80
  }
}

resource "aws_alb_listener" "listener_http" {
  load_balancer_arn = aws_alb.lost_in_space.arn
  port              = "80"
  protocol          = "HTTP"

  default_action {
    target_group_arn = aws_alb_target_group.lost_in_space.arn
    type             = "forward"
  }
}

ก็จะมีการสร้าง VPC, Internet Gateway, Subnet, Route Table, Security Group, Application Load Balancer (ALB) ซึ่งของพวกนี้เราไม่จำเป็นต้อง deploy ใหม่ทุกครั้งครับ เรา define ไว้ได้เลย

ต่อไปมาดู app/main.tf กัน ซึ่งไฟล์นี้แหละ เราจะเอาไว้ทำ blue-green deployment

# app/main.tf

provider "aws" {
  access_key = var.access_key_id
  secret_key = var.secret_access_id
  region     = var.region
}

variable "access_key_id" {
  type        = string
  description = "AWS Access Key ID"
}

variable "secret_access_id" {
  type        = string
  description = "AWS Secret"
}

variable "region" {
  type        = string
  default     = "ap-southeast-1"
  description = "AWS Region"
}

variable "product_area" {
  type        = string
  default     = "lost-in-space"
  description = "Product Area"
}

variable "environment" {
  type        = string
  default     = "dev"
  description = "Product Environment"
}

variable "infrastructure_version" {
  type        = string
  description = "Infrastructure Version"
}

data "aws_alb_target_group" "lost_in_space" {
  name = "lost-in-space-alb-target"
}

data "aws_subnet" "selected" {
  filter {
    name   = "tag:Name"
    values = ["${var.product_area}-public-subnet-zone-a"]
  }
}

data "aws_security_group" "selected" {
  filter {
    name   = "tag:Name"
    values = ["lost-in-space-dev"]
  }
}

resource "aws_alb_target_group_attachment" "lost_in_space_target_group_attachment" {
  target_group_arn = data.aws_alb_target_group.lost_in_space.arn
  target_id        = aws_instance.lost_in_space.id
  port             = 80
}

resource "aws_instance" "lost_in_space" {
  associate_public_ip_address = true
  subnet_id                   = data.aws_subnet.selected.id
  security_groups             = [data.aws_security_group.selected.id]
  ami                         = "ami-09a4a9ce71ff3f20b"
  instance_type               = "t2.medium"
  key_name                    = "rocket-dev"
  user_data                   = file("bootstrap.sh")

  root_block_device {
    volume_type = "gp2"
    volume_size = 30
  }

  volume_tags = {
    Name         = "lost-in-space-dev"
    environment  = var.environment
    product-area = var.product_area
  }

  tags = {
    Name                  = "lost-in-space-dev"
    InfrastructureVersion = var.infrastructure_version
    environment           = var.environment
    product-area          = var.product_area
  }

  lifecycle {
    create_before_destroy = true
  }
}

ไฟล์ app/main.tf จะมีจุดสำคัญอยู่ 3 จุดที่เราจำเป็นต้องรู้คือ

การใช้ Data Source สาเหตุที่เราต้องใช้เพราะว่าเราจำเป็นต้องรู้ว่าตอนที่เราจะ deploy เราจะเอา EC2 instance ของเราไปผูกกับ ALB target group อะไร Subnet อะไร และ Security Group อะไร ที่เราสร้างไว้ตอนแรกใน base/main.tf ซึ่งตัว Data Source นี่แหละ เหมือนให้เราสามารถไปดึงค่า AWS service ที่เราเคยสร้างเอาไว้แล้วมาใช้ในสคริปนี้ต่อได้
การใช้ variable ที่ชื่อ InfrastructureVersion ซึ่งตรงนี้ จะเป็นจุดที่ผมใช้เพื่อให้ Terraform ตรวจจับการเปลี่ยนแปลงเพื่อที่มันจะสร้าง stack ใหม่ให้ผมได้ ซึ่งตรงนี้ก็มีหลากหลายเทคนิคนะครับ จะแก้ตัวไฟล์ app/main.tf เลย หรือจะมีอีกสคริปหนึ่งมา search & replace ค่าอะไรสักอย่างใน app/main.tf ก็ได้ ใครชอบแบบไหนก็เลือกเอาได้เลย
จุดสำคัญที่สุดที่จะทำให้เราลด downtime เวลาที่ deploy ได้คือตรง lifecycle ครับ ในที่นี้ผมเซต create_before_destroy = true จะหมายความว่าให้สร้าง stack ใหม่ให้เสร็จก่อน แล้วค่อยลบ stack เก่า ซึ่งถ้าไม่ได้เซตตรงนี้ไว้ stack เก่าจะโดนลบทันทีที่เรากำลังสร้าง stack ใหม่ครับ แนะนำให้อ่าน Zero Downtime Updates with HashiCorp Terraform ต่อ เค้าจะบอกวิธีแก้ในกรณีที่ application ของเรายังไม่ได้รันขึ้นมาจริงๆ (รัน instance ขึ้นมาได้ ไม่ได้หมายความว่า application ของเราจะรันเสร็จ)

จบ! 😎

การเริ่มใช้ Mockito (@Mock กับ @InjectMocks) ใน Spring Boot

Kan Ouivirach — Sun, 19 Apr 2020 04:56:13 +0000

ลอง search ใน Google แล้วพบว่ามีหลายบทความที่เขียนเกี่ยวกับเรื่องนี้เยอะอยู่เหมือนกัน ไล่ตามอ่านหลายบทความอยู่จนพอที่จะทำ minimal working example เกี่ยวกับการ Mock ใน Spring Boot โดยใช้ Mockito (แค่ @Mock กับ @InjectMocks) ได้แล้ว ดีใจ~ 🤩🎉

เผื่อใครอยากลองทำตามก็ไปใช้ Spring Initializr สร้างโปรเจคมาก่อน เลือกเป็น Maven หรือ Gradle ก็ได้นะ ส่วนภาษาก็จริงๆ เลือกอะไรก็ได้ ไม่ว่าจะเป็น Java หรือ Kotlin หรือ Groovy แต่ในบทความจะเป็น Java นะครับ (เหตุผล? ตอนที่เขียนบทความนี้ผมรู้จัก syntax ของ Java อยู่ภาษาเดียวครับ 😂) สร้างเสร็จแล้วก็น่าจะได้ ZIP ไฟล์มา เราก็เอาไป import เข้า IDE ตัวที่ถนัดของเรา ไปเริ่มเขียนโค้ดกันเลย

แบบยังไม่ได้ใช้ Mockito

สมมุติว่าเรามีคลาสแบบง่ายๆ อยู่ 2 คลาส

package team.bars.mockito;

public class Bear {
    public String roar() {
        return "Hello";
    }
}

public class BearService {
    public String say() {
        Bear bear = new Bear();
        return bear.roar();
    }
}

ตัว BearService แค่สร้าง bear ขึ้นมาแล้วส่งค่าจาก method ที่ชื่อ roar ออกไป เวลาที่เราเขียนเทสก็จะประมาณนี้

package team.bears.mockito;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

public class BearServiceTest {
    @Test
    public void testItShouldReturnHelloFromBear() {
        BearService bearService = new BearService();
        String actual = bearService.say();
        assertEquals("Hello", actual);
    }
}

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

คลาส BearService มีการเรียก Bear ที่เป็น dependency ข้างใน เสมือนกับว่าเทสนี้ได้ไปทดสอบตัว Bear ไปด้วยเลยโดยปริยาย ซึ่งความต้องการจริงๆ แล้วเราอาจจะอยากทดสอบแค่ตัว BearService พอ
เรามองไม่เห็นว่า BearService ได้ไปเรียก Bear จริงๆ หรือเปล่าตามที่เราตั้งใจไว้
ถ้าเป็นกรณีที่ say ของ BearService ไปเรียก API เวลาที่เรารันเทสแล้ว มันก็จะไปยิง API จริงๆ ซึ่งเราคงไม่อยากให้เป็นแบบนั้น

มาลองใช้ Mockito (@Mock กับ @InjectMocks) กัน

ก่อนอื่นเราจะต้องไปเพิ่ม Mockito ให้เป็น dependency ก่อน ถ้าใครใช้ Gradle ก็ให้ไปเพิ่ม dependency ที่ใช้สำหรับตอน compile ตัวเทส (ไม่เอาไปใช้บน production) ใน dependencies ที่ไฟล์ build.gradle ประมาณนี้

dependencies {
    ...
    testCompile group: 'org.mockito', name: 'mockito-core', version: '3.3.3'
}

ถ้าใครใช้ Maven ก็ให้เพิ่ม dependency ใน dependencies ที่ไฟล์ pom.xml ตามนี้

<dependencies>
    ...
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <version>3.3.3</version>
        <scope>test</scope>
    </dependency>
</dependencies>

รู้ได้อย่างไรว่าต้องเขียน dependency แบบนี้? ดูจาก Maven Repository จ้า 😆

ต่อไปเราจะไปแก้ที่ BearService ก่อน โดยแทนที่เราจะ instantiate ตัว bear ขึ้นมาเอง เราจะใช้เทคนิค dependency injection เพื่อที่เราจะได้ไม่ต้องมา instantiate ใน BearService เอง ซึ่งใน Spring มี annotation ที่ชื่อ @Autowired มาช่วยให้ชีวีตเราง่ายขึ้น โค้ดของ BearService จะได้ตามนี้

package team.bears.mockito;

import org.springframework.beans.factory.annotation.Autowired;

public class BearService {
    @Autowired
    Bear bear;

    public String say() {
        return bear.roar();
    }
}

จากนั้นเราก็จะไปแก้เทส BearServiceTest กัน เราอยากจะ mock ตัว Bear เพื่อที่เราจะได้ทดสอบแค่ส่วนของ BearService เราก็จะแก้โค้ดตามนี้

package team.bears.mockito;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import static org.junit.jupiter.api.Assertions.assertEquals;

@ExtendWith(MockitoExtension.class)
public class BearServiceTest {
    @Mock
    Bear bear;

    @InjectMocks
    BearService bearService;

    @Test
    public void testItShouldReturnHelloFromBear() {
        String actual = bearService.say();
        assertEquals("Hello", actual);
    }
}

ถ้าเราใช้ JUnit 5 (มีคำว่า Jupiter) เวลาเราจะใช้ Mockito เราก็ใส่ @ExtendWith(MockitoExtension.class) ไว้บนคลาส ถ้าใครใช้ JUnit เวอร์ชั่นต่ำกว่านี้ ก็ให้ลง JUnit 5 ครับ อ่านไปอ่านบทความ ใช้ JUnit 5 + Mockito บน Spring Boot กันต่อได้

ทีนี้ @Mock กับ @InjectMock เนี่ยมันคืออะไรนะ? ผมขอใช้ประโยคง่ายๆ ละกัน

ตัว @Mock เป็นการบอกว่ามันคือ object ที่เราจะ mock นะ
ตัว @InjectMocks จะเป็นบอกว่า object ที่เราแปะหัวเนี่ย จะมีการ inject mock เข้าไปนะ

เสร็จแล้วก็ให้ลองรันเทสดูครับ มันควรจะ fail! 💥 เราจะเห็น error ประมาณนี้

expected: <Hello> but was: <null>

ดีใจได้เลยครับ มันแปลว่าเรา mock สำเร็จแล้ว 🎉 ทีนี้เราอยากแค่จะทดสอบนะ ว่า bear ที่เรา mock ไว้มันจะโดยเรียกจริงเปล่า? ต้องเขียนโค้ดอย่างไรนะ? จัดไปตามนี้ครับ เราจะใช้ verify กับ times จาก Mockito

package team.bears.mockito;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.times;

@ExtendWith(MockitoExtension.class)
public class BearServiceTest {
    @Mock
    Bear bear;

    @InjectMocks
    BearService bearService;

    @Test
    public void testItShouldReturnHelloFromBear() {
        bearService.say();
        verify(bear, times(1)).roar();
    }
}

แล้วถ้าเราอยากจะ Stub ตัว bear สามารถทำได้ด้วยหรือเปล่า? ทำได้ครับ จัดไปตามนี้ เราจะใช้ when จาก Mockito

package team.bears.mockito;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
public class BearServiceTest {
    @Mock
    Bear bear;

    @InjectMocks
    BearService bearService;

    @Test
    public void testItShouldReturnHelloFromBear() {
        when(bear.roar()).thenReturn("Grrrrr!");

        String actual = bearService.say();
        assertEquals("Grrrrr!", actual);

        verify(bear, times(1)).roar();
    }
}

โค้ดทั้งหมดที่ใช้ในบทความนี้อยู่ที่ GitHub นะครับ ลองเอาไปเล่นกันดู ตรงไหนปรับให้ดีขึ้นได้ ช่วยเปิด pull request มาให้ด้วยนะ 🤣

หลังจากโพสต์ลง Facebook ไป พี่ปุ๋ยมาให้คำแนะนำเกี่ยวกับ @InjectMocks ว่า

🙏 กราบขอบคุณพี่ปุ๋ยมา ณ ที่นี้ด้วยครับ ถ้าใครสนใจรายละเอียดเพิ่มเติมก็ลองไปอ่าน InjectMocks doc กันดูนะ

ทีนี้ผมขอมาแก้คลาส BearService สักเล็กน้อย สุดท้ายแล้วจะได้ตามนี้

package team.bears.mockito;

public class BearService {
    private Bear bear;

    public BearService(Bear bear) {
        this.bear = bear;
    }

    public String say() {
        return this.bear.roar();
    }
}

ที่นี้ก็น่าจะชัดเจนแล้วว่าตัว mock จะถูก inject เข้ามาที่ default constructor ของ BearService 🤓

We may be looking for "Work-Life Integration"

Kan Ouivirach — Mon, 06 Apr 2020 04:21:00 +0000

I found out that there is a term called "Work-Life Integration". I think it's quite interesting for all of us and I'd recommend everyone to check this article out.

See the definition of the term Work/Life Integration by BerkeleyHaas below:

Work/Life Integration instead is an approach that creates more synergies between all areas that define "life": work, home/family, community, personal well-being, and health.

I really like it.

สรุป Make learning part of the culture @ Google

Kan Ouivirach — Sun, 05 Apr 2020 00:45:59 +0000

เคยอ่านบทความ Make learning part of the culture เมื่อนานมาแล้ว กลับมาเขียนสรุปไว้เผื่อแวะมาอ่านกัน

คือที่ Google เค้ามีโปรแกรมภายในที่ชื่อ g2g (“Googlers-to-Googlers”) พูดง่ายๆ ว่ามันคือโปรแกรมสอนกันเองนี่แหละ และเค้ามี core belief ที่ทำให้ learning process ของเค้าเป็น "the best place to learn on the planet"

Learning is a process. - มันคือการมี motivation และการที่เราได้โอกาสฝึกฝนตัวเองรัวๆ และได้ feedback กับสิ่งที่เราทำ
Learning happens in real life. - เราเรียนรู้ และเจอสิ่งที่ท้าทาย ตลอดเวลาในชีวิตจริง
Learning is personal. - แต่ละคนมี learning style ที่แตกต่างกัน ผมเคยฟังโน้สอุดม เค้าพูดเปรียบว่าเด็กแต่ละคนเหมือนผลไม้คนละชนิดกัน บางคนเป็นมะนาว บางคนเป็นแตงโม ซึ่งผลไม้แต่ละชนิดนั้นมีช่วงเวลาที่ออกดอกออกผลที่แตกต่างกัน เราจะไปยัดเยียดวิธีเรียนรู้สำหรับคนที่เป็นมะนาว ให้กับคนที่แตงโม ไม่ได้.. โคตรจะจริง
Learning is social. - ที่ Google เค้าสนับสนุนสภาพแวดล้อมที่ทำให้ Googlers ทุกคนสามารถช่วยเหลือ และสนับสนุนกันได้ง่าย

พารากราฟสุดท้ายในบทความเป็นพารากราฟที่ผมชอบมาก ขอยกมาแปะไว้ตรงนี้ด้วย

The g2g team is often asked: “How do you motivate people to do something outside their core job?” The answer is actually pretty simple; trust people to do great work, give them tools and feedback, show them how it connects to the big picture, and then step aside. When the team focused their strategy around trust and support, participants have consistently exceeded expectations.

My Notes from the Book, "Read This Before Our Next Meeting", by Al Pittampalli

Kan Ouivirach — Fri, 14 Feb 2020 00:39:25 +0000

Meetings are expensive. They break workdays into a series of work moments. Interruptions force us to start over each time.

8 Principles of Modern Meetings

The modern meeting doesn't make decisions. Leaders do. -- A meeting might be helpful as part of decision-making process, but it isn't the decision-making process itself. Consult the team without calling a meeting. If the decision is of no consequence, don't call a meeting.
The modern meeting has 2 primary functions: conflict and coordination. -- For low consequence, the meeting is about coordination. Get the team on the same page. Allow the team to ask questions, voice concerns, and propose modifications. For high consequence, the meeting is about conflict. Encourage a robust, honest debate. Have the team submit their own thoughts about the issues before the meeting. Ask pros and cons. Let the best decision prevail, even if it's not yours.
The modern meeting moves fast and ends on schedule. -- Spend the time wisely since every minute costs us a fortune.
The modern meeting limits the number of attendees. -- Invite only people who are absolutely necessary. Don't waste the others' time.
The modern meeting rejects the unprepared. -- Prepare the agenda and a set of background materials. Every meeting should require pre-meeting work. If someone comes unprepared, cancel the meeting or hold it without him.
The modern meeting produces committed action plans. -- Actions should be clear for all. If no action plan is necessary, neither is a meeting.
The modern meeting refuses to be informational. Reading memos is mandatory. -- We must commit to reading the memos. Treat this agreement very seriously.
The modern meeting works only alongside a culture of brainstorming. -- Brainstorm is so crucial to the success of meeting. Modern meeting is focused in decision.

Initiate a Meeting?

Determine that the meeting is necessary?
Make a list of people to invite.
Create a detailed agenda.
Ask yourself again. Is the meeting really necessary?

How to Decide When We Have a Decision to Make?

Can I make this decision myself?
Is this a decision of high, low, or no consequence?
If a group is necessary, how and when should I involve them?
Does the opinion of someone else matter? Or are facts sufficient?
Can I do this with a series of one-on-one conversations instead of a meeting?
How much time should this decision take?

This book helps me a lot and I hope it does the same for you. 😃

Mutation Testing อีกทางหนึ่งในการวัดคุณภาพของการทดสอบ

Kan Ouivirach — Sat, 28 Dec 2019 06:08:57 +0000

เพิ่งรู้จัก Mutation Testing จากบทความ A demonstration of Mutation Testing

เค้าบอกว่าปกติแล้วเราจะใช้ test coverage เป็น metric ในการวัด quality ของเทสของเรา แต่ทีนี้มันเหมือนโกงได้ คือจริงๆ มันประมาณว่าถ้าเทสเรารันผ่านโค้ดทุกส่วน โดยเทสไม่ต้อง pass หรือ fail ก็ได้ มันก็ได้ 100% coverage แล้ว (เช่น เขียนเทส แต่ไม่เขียน assertion เลย) ทีนี้ก็เลยมีอีกทางหนึ่งนอกจาก coverage แล้วเนี่ย เรายังทำ mutation testing เพิ่มได้อีก

ไอเดียคือ… เราจะใช้ tool เพื่อใส่บั๊ก 🐛 หรือ mutants เข้าไปในโค้ดของเรา เพื่อให้เทส fail

ถ้าเทสเรา fail แปลว่าเราฆ่า mutant นั้นได้
ถ้าเทสเรา pass แปลว่า mutant นั้นยังมีชีวิตอยู่

เป้าหมายของเราคือฆ่า mutant ให้ได้เยอะที่สุด % ที่ mutant ตายยิ่งมาก ก็หมายความว่าเทสของเราก็ยิ่งมีประสิทธิภาพมากขึ้นด้วย 💪

ลองดูตัวอย่างการที่ tool ใส่ mutant เข้าไปในโค้ดเราได้ที่ Stryker Mutator: An example

หมายเหตุ ข้อเสียมันคือใช้เวลารันนาน… แหงล่ะ เล่นใส่ mutant มาในโค้ดแล้วก็รันเทสทดสอบทีละ mutant แบบนั้น ดังนั้นเราก็ไม่ควรใส่ไว้ใน build pipeline นะ เอาไว้เป็น tool สำหรับ review เทสของเราก็น่าจะพอ

Setting Up a Minimal Amazon ECS Cluster to Manage Multiple Applications

Kan Ouivirach — Thu, 26 Dec 2019 02:09:29 +0000

Outline

What is Amazon ECS?
Creating an ECS Cluster
Creating an Application Load Balancer (ALB)
Setting up an Application in the ECS cluster
Adding a Domain to ALB
Testing the Application

What is Amazon ECS?

I will not explain too much about it here. It's not the main point of this tutorial. Please read the quote below to get some idea what it is. 😆

Amazon Elastic Container Service (Amazon ECS) is a fully managed container orchestration service. Customers such as Duolingo, Samsung, GE, and Cook Pad use ECS to run their most sensitive and mission critical applications because of its security, reliability, and scalability.

Reference: Amazon ECS

Creating an ECS Cluster

Go to the ECS service and click "Create Cluster".

Select the "EC2 Linux + Networking" template. Don't worry if we don't see AWS Fargate here, we can set it later.

Fill in the information below. If we want to SSH into the EC2 instance, we need to specify the key pair. In this tutorial, we don't need it.

For networking, let's create a new VPC.

Use the default IAM role ecsInstanceRole. Specify the tags, so we can track the bill and keep our resources organized.

Once we finish, we should see the launch status as shown in the screenshot below.

We can then view the newly created cluster.

Creating an Application Load Balancer (ALB)

We need a load balancer to route requests to the destination. Let's create one. Go to the EC2 service then find the "Load Balancer" on the menu on the left. Click "Create Load Balancer".

Choose the Application Load Balancer.

Configure the ALB and choose the VPC we created from above in the Availability Zone section. Again, don't forget to add the tags.

In the step 2, we need a SSL certificate for it. We can set it later and can skip this for now.

For the security group, just create a new one.

For the routing configuration, create a new target group.

We can skip the register targets step. ECS will do it for us when we create a new service in ECS.

Wait until the ALB is provisioned.

Once the provision is finished, what we need to do is to update the security group rule on the EC2 instances where containers will run in the ECS cluster, so the ALB can access.

Go back to the ECS console, select the cluster, click on the tab "ECS Instances". We will see an instance is running. Click the ECS instance ID.

Click on the security group name.

Edit the inbound rule.

Select the security group previously created for the ALB. We're allowing all the traffic from the ALB to the instances since when working with ECS we can use a dynamic port mapping feature in order to run more containers with the same image in the same EC2 instances, so when starting our task, we won't specify any port to run applications and the ECS will do it for us.

Setting up an Application in the ECS cluster

In order to set up an application in the ECS cluster, we need to:

Create a task definition;
Create a service.

Creating a Task Definition

Go to the ECS console and click the "Task Definitions" on the left menu.

Choose the EC2 launch type.

Configure the task and container definitions.

Click "Add container" then.

To make it simple, we're using this public Docker image in this tutorial. Note that we can actually use any Docker image from either a public or private Docker image repository here.

We intentionally set the host port to 0 since it will be used to facilitate dynamic port allocation. The ALB dynamically allocate a port during the task placement.

Add the tags.

Check the "Auto-configure CloudWatch Logs", so we can view the log in CloudWatch. Just keep the default settings.

After that, we add the container and create the task definition.

Creating a Service

Let's create a service. This allow us to run and maintain a specified number of instances of a task definition simultaneously in the ECS cluster.

Configure the service.

For Load balancing, choose the Application Load Balancer. Click "Add to load balancer" to add the container to the load balancer.

Configure the container settings as follows.

Uncheck the "Enable service discovery integration" option. This is not necessary for now since we won't do anything in the Route 53 now.

After that, create the service.

Our application should be up and running soon.

Adding a Domain to ALB

This is the last step before we can access our application from the Internet. Go to our ALB and edit rules.

Create a new rule or edit the existing one like this. In this tutorial, choose the host header for the condition, then we set the domain my-test-zkan-bkk.prontotools.io.

Click "Update".

Testing the Application

If we have our own domain, we can point it to the ALB's DNS name.

If not, we can modify our hosts file. Get the ALB's IP with nslookup.

Modify the hosts file.

Done! 🍻🎄🎉

If we want to add a new application, just repeat the step 3 to 5 again. 😉

I've drawn a simple diagram to show how it will look like after complete those steps above. 👇

Hope this helps! 😇