อัพเดทบริการ AWS Proton ในปี 2025

บทความนี้แปลมาจากบทความภาษาญี่ปุ่นชื่อว่า AWS 入門ブログリレー 2024 〜AWS Proton編〜 โดยเจ้าของบทความนี้คือ คุณ トクヤマシュン

AWS Proton คืออะไร

AWS Proton เป็นบริการสำหรับการทำให้การจัดสรร (provisioning) และการปรับใช้ (deployment) ของโครงสร้างพื้นฐานในรูปแบบโค้ด (IaC: Infrastructure as Code) อัตโนมัติ ซึ่งทำงานบนแอปพลิเคชันที่ใช้ serverless และ container ในแง่ของประเภทบริการแล้ว AWS Proton จัดอยู่ในกลุ่ม provisioning service เช่น CloudFormation และ Elastic Beanstalk

ใน Proton สามารถสร้างเทมเพลตสำหรับการกำหนดค่าเซอร์วิสที่ใช้ Lambda หรือ ECS พร้อมทั้งจัดการเวอร์ชันได้ นอกจากนี้ยังสามารถสร้าง CI/CD pipeline สำหรับแอปพลิเคชันที่ทำงานบนเซอร์วิสเหล่านั้นได้อีกด้วย

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

ภาพรวมการทำงานของ Proton

ภาพรวมการทำงานเป็นไปตามแผนภาพด้านล่าง

อ้างอิง What is AWS Proton?

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

สิ่งที่ต้องรู้ก่อน

Character Role
มี 2 ประเภทดังนี้

• Administrators (ผู้ดูแลระบบ)
  • ผู้ที่รับผิดชอบการจัดการและการสร้างโครงสร้างพื้นฐานของ AWS โดยใช้ IaC (Infrastructure as Code)
  • บริการนี้เหมาะสำหรับผู้ดูแลที่ต้องการทำให้โครงสร้างพื้นฐานของ AWS เป็นมาตรฐานและจัดการเวอร์ชันได้อย่างมีประสิทธิภาพ
• Developers (นักพัฒนา)
  • นักพัฒนาที่ทำงานบนแอปพลิเคชันซึ่งทำงานบนบริการต่างๆ เช่น Lambda หรือ ECS
  • แม้แต่นักพัฒนาที่ไม่มีความเชี่ยวชาญในโครงสร้างพื้นฐานของ AWS ก็สามารถใช้โครงสร้างพื้นฐานได้โดยไม่ต้องคำนึงถึงการตั้งค่ารายละเอียด และสามารถทำให้แอปพลิเคชันที่พัฒนาขึ้นทำงานได้

แนวคิดของ Proton คือการแบ่งเส้นแบ่งระหว่าง Administrators และ Developers ให้ชัดเจน เพื่อให้แต่ละฝ่ายสามารถมุ่งเน้นไปที่การจัดสรร (provisioning) และการปรับใช้ (deployment) ภายในขอบเขตของตนเองได้อย่างมีประสิทธิภาพ

การจัดสรรทรัพยากร (Provisioning) ของ Environment (สภาพแวดล้อม) และ Service (บริการ)
ทรัพยากร AWS ที่ Proton จัดสรรสามารถแบ่งออกเป็นสองประเภทหลัก คือ Environment (สภาพแวดล้อม) และ Service (บริการ)

• Environment
  • ทรัพยากรอื่นๆ ที่ไม่ใช่คอมพิวเตอร์สำหรับการรันแอปพลิเคชัน
  • เช่น VPC, ECS Cluster, ELB, API Gateway, Cloud Map เป็นต้น
• Service
  • ทรัพยากรคอมพิวเตอร์และส่วนที่เกี่ยวข้องกับการปรับใช้แอปพลิเคชัน
  • เช่น ECS Service, ECS Task Definition, Lambda, ECR, CodePipeline เป็นต้น

ในคู่มือผู้ใช้ของ AWS Proton ได้อธิบายว่า "Environment (สภาพแวดล้อม)" จะถูกจัดการโดย Administrators ในขณะที่ "Service (บริการ)" จะถูกจัดการโดยทั้ง Administrators และ Developers ในการสร้างและอัปเดตบริการเหล่านี้ อย่างไรก็ตาม ในทางปฏิบัติ คุณสามารถปรับขอบเขตเหล่านี้ให้เหมาะสมกับสถานการณ์ขององค์กรของคุณได้

การตัดสินใจว่าจะแยกทรัพยากร AWS ออกเป็น Environment หรือ Service นั้นเป็นเพียงตัวอย่างหนึ่งเท่านั้น ไม่ใช่สิ่งที่ตายตัว ดังนั้น Administrators สามารถกำหนดตามที่สะดวกและเหมาะสมกับการทำงานได้

อ้างอิง How AWS Proton works

มีวิธีการ 3 แบบในการจัดสรร (provisioning) สภาพแวดล้อม (Environment) และบริการ (Service) เหล่านี้

• AWS Managed Provisioning
  • จัดสรรผ่าน Proton โดยใช้ CloudFormation
  • รองรับเฉพาะ CloudFormation เทมเพลต
• Self-managed Provisioning
  • Proton จะส่ง pull request ของไฟล์เทมเพลต Terraform ที่จะจัดสรรไปยัง Git repository ที่กำหนด
  • Proton จะทำงานถึงขั้นตอนนี้เท่านั้น
  • หลังจากที่ pull request ถูก merge แล้ว ผู้ปฏิบัติงานจะต้องเรียกใช้ terraform apply ด้วยตนเองเพื่อทำการจัดสรร
  • รองรับเฉพาะเทมเพลต Terraform
• CodeBuild Provisioning
  • จัดสรรโดยการรันงาน CodeBuild จาก Proton
  • รองรับ CDK (หรือ IaC ใดๆ ก็ตามที่สามารถรันคำสั่งบนโปรเจกต์การบิลด์ได้)

ควรเลือกวิธีการที่เหมาะสมตามภาษา IaC ที่องค์กรของคุณใช้งาน

Template Bundle

สภาพแวดล้อม (Environment) และบริการ (Service) ต่างๆ จะมี "เทมเพลต" ที่ถูกกำหนดด้วย IaC และมีการจัดการเวอร์ชัน เทมเพลตเหล่านี้จะประกอบด้วยหลายไฟล์และถูกจัดเป็น "Template Bundle" ตามรายการด้านล่าง

• IaC files
  • ไฟล์ที่บันทึกการตั้งค่าการจัดสรรโดยใช้ CloudFormation, Terraform, CDK เป็นต้น
  • หากเขียนสำหรับ Proton จะมีข้อกำหนดเฉพาะและต้องใช้การเขียนที่เป็นไปตามรูปแบบเฉพาะ
    • เช่น ในกรณีของ CloudFormation จำเป็นต้องระบุพารามิเตอร์ในรูปแบบ Jinja เป็นต้น
• Manifest File
  • ไฟล์ที่บันทึกชื่อไฟล์ IaC และวิธีการจัดสรร (provisioning)
• Schema files
  • ไฟล์ที่กำหนดพารามิเตอร์การป้อนข้อมูลสำหรับไฟล์ IaC

ใน Proton จะสร้างสภาพแวดล้อม (Environment) และบริการ (Service) ขึ้นโดยอ้างอิงจากเทมเพลตที่มีการจัดการเวอร์ชัน

กระบวนการทำงาน

ภาพการทำงานจะถูกนำมาแสดงอีกครั้ง

อ้างอิง What is AWS Proton?

① ผู้ดูแลระบบสร้างเทมเพลตสภาพแวดล้อมโดยการลงทะเบียนชุดเทมเพลตสภาพแวดล้อมใน Proton การลงทะเบียนชุดเทมเพลตสภาพแวดล้อมสามารถทำได้ด้วยตนเองหรือโดยใช้การตั้งค่าการซิงโครไนซ์

• Manual
  • อัปโหลดไฟล์ ZIP ที่บรรจุชุดเทมเพลตทั้งหมดไปยังบัคเก็ต S3
• การตั้งค่าการซิงโครไนซ์
  • ลงทะเบียนโดยการซิงโครไนซ์กับ Git repository
  • สามารถใช้ GitHub, GitHub Enterprise Server, และ BitBucket ได้

โดยทั่วไปแล้ว แนะนำให้ใช้การตั้งค่าการซิงโครไนซ์กับ Git repository

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

③ Administrators สร้างเทมเพลตบริการโดยการลงทะเบียนชุดเทมเพลตบริการใน Proton เช่นเดียวกับข้อ ① สามารถลงทะเบียนด้วยตนเองหรือใช้การตั้งค่าการซิงโครไนซ์ได้

⑥ (ข้อนี้สลับลำดับไว้เพื่อความเข้าใจง่าย)
Administrators หรือ Developers สร้างบริการจริงจากเทมเพลตบริการ บริการนี้สามารถรวมทรัพยากรการคำนวณเช่น ECS หรือ Lambda และยังสามารถรวม CI/CD pipeline เป็นตัวเลือกได้ด้วย

④ Developers อัปโหลดซอร์สโค้ดเพื่อเริ่ม CI/CD pipeline การอัปโหลดนี้สามารถทำได้ทั้งการลงทะเบียนด้วยตนเองและการตั้งค่าการซิงโครไนซ์ แต่เช่นเดียวกับข้อ ① และ ③ แนะนำให้ใช้การตั้งค่าการซิงโครไนซ์

⑤ CI/CD pipeline ทำการ build และ deploy จากซอร์สโค้ดของแอปพลิเคชัน และอัปเดตบริการที่ทำงานอยู่บนสภาพแวดล้อม

นี่คือภาพรวมของขั้นตอนการทำงานของ Proton

ลองสร้างแอปพลิเคชันที่ทำงานบนพื้นฐานของคอนเทนเนอร์ด้วย Proton

จากนี้ เราจะทดลองใช้งาน Proton จริงๆ ผ่านทาง management console เพื่อเป็นการสาธิต
มีบทแนะนำวิธีการเริ่มต้นใน AWS Management Console และมีเทมเพลตตัวอย่างให้ใช้ด้วย เราจะลองใช้สิ่งเหล่านี้
ในครั้งนี้ เราจะใช้วิธีการดังต่อไปนี้

• วิธีการ provision
  • AWS Managed (ใช้ CloudFormation)
• ชุดเทมเพลตสภาพแวดล้อม, ชุดเทมเพลตบริการ, ซอร์สโค้ดแอปพลิเคชัน
  • ซิงโครไนซ์จาก GitHub
• CI/CD pipeline
  • มี

แผนผังโครงสร้าง

โครงสร้างที่เราจะสร้างในครั้งนี้เป็นดังนี้

ที่มา : aws-proton-cloudformation-sample-templates/service-templates /backend-fargate-svc/

เราจะเริ่มเว็บเซิร์ฟเวอร์ nginx เป็นแอปพลิเคชันในบริการ ECS โดยมีการตั้งค่าบางอย่างที่ไม่เหมาะสม เช่น ECS task อยู่ใน public subnet และมี CloudMap (ซึ่งไม่ได้ใช้ในการสาธิตนี้) โดยเราจะลองมาแก้ไขกัน

การเตรียม Fork ของ GitHub repository

ก่อนอื่น หากคุณยังไม่มีบัญชี GitHub ให้สร้างบัญชีขึ้นมา
อ้างอิง: การสร้างบัญชีบน GitHub

ต่อไป เราจะเตรียมชุดเทมเพลตตัวอย่างและซอร์สโค้ดตัวอย่างในบัญชี GitHub ของคุณ
โดย AWS ได้จัดเตรียม repository ต่อไปนี้ให้ Fork ทั้งสอง repository เข้าสู่ repository GitHub ของคุณ

• Aws-proton-cloudformation-sample-templates
  • ชุดตัวอย่าง CloudFormation ที่ให้ชุดเทมเพลตสภาพแวดล้อมและชุดเทมเพลตบริการ
• Aws-proton-sample-services
  • ชุดตัวอย่างที่ให้ซอร์สโค้ดแอปพลิเคชันที่ทำงานบน ECS และ Lambda

อ้างอิง: การ Fork repository

เราจะอธิบายเนื้อหาของโค้ดอย่างคร่าวๆ สำหรับรายละเอียด กรุณาเข้าถึง repository โดยตรงและตรวจสอบโค้ดด้วยตนเอง

Environment Template Bundle

aws-proton-cloudformation-sample-templates/environment-templates/fargate-env เป็นชุดเทมเพลตสภาพแวดล้อมที่เราจะใช้ในครั้งนี้

โค้ดทั้งหมดสำหรับเวอร์ชันสภาพแวดล้อมที่เราจะสร้างในครั้งนี้อยู่ภายใต้โฟลเดอร์ v1 โดยผมจะอธิบายอย่างคร่าวๆ

infrastructure

• cloudformation.yaml

  • เป็น CloudFormation template ที่กำหนดทรัพยากรที่จะถูกสร้างโดย Environment template
  • กำหนดทรัพยากรต่างๆ เช่น VPC, Subnet, ECS Cluster
  • มีลักษณะเด่นคือใช้รูปแบบ Jinja ในการกำหนดพารามิเตอร์

• Manifest.yaml

  • ประกาศการใช้ AWS Managed Provisioning ด้วยการระบุ template_language: cloudformation
  • รายละเอียดอื่นๆ เกี่ยวกับชื่อ template และการใช้ Jinja เป็น rendering engine

schema

• schema.yaml
  • กำหนดรูปแบบของช่วง CIDR ที่จะใช้เป็นข้อมูลนำเข้า

Service Template Bundle

aws-proton-cloudformation-sample-templates/service-templates/backend-fargate-svc คือ Environment Template Bundle ที่เราจะใช้ในครั้งนี้

โค้ดทั้งหมดสำหรับเวอร์ชันสภาพแวดล้อมที่เราจะสร้างอยู่ในโฟลเดอร์ v1 ผมจะอธิบายโดยยกตัวอย่างบางส่วนดังนี้

• instance_infrastructure
  • cloudformation.yaml
    • เทมเพลต CloudFormation ที่กำหนดเป้าหมายสำหรับการโพรวิชันอินสแตนซ์บริการ (สิ่งที่ทำให้แอปทำงาน) จากเทมเพลตบริการ
    • กำหนด ECS Service และการกำหนดงาน (Task Definition) เป็นต้น
• pipeline_infrastructure
  • cloudformation.yaml
    • เทมเพลต CloudFormation ที่กำหนดเป้าหมายสำหรับการโพรวิชัน pipeline จากเทมเพลตบริการ
    • กำหนด ECR, CodeBuild และ CodePipeline
• schema
  • schema.yaml
    • กำหนดรูปแบบที่เป็นอินพุตสำหรับอินสแตนซ์บริการและ pipeline

Application Source Code

aws-proton-sample-services/ecs-backend เป็นโค้ดตัวอย่างของแอปพลิเคชันที่เราจะใช้ในครั้งนี้ ผมจะยกตัวอย่างบางส่วนและอธิบายอย่างคร่าวๆ

• app.py
  • นี่คือโค้ดของแอปพลิเคชันในครั้งนี้ ซึ่งทำงานบนเว็บเซิร์ฟเวอร์ nginx
  • มันจะส่งคืนค่าเป็น HTTP response เช่น {"response": "Hello from backend-svc. Time: Monday, May 02 2022, 15:26:06"}
• Dockerfile
  • ใช้ในขั้นตอนการบิลด์ของ pipeline

นี่คือคำอธิบายสั้นๆ เกี่ยวกับโค้ดตัวอย่างที่เราจะใช้ในครั้งนี้

การสร้าง AWS CodeConnections

หลังจากที่ทำการ Fork repository เข้าสู่ GitHub ของคุณแล้ว ให้ตั้งค่าการเชื่อมต่อไปยัง repository แต่ละอันผ่าน AWS CodeConnections (เดิมคือ CodeStar connection)

โปรดสร้างการเชื่อมต่อไปยัง GitHub โดยอ้างอิงจากลิงก์ด้านล่าง ในขั้นตอนนี้จะอนุญาตการเข้าถึงทุก repository แต่คุณสามารถจำกัดการอนุญาตเฉพาะ repository ที่จำเป็นได้ (โปรดอนุญาตสำหรับ repository ทั้ง 2 อัน ที่เรา Fork มาในครั้งนี้)

อ้างอิง: Create a connection to GitHub

การสร้าง environment templates and service templates

ต่อไป เราจะสร้างเทมเพลตสภาพแวดล้อมและเทมเพลตบริการ จากหน้าหลักของ AWS Proton ให้คลิกปุ่ม "Get started"

ขั้นตอนที่ 1 เป็นหน้าแนะนำ Proton มีคำศัพท์เฉพาะหลายคำ ดังนั้นจึงเป็นเรื่องดีที่มีการอธิบายอีกครั้ง หลังจากตรวจสอบแล้ว ให้คลิกปุ่ม "Next"

ขั้นตอนที่ 2 เป็นหน้าจอการตั้งค่าเริ่มต้น ที่นี่ให้เลือกการเชื่อมต่อ CodeConnections ที่เราสร้างไว้ก่อนหน้านี้

ต่อไป เราจะสร้าง IAM service role ที่ Proton จะใช้ในการโพรวิชัน pipeline ให้ตั้งค่าให้สร้าง service role ใหม่ และติ๊กที่ "New service role" เพื่อให้สิทธิ์ admin กับ role

เมื่อทำเสร็จแล้ว ให้คลิกปุ่ม "Next"

ขั้นตอนที่ 3 เป็นหน้าจอสร้างเทมเพลตสภาพแวดล้อม

ในครั้งนี้ เราจะรับชุดเทมเพลตจาก GitHub ดังนั้นเราจะตั้งค่าการซิงโครไนซ์ชุดเทมเพลตจาก Git

ในส่วนของ repository กำหนดเทมเพลต เนื่องจากเป็นครั้งแรกที่เราเชื่อมโยง Git repository กับ Proton ให้คลิก "Link another Git repository" แล้วตั้งค่า CodeConnection, repository และ branch เพื่อเชื่อมต่อกับ GitHub repository (aws-proton-cloudformation-sample-templates) ที่เรา Fork ไว้ก่อนหน้านี้

จากนั้นตั้งชื่อเทมเพลตสภาพแวดล้อมและชื่อที่แสดงให้เหมาะสม แล้วคลิกปุ่ม "Next"

ขั้นตอนสุดท้าย ขั้นตอนที่ 4 เป็นหน้าจอสร้างเทมเพลตบริการ เนื้อหาคล้ายกับเทมเพลตสภาพแวดล้อมเกือบทั้งหมด เราจะตั้งค่าเพื่อรับชุดเทมเพลตสำหรับเทมเพลตบริการจาก GitHub

ตั้งค่า CodeConnection, repository, branch, ชื่อเทมเพลตบริการ และชื่อที่แสดง

สำหรับการกำหนด pipeline เนื่องจากเทมเพลตตัวอย่างในครั้งนี้รวม CI/CD pipeline ไว้ด้วย ให้เลือกตัวเลือก "This template includes a CI/CD pipeline."

เมื่อเสร็จสิ้นแล้ว ให้คลิกปุ่ม "Complete"

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

ต่อจากนี้ เราจะเริ่มสร้างสภาพแวดล้อม คลิกปุ่ม "Create environment"

การสร้างสภาพแวดล้อม

เนื่องจากการสร้าง template เสร็จสิ้นแล้ว ตอนนี้เราจะสร้าง environment และ service จริงๆ

ก่อนอื่น มาสร้าง environment กัน คลิกปุ่ม "Create environment"

ในขั้นตอนที่ 1 ให้เลือก environment template เลือก template ที่เราเพิ่งสร้างไว้ แล้วคลิกปุ่ม "Configure"

ในขั้นตอนที่ 2 เราจะทำการตั้งค่าพื้นฐานสำหรับ environment เนื่องจากเราใช้ CloudFormation template ในครั้งนี้ จึงตั้งค่าวิธีการ provisioning เป็น "AWS Managed Provisioning"

สำหรับ deployment account ให้ตั้งค่าเป็น "This AWS account"

ในส่วนรายละเอียดของ environment ให้ตั้งชื่อ environment ที่ไม่ซ้ำกับที่มีอยู่

สำหรับ AWS Managed Provisioning role ให้ตั้งค่า service role ที่มีอยู่แล้ว โดยตั้งค่า IAM service role สำหรับ Proton ที่เราได้สร้างไว้ในการตั้งค่าเริ่มต้น

ส่วนอื่นๆ เป็นตัวเลือกเพิ่มเติมซึ่งไม่จำเป็นในครั้งนี้ จึงข้ามการตั้งค่าเหล่านั้น และคลิกปุ่ม "Next"

ในขั้นตอนที่ 3 เราจะกำหนดค่าการตั้งค่าแบบกำหนดเอง ที่นี่เราจะตั้งค่าค่าที่จะใช้เป็นข้อมูลนำเข้าเมื่อสร้าง environment ในครั้งนี้เราจะใช้ค่าเริ่มต้นที่กำหนดไว้ใน sample template โดยไม่เปลี่ยนแปลงอะไร และคลิกปุ่ม "Next"

ขั้นตอนที่ 4 เป็นหน้าสำหรับตรวจสอบ ให้ตรวจสอบข้อมูลทั้งหมด และหากไม่มีปัญหาใดๆ ให้คลิกปุ่ม "Create"

รอสักครู่ เมื่อสถานะเปลี่ยนเป็น "Succeeded" แสดงว่าการ deploy เสร็จสมบูรณ์แล้ว Proton จะสร้าง CloudFormation stack และสร้าง environment ตามที่เราได้กำหนดค่าไว้
เราสามารถตรวจสอบ Output ที่กำหนดไว้ใน CloudFormation จากหน้าจอของ Proton

การสร้าง Service

ต่อไป เราจะสร้าง service จาก service template คลิก "Create service" จากหน้าจอ service

ในขั้นตอนที่ 1 เราจะระบุ service template ให้เลือก template ที่เราได้สร้างไว้ก่อนหน้านี้

ในขั้นตอนที่ 2 เราจะทำการตั้งค่า service ให้ตั้งชื่อ service ที่ไม่ซ้ำกับที่มีอยู่ สำหรับ repository ของซอร์สโค้ดแอปพลิเคชัน แตกต่างจากที่ผ่านมา เราจำเป็นต้องระบุ repository aws-proton-sample-services

เลือก "Link another Git repository" และเลือก GitHub เป็น repository provider จากนั้นเลือก CodeStar connection ที่สร้างไว้ตั้งแต่แรก สำหรับ repository ให้ระบุเป็น aws-proton-sample-services และเลือก branch เป็น main ส่วน tag เป็นตัวเลือกเพิ่มเติมจึงข้ามไป แล้วคลิกปุ่ม "Next"

ในขั้นตอนที่ 3 เราจะตั้งค่า service instance

สำหรับแหล่งที่มาของคำจำกัดความ service ให้เลือก "Define your service directly in Proton" เพื่อตั้งค่าขนาดของ ECS task และอื่นๆ โดยตรงจาก console นอกจากนี้ เราสามารถตั้งค่า "Sync service from Git" เพื่อให้การตั้งค่าและอัปเดต service instance ทำได้โดยอัตโนมัติโดยใช้ไฟล์ "proton-ops" บน Git

ในส่วนการตั้งค่า service instance ให้ระบุชื่อ service instance ที่ไม่ซ้ำกัน และเลือก environment ที่เราสร้างไว้ก่อนหน้านี้ ส่วนอื่นๆ ให้ใช้ค่าเริ่มต้นที่กำหนดไว้ใน service template เป็นพารามิเตอร์นำเข้าของ service instance

สำหรับการนำเข้าข้อมูลของ Pipeline ให้ใช้ค่าเริ่มต้น แล้วคลิกปุ่ม "Next"

ในขั้นตอนที่ 4 ให้ตรวจสอบข้อมูลทั้งหมด และหากไม่มีปัญหาใดๆ ให้คลิกปุ่ม "Create"

หลังจากรอสักครู่ สถานะของ service จะเปลี่ยนเป็น Active และสถานะการ provisioning ของ pipeline จะเปลี่ยนเป็น Succeeded

เมื่อเป็นเช่นนี้ การสร้างก็เสร็จสมบูรณ์แล้ว เนื่องจาก pipeline กำลังทำงานอยู่
เราสามารถตรวจสอบที่แท็บ pipeline หลังจากรอสักครู่ ขั้นตอนจะดำเนินไปตามลำดับ Source-Build-Deploy และ service จะถูก deploy

เพียงเท่านี้ การ deploy ก็เสร็จสมบูรณ์แล้ว ทีนี้ เรามาตรวจสอบผลลัพธ์ของการ deploy กัน

จากหน้าจอ ECS ให้เข้าไปที่ ECS task ที่เกี่ยวข้อง → แท็บ Network คุณจะเห็น public IP address ให้คลิกที่ "open address" ที่อยู่ข้างๆ IP address นั้น

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

จนถึงตอนนี้ เราได้ตรวจสอบกระบวนการทั้งหมดของการสร้างโดยใช้ Proton เรียบร้อยแล้ว

การอัปเดต Pipeline

สุดท้าย เรามาลองอัปเดต pipeline กัน

ให้แก้ไขบรรทัดที่ 16 ของไฟล์ ecs-backend/app.py ใน repository aws-proton-sample-services โดยเปลี่ยนจาก Hello เป็น Bye

from flask import Flask
import json
import time

app = Flask(__name__)

@app.route("/ping", methods=["GET"])
def healthcheck():
    return "ok"

@app.route("/", methods=["GET"])
def inc():
    data = {
        "response": "Bye from backend-svc. Time: {}".format(
            time.strftime("%A, %B %d %Y, %H:%M:%S")
        )
    }
    response = app.response_class(
        response=json.dumps(data), status=200, mimetype="application/json"
    )
    return response

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=80)

หลังจากแก้ไขแล้ว ให้ทำการ git add, git commit และ git push เพื่ออัปเดตโค้ดบน GitHub

git push จะเป็นตัวกระตุ้นให้ pipeline เริ่มทำงาน คุณสามารถตรวจสอบการทำงานนี้ได้จากหน้าจอ service ของ Proton

หลังจากรอสักครู่ pipeline จะดำเนินการจนเสร็จสมบูรณ์

ในสถานะนี้ เมื่อเข้าถึง task เช่นเดียวกับที่ทำก่อนหน้านี้ คุณจะเห็นว่าคำว่า Bye ซึ่งเป็นข้อความที่อัปเดตแล้วจะถูกส่งกลับมาเป็น response

ด้วยวิธีนี้ เราสามารถรันไปป์ไลน์ที่สร้างด้วย Proton โดยใช้การอัปเดต GitHub repository เป็นตัวกระตุ้นได้สำเร็จ

การลบทรัพยากร

สุดท้าย เราจะทำการลบตามลำดับ คือ service ก่อน แล้วจึงลบ environment คุณสามารถลบแต่ละอย่างได้จากเมนู Actions ในหน้า console ของ Proton

การลบ service

การลบสภาพแวดล้อม

แม้ว่าจะลบ service และ environment แล้ว แต่ service template และ environment template จะไม่ถูกลบไปด้วย template เหล่านี้ไม่ได้มีค่าใช้จ่ายเพิ่มเติมแต่อย่างใด แต่เราจะลบ template เหล่านี้ด้วย

การลบ Environment templates

การลบ Service templates

สรุป

AWS Proton เป็นบริการที่ช่วยในการจัดการและอัตโนมัติการสร้างโครงสร้างพื้นฐาน (Infrastructure as Code) และการ deploy แอปพลิเคชันที่ทำงานบน serverless และ container-based

บทความต้นฉบับ

• AWS 入門ブログリレー 2024 〜AWS Proton編〜