โปรเจกต์ใน AWS

สร้างเว็บแอปพลิเคชันอันทันสมัย

ติดตั้งเว็บแอปพลิเคชันเพื่อใช้จริง เชื่อมต่อกับฐานข้อมูล และวิเคราะห์พฤติกรรมของผู้ใช้

โมดูลที่ 2: โฮสต์แอปพลิเคชันบนเว็บเซิร์ฟเวอร์

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

ภาพรวม

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

AWS Fargate เป็นตัวเลือกการติดตั้งใน Amazon Elastic Container Service (ECS) ที่ช่วยให้คุณสามารถปรับใช้ที่คอนเทนเนอร์ได้โดยไม่ต้องจัดการกับคลัสเตอร์หรือเซิร์ฟเวอร์ใด ๆ สำหรับแบ็คเอนด์ของ Mythical Mysfits เราจะใช้ Python และสร้างแอป Flask ในคอนเทนเนอร์ของ Docker ที่อยู่เบื้องหลัง Network Load Balancer สิ่งเหล่านี้จะสร้างแบ็คเอนด์ของไมโครเซอร์วิสสำหรับเว็บไซต์ฟรอนต์เอนด์

ทำไมเราถึงเลือก Fargate

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

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

คำแนะนำในการใช้งาน

ทำตามคำแนะนำแบบทีละขั้นตอนด้านล่างนี้เพื่อสร้างบริการ AWS Fargate ของคุณ เนื่องจากโมดูลนี้มีขนาดใหญ่ เราจึงแบ่งออกเป็น 3 โมดูลย่อย ในโมดูล 2a คุณจะได้ตั้งค่าโครงสร้างพื้นฐานหลักเพื่อเตรียมการติดตั้งบริการของคุณ ในโมดูล 2b คุณจะได้ติดตั้งบริการของคุณโดยใช้ AWS Fargate สุดท้ายในโมดูล 2c คุณจะได้ตั้งค่าการติดตั้งแบบอัตโนมัติโดยใช้บริการโค้ดของ AWS

โมดูล 2A: การตั้งค่าโครงสร้างพื้นฐานหลัก

ก่อนที่เราจะสร้างบริการของเราได้นั้น เราต้องสร้างสภาพแวดล้อมโครงสร้างพื้นฐานหลักที่บริการนั้นจะใช้งาน รวมถึงโครงสร้างพื้นฐานด้านระบบเครือข่ายใน Amazon VPC และ AWS Identity and Access Management Roles ที่จะกำหนดสิทธิ์ที่ ECS และคอนเทนเนอร์ของเราจะมีที่ด้านบนของ AWS

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

  • เราได้จัดเตรียมเทมเพลต CloudFormation เพื่อสร้างทรัพยากรเครือข่ายและความปลอดภัยที่จำเป็นทั้งหมดใน /module-2/cfn/core.yml โดยเทมเพลตจะสร้างทรัพยากรต่อไปนี้:

    • Amazon VPC - สภาพแวดล้อมเครือข่ายที่มี 4 เครือข่ายย่อย (แบบสาธารณะ 2 เครือข่าย และแบบส่วนตัว 2 เครือข่าย) ในพื้นที่ IP ส่วนตัว 10.0.0.0/16 เช่นเดียวกับการกำหนดค่าตารางเส้นทางที่จำเป็นทั้งหมด เครือข่ายย่อยสำหรับเครือข่ายนี้จะถูกสร้างใน Availability Zones (AZ) ของ AWS แยกกัน เพื่อให้มีความพร้อมใช้งานสูงในสิ่งอำนวยความสะดวกต่างๆ ทั่วภูมิภาคของ AWS เรียนรู้เพิ่มเติมเกี่ยวกับวิธีที่ AZ สามารถช่วยให้คุณมีความพร้อมใช้งานสูง
    • 2 เกตเวย์ NAT (1 เกตเวย์สำหรับแต่ละเครือข่ายย่อยแบบส่วนตัว) - อนุญาตให้คอนเทนเนอร์ที่เราจะติดตั้งในเครือข่ายย่อยแบบส่วนตัวของเราเชื่อมต่อกับอินเทอร์เน็ตเพื่อดาวน์โหลดแพ็คเกจที่จำเป็น และอื่นๆ
    • ตำแหน่งข้อมูล VPC ของ DynamoDB - บริการไมโครเซอร์วิสแบ็คเอนด์ของเราจะรวมเข้ากับ Amazon DynamoDB เพื่อความคงที่ (เป็นส่วนหนึ่งของโมดูลที่ 3)
    • กลุ่มความปลอดภัย - อนุญาตให้คอนเทนเนอร์ Docker ของคุณรับปริมาณการใช้งานบนพอร์ต 8080 จากอินเทอร์เน็ตผ่าน Network Load Balancer
    • บทบาท IAM - บทบาทต่างๆ ใน Identity and Access Management ถูกสร้างขึ้น สิ่งเหล่านี้จะถูกใช้ตลอดทั้งการเวิร์คช็อปเพื่อให้บริการของ AWS หรือทรัพยากรที่คุณสร้างเข้าถึงบริการของ AWS อื่นๆ เช่น DynamoDB S3 เป็นต้น

    ในการสร้างทรัพยากรเหล่านี้ ให้เรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล Cloud9 (จะใช้เวลาประมาณ 10 นาทีในการสร้างสแตก):

    aws cloudformation create-stack --stack-name MythicalMysfitsCoreStack --capabilities CAPABILITY_NAMED_IAM --template-body file://~/environment/aws-modern-application-workshop/module-2/cfn/core.yml

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

    aws cloudformation describe-stacks --stack-name MythicalMysfitsCoreStack

    เรียกใช้คำสั่งอธิบายสแตก จนกระทั่งคุณเห็นสถานะของ"StackStatus": "CREATE_COMPLETE"

    อธิบายสแตก

    (คลิกเพื่อซูม)

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

    คุณจะได้ใช้ค่าจากเอาต์พุตของคำสั่งนี้ตลอดการเวิร์กช็อปที่เหลือ คุณสามารถเรียกใช้คำสั่งต่อไปนี้เพื่อส่งออกคำสั่งอธิบายสแตกด้านบนไปยังไฟล์ใหม่ใน IDE ของคุณโดยตรง ซึ่งจะถูกเก็บไว้ที่ cloudformation-core-output.json:

    aws cloudformation describe-stacks --stack-name MythicalMysfitsCoreStack > ~/environment/cloudformation-core-output.json

โมดูล 2B: ติดตั้งบริการด้วย AWS Fargate

ถัดไป คุณจะได้สร้างคอนเทนเนอร์ของอิมเมจ Docker ที่มีโค้ดและการกำหนดค่าที่จำเป็นทั้งหมดสำหรับการเรียกใช้แบ็คเอนด์ของ Mythical Mysfits ในรูปแบบของ API ไมโครเซอร์วิสที่ถูกสร้างด้วย Flask เราจะสร้างคอนเทนเนอร์ของอิมเมจ Docker ภายใน Cloud9 จากนั้นพุชไปที่ Amazon Elastic Container Registry ซึ่งจะสามารถดึงมาใช้งานได้เมื่อเราสร้างบริการของเราโดยใช้ Fargate

แผนผังสถาปัตยกรรม

เบราว์เซอร์ไปที่โหลดบาลานเซอร์เพื่อไปที่ Fargate
  • A: สร้างอิมเมจ Docker

    โค้ดทั้งหมดที่จำเป็นสำหรับการเรียกใช้บริการแบ็คเอนด์ของเราจะถูกเก็บไว้ในไดเรกทอรี /module-2/app/ ของพื้นที่เก็บข้อมูลที่คุณได้โคลนไว้ใน Cloud9 IDE ของคุณ หากคุณต้องการตรวจสอบโค้ด Python ที่ใช้ Flask ในการสร้าง API บริการ ให้ดูที่ไฟล์ /module-2/app/service/mythicalMysfitsService.py

    เมื่อได้ติดตั้ง Docker บน Cloud9 IDE ที่คุณสร้างขึ้นแล้ว ดังนั้น ในการที่จะสร้างอิมเมจ Docker ภายในระบบ สิ่งที่เราต้องทำคือเรียกใช้คำสั่ง 2 รายการต่อไปนี้ในเทอร์มินัล Cloud9:  

    เริ่มต้นเปลี่ยนไดเรกทอรีเป็น ~/environment/module-2/app

    cd ~/environment/aws-modern-application-workshop/module-2/app

    คุณสามารถรับ ID บัญชีและเขตเริ่มต้นของคุณจากเอาต์พุตของ CloudFormation ก่อนหน้านี้ **อธิบายสแตก

    แทนที่ REPLACE_ME_ACCOUNT_ID ด้วย ID บัญชีของคุณและ REPLACE_ME_REGION ด้วยเขตเริ่มต้นในคำสั่งต่อไปนี้ เพื่อสร้างอิมเมจ Docker โดยใช้ไฟล์ Dockerfile ซึ่งมีคำแนะนำเกี่ยวกับ Docker คำสั่งแท็กอิมเมจ Docker โดยใช้ตัวเลือก -t พร้อมกับรูปแบบแท็กเฉพาะเพื่อให้สามารถพุชอิมเมจไปยังบริการ Amazon Elastic Container Registry ได้ในภายหลัง

    เมื่อคุณมี ID บัญชีของคุณ คุณก็พร้อมที่จะสร้างอิมเมจ Docker แล้ว:

    docker build . -t REPLACE_ME_AWS_ACCOUNT_ID.dkr.ecr.REPLACE_ME_REGION.amazonaws.com/mythicalmysfits/service:latest

    คุณจะเห็น Docker ดาวน์โหลดและติดตั้งแพคเกจซึ่งขึ้นต่อกันที่จำเป็นทั้งหมดที่แอปพลิเคชันของเราต้องการ และส่งออกแท็กสำหรับอิมเมจที่สร้างขึ้น คัดลอกแท็กอิมเมจเพื่อใช้อ้างอิงในภายหลัง ด้านล่างแท็กตัวอย่างที่แสดงคือ: 111111111111.dkr.ecr.us-east-1.amazonaws.com/mythicalmysfits/service:latest

    Successfully built 8bxxxxxxxxab
    Successfully tagged 111111111111.dkr.ecr.us-east-1.amazonaws.com/mythicalmysfits/service:latest
    B: ทดสอบบริการในระบบ

    ลองทดสอบอิมเมจของเราภายในระบบใน Cloud9 เพื่อให้แน่ใจว่าทุกอย่างทำงานได้ตามที่คาดไว้ คัดลอกแท็กอิมเมจที่เป็นผลมาจากคำสั่งก่อนหน้าและ เรียกใช้คำสั่งต่อไปนี้ เพื่อติดตั้งคอนเทนเนอร์แบบ “ในระบบ” (ซึ่งจริงๆ แล้วอยู่ภายใน Cloud9 IDE ใน AWS ของคุณ!):

    docker run -p 8080:8080 REPLACE_ME_WITH_DOCKER_IMAGE_TAG

    ดังนั้น คุณจะเห็น Docker รายงานว่าคอนเทนเนอร์ของคุณถูกติดตั้งและทำงานแบบภายในระบบ:

     * Running on http://0.0.0.0:8080/ (Press CTRL+C to quit)

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

    หากต้องการดูเว็บเบราว์เซอร์ตัวอย่าง เลือก ดูตัวอย่าง > ดูตัวอย่างแอปพลิเคชันที่กำลังใช้งานอยู่ในแถบเมนู Cloud9:

    preview-menu

     

    นี่จะเป็นการเปิดแถบอีกหนึ่งแถบใน IDE ซึ่งจะมีเว็บเบราว์เซอร์ให้ใช้งาน ผนวก /mysfits ต่อท้าย URI ในแถบที่อยู่ของเบราว์เซอร์ตัวอย่าง และกด ENTER:

    address-bar

    หากสำเร็จ คุณจะเห็นการตอบสนองจากบริการที่ส่งคืนเอกสาร JSON ที่เก็บไว้ที่ `/aws-modern-application-workshop/module-2/app/service/mysfits-response.json`

    เมื่อเสร็จสิ้นการทดสอบบริการ คุณสามารถหยุดได้โดยกด CTRL-c บนพีซีหรือ Mac

    C: พุชอิมเมจ Docker ไปยัง Amazon ECR

    เมื่อการทดสอบบริการในระบบประสบความสำเร็จ เราพร้อมที่จะสร้างพื้นที่เก็บข้อมูลคอนเทนเนอร์ของอิมเมจใน Amazon Elastic Container Registry (Amazon ECR) และพุชอิมเมจของเราไปไว้ในนั้น ในการสร้างการลงทะเบียน ให้เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างพื้นที่เก็บข้อมูลใหม่ในรีจิสทรีของ AWS ECR เริ่มต้นที่สร้างขึ้นสำหรับบัญชีของคุณ

    aws ecr create-repository --repository-name mythicalmysfits/service

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

    เรียกใช้คำสั่งต่อไปนี้ ซึ่งจะแสดงคำสั่งเข้าสู่ระบบเพื่อดึงข้อมูลประจำตัวของไคลเอ็นต์ Docker ของเราแล้วดำเนินการโดยอัตโนมัติ (รวมถึงคำสั่งแบบเต็มรูปแบบที่มี $ ตามด้านล่าง) 'เข้าสู่ระบบสำเร็จ' จะถูกรายงานหากคำสั่งนั้นสำเร็จ

    $(aws ecr get-login --no-include-email)

    ถัดไป พุชอิมเมจที่คุณสร้างขึ้นไปยังพื้นที่เก็บข้อมูล ECR โดยใช้การคัดลอกแท็กจากด้านบน เมื่อใช้คำสั่งนี้ Docker จะพุชอิมเมจของคุณและอิมเมจทั้งหมดขึ้นอยู่กับ Amazon ECR:

    docker push REPLACE_ME_WITH_DOCKER_IMAGE_TAG

    เรียกใช้คำสั่งต่อไปนี้ เพื่อดูอิมเมจ Docker ที่เพิ่งถูกพุชไปเก็บไว้ที่พื้นที่เก็บข้อมูลของ ECR:

    aws ecr describe-images --repository-name mythicalmysfits/service
  • A: สร้างคลัสเตอร์ AWS Fargate

    ตอนนี้ เรามีอิมเมจที่พร้อมใช้งานใน ECR ซึ่งสามารถติดตั้งกับบริการที่ถูกโฮสต์บน Amazon ECS ได้ โดยใช้ AWS Fargate บริการเดิมที่คุณได้ทดสอบในระบบผ่านเทอร์มินัลใน Cloud9 ซึ่งเป็นส่วนหนึ่งของโมดูลล่าสุดจะถูกติดตั้งในระบบคลาวด์และให้บริการแบบสาธารณะเบื้องหลัง Network Load Balancer

    ขั้นแรก เราจะทำการสร้างคลัสเตอร์ใน Amazon Elastic Container Service (ECS) ซึ่งจะแสดงถึงคลัสเตอร์ของ “เซิร์ฟเวอร์” ที่เก็บคอนเทนเนอร์ของบริการของคุณจะถูกติดตั้ง เซิร์ฟเวอร์จะอยู่ใน “เครื่องหมายอัญประกาศ” เนื่องจากคุณจะใช้ AWS Fargate โดย Fargate ช่วยให้คุณระบุว่าคอนเทนเนอร์ใดของคุณจะถูกติดตั้งกับคลัสเตอร์โดยไม่ต้องเตรียมหรือจัดการเซิร์ฟเวอร์ใดๆ ด้วยตัวคุณเอง

    ในการสร้างคลัสเตอร์ใหม่ใน ECS ให้เรียกใช้คำสั่งต่อไปนี้:

    aws ecs create-cluster --cluster-name MythicalMysfits-Cluster
    B: สร้างกลุ่ม AWS CloudWatch Logs

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

    ในการสร้างกลุ่มบันทึกใหม่ใน CloudWatch logs ให้เรียกใช้คำสั่งต่อไปนี้:

    aws logs create-log-group --log-group-name mythicalmysfits-logs
    C: ลงทะเบียนคำจำกัดความของงาน ECS

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

    ไฟล์ JSON ถูกจัดเตรียมไว้เพื่อใช้เป็นอินพุตไปยังคำสั่ง CLI

    เปิด ~/environment/aws-modern-application-workshop/module-2/aws-cli/task-definition.json ใน IDE

    แทนที่ค่าที่ถูกระบุ ด้วยค่าที่เหมาะสมจากทรัพยากรที่คุณสร้างขึ้น

    ค่านี้จะถูกดึงจากการตอบสนองของ CloudFormation ที่คุณได้คัดลอกก่อนไว้หน้านี้ เช่นเดียวกับแท็กอิมเมจ Docker ที่คุณพุชไปที่ ECR ตัวอย่าง: REPLACE_ME_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/mythicalmysfits/service:latest

    เมื่อคุณแทนที่ค่าใน task-definition.json และบันทึกไว้ ใช้คำสั่งต่อไปนี้เพื่อลงทะเบียนคำจำกัดความของงานใหม่ใน ECS:

    aws ecs register-task-definition --cli-input-json file://~/environment/aws-modern-application-workshop/module-2/aws-cli/task-definition.json
  • A: สร้าง Network Load Balancer

    เมื่อมีการลงทะเบียนคำจำกัดความของงานใหม่แล้ว เราก็จะเตรียมโครงสร้างพื้นฐานที่จำเป็นในสแตกบริการของเรา แทนที่จะแสดงบริการของเราโดยตรงบนอินเทอร์เน็ต เราจะเตรียม Network Load Balancer (NLB) เพื่อเป็นด่านหน้าของระดับการบริการของเรา ซึ่งจะช่วยให้โค้ดเว็บไซต์ฟรอนต์เอนด์ของเราสามารถเชื่อมต่อกับ DNS แบบเดี่ยวได้ ในขณะที่บริการแบ็คเอนด์ของเราจะสามารถปรับขนาดเข้า-ออกในแบบยืดหยุ่นได้ตามความต้องการ หรือหากเกิดความล้มเหลวและต้องมีการจัดเตรียมคอนเทนเนอร์ใหม่

    ในการจัดเตรียม NLB ใหม่ให้เรียกคำสั่ง CLI ต่อไปนี้ ในเทอร์มินัล Cloud9 (ดึงข้อมูล SubnetIds จากเอาต์พุต CloudFormation ที่คุณบันทึกไว้):

    aws elbv2 create-load-balancer --name mysfits-nlb --scheme internet-facing --type network --subnets REPLACE_ME_PUBLIC_SUBNET_ONE REPLACE_ME_PUBLIC_SUBNET_TWO > ~/environment/nlb-output.json

    เมื่อคำสั่งนี้เสร็จสมบูรณ์ ไฟล์ใหม่จะถูกสร้างขึ้นใน IDE ของคุณโดยมีชื่อว่า nlb-output.json คุณจะได้ใช้ DNSName, VpcId และ LoadBalancerArn ในขั้นตอนต่อไป

    B: สร้างกลุ่มเป้าหมายของโหลดบาลานเซอร์

    ถัดไป ใช้ CLI เพื่อสร้างกลุ่มเป้าหมาย NLB กลุ่มเป้าหมายจะอนุญาตให้ทรัพยากร AWS ลงทะเบียนเป็นเป้าหมายสำหรับคำขอที่โหลดบาลานเซอร์ได้รับเพื่อทำการส่งต่อ บริการคอนเทนเนอร์ของเราจะลงทะเบียนไปยังเป้าหมายนี้โดยอัตโนมัติ เพื่อให้สามารถรับปริมาณการใช้งานจาก NLB เมื่อได้รับการจัดสรรแล้ว คำสั่งนี้มีหนึ่งค่าที่จะต้องถูกเปลี่ยน คือ vpc-id ซึ่งคุณสามารถพบเป็นค่าในเอาต์พุตภายใน MythicalMysfitsCoreStack ที่ถูกบันทึกไว้ก่อนหน้านี้ จะถูกส่งคืนโดย CloudFormation

    aws elbv2 create-target-group --name MythicalMysfits-TargetGroup --port 8080 --protocol TCP --target-type ip --vpc-id REPLACE_ME_VPC_ID --health-check-interval-seconds 10 --health-check-path / --health-check-protocol HTTP --healthy-threshold-count 3 --unhealthy-threshold-count 3 > ~/environment/target-group-output.json

    เมื่อคำสั่งนี้เสร็จสมบูรณ์ เอาต์พุตจะถูกบันทึกไปยัง target-group-output.json ใน IDE ของคุณ คุณจะอ้างอิงค่า TargetGroupArn ในขั้นตอนถัดไป

    C: สร้างกระบวนการรอรับโหลดบาลานเซอร์

    ถัดไป ใช้ CLI เพื่อสร้างกระบวนการรอรับโหลดบาลานเซอร์สำหรับ NLB ซึ่งจะแจ้งว่าโหลดบาลานเซอร์สำหรับคำขอที่ได้รับบนพอร์ตเฉพาะ ควรส่งต่อไปยังเป้าหมายที่ได้ลงทะเบียนไว้ไปยังกลุ่มเป้าหมายด้านบน ตรวจดูให้แน่ใจว่าได้แทนที่ค่าที่ระบุทั้งสองด้วย ARN ที่เหมาะสมจาก TargetGroup และ NLB ที่คุณได้บันทึกไว้จากขั้นตอนก่อนหน้านี้:

    aws elbv2 create-listener --default-actions TargetGroupArn=REPLACE_ME_NLB_TARGET_GROUP_ARN,Type=forward --load-balancer-arn REPLACE_ME_NLB_ARN --port 80 --protocol TCP
  • A: สร้างหน้าที่เชื่อมโยงบริการสำหรับ ECS

    หากคุณเคยใช้ ECS มาก่อนแล้ว คุณสามารถข้ามขั้นตอนนี้และไปยังขั้นตอนถัดไปได้เลย หากคุณยังไม่เคยใช้ ECS มาก่อน เราจำเป็นต้องสร้าง **บทบาทที่เชื่อมต่อกับบริการ** ใน IAM ที่ให้สิทธิ์แก่บริการ ECS ในการสร้างคำขอ API ECS ภายในบัญชีของคุณ ซึ่งเป็นสิ่งจำเป็น เพราะเมื่อคุณสร้างบริการใน ECS บริการนี้จะเรียก API ภายในบัญชีของคุณเพื่อดำเนินการต่างๆ เช่น การดึงอิมเมจ Docker การสร้างงานใหม่ ฯลฯ

    หากไม่มีการสร้างบทบาทนี้ บริการ ECS จะไม่ได้รับอนุญาตให้ดำเนินการที่จำเป็น ในการสร้างบทบาทนี้ ให้ใช้คำสั่งต่อไปนี้ในเทอร์มินัล:  

    aws iam create-service-linked-role --aws-service-name ecs.amazonaws.com

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

    B: สร้างบริการ

    ด้วย NLB ที่ถูกสร้างและกำหนดค่าแล้ว และบริการ ECS ได้รับสิทธิ์ที่เหมาะสม เราก็พร้อมที่จะสร้าง **บริการ** ECS จริง โดยที่คอนเทนเนอร์ของเราจะทำงานและลงทะเบียนตัวเองกับโหลดบาลานเซอร์เพื่อรับปริมาณการใช้งาน เราได้เพิ่มไฟล์ JSON สำหรับอินพุต CLI ไว้ที่: `~ / environment / aws-modern-application-workshop / module-2 / aws-cli / service-definition.json` ไฟล์นี้มีรายละเอียดการกำหนดค่าทั้งหมดสำหรับบริการที่จะสร้าง รวมถึงระบุว่าบริการนี้ควรจะเปิดใช้ด้วย **AWS Fargate** - ซึ่งหมายความว่าคุณไม่จำเป็นต้องจัดเตรียมเซิร์ฟเวอร์ใดๆ ภายในคลัสเตอร์เป้าหมาย คอนเทนเนอร์ที่ถูกกำหนดเวลาไว้เป็นส่วนหนึ่งของงานที่ใช้ในบริการนี้ จะทำงานบนคลัสเตอร์ที่ถูกจัดการโดย AWS อย่างสมบูรณ์

    เปิด ~ / environment / aws-modern-application-workshop / module-2 / aws-cli / service-definition.json ใน IDE และแทนที่ค่าที่ระบุไว้ของ REPLACE_ME ทำการบันทึก จากนั้นเรียกใช้คำสั่งต่อไปนี้เพื่อสร้างบริการ:

    aws ecs create-service --cli-input-json file://~/environment/aws-modern-application-workshop/module-2/aws-cli/service-definition.json
    C: ทดสอบบริการ

    คัดลอกชื่อ DNS ที่คุณได้บันทึกไว้ตอนที่สร้าง NLB และส่งคำขอโดยใช้เบราว์เซอร์แสดงตัวอย่างใน Cloud9 (หรือโดยเว็บเบราว์เซอร์ใดก็ได้ เนื่องจากบริการของเราพร้อมให้บริการบนอินเทอร์เน็ตแล้ว) ลองส่งคำขอไปยังทรัพยากร mysfits:

    http://mysfits-nlb-123456789-abc123456.elb.us-east-1.amazonaws.com/mysfits

    การตอบสนองที่แสดงการตอบสนองของ JSON แบบเดียวกันที่เราได้รับก่อนหน้านี้เมื่อทำการทดสอบคอนเทนเนอร์ Docker ภายในระบบใน Cloud9 หมายความว่า API Flask ของคุณเริ่มทำงานบน AWS Fargate แล้ว

    หมายเหตุ: Network Load Balancer นี้ รองรับคำขอ HTTP (http://) เท่านั้น เนื่องจากไม่มีใบรับรอง SSL/TLS ติดตั้งอยู่ สำหรับบทแนะนำสอนการใช้งานนี้ โปรดตรวจดูให้แนใจว่าได้ส่งคำขอโดยใช้ http:// เท่านั้น หากใช้ https:// คำขอจะทำงานไม่สมบูรณ์

  • A: แทนที่ตำแหน่งข้อมูล API

    ถัดไป เราต้องผสานรวมเว็บไซต์ของเราเข้ากับ API แบ็คเอนด์ใหม่ของคุณแทนการใช้ข้อมูลฮาร์ดโค้ดที่เราเคยอัปโหลดไปยัง S3 ก่อนหน้านี้ คุณจะต้องอัปเดตไฟล์ต่อไปนี้เพื่อใช้ URL NLB เดียวกันสำหรับการเรียก API (ไม่รวมเส้นทาง /mysfits): /module-2/web/index.html

    เปิดไฟล์ใน Cloud9 และแทนที่พื้นที่ที่ไฮไลต์ด้านล่างระหว่างเครื่องหมายอัญประกาศด้วย URL ของ NLB:

    before-replace

    หลังจากวางแล้ว บรรทัดนั้นควรมีลักษณะคล้ายกับด้านล่างนี้:

    after-replace
    B: อัปโหลดไปยังS3

    ในการอัปโหลดไฟล์นี้ไปยังเว็บไซต์โฮสต์ S3 ของคุณ ให้ใช้ชื่อบัคเก็ตอีกครั้ง ที่สร้างขึ้นระหว่างโมดูล 1 และเรียกใช้คำสั่งต่อไปนี้:

    aws s3 cp ~/environment/aws-modern-application-workshop/module-2/web/index.html s3://INSERT-YOUR-BUCKET-NAME/index.html

    เปิดเว็บไซต์ของคุณโดยใช้ URL เดียวกันกับที่ใช้ในตอนท้ายของโมดูล 1 เพื่อดูเว็บไซต์ Mythical Mysfits ใหม่ของคุณ ที่กำลังดึงข้อมูล JSON จาก API Flask ที่ทำงานอยู่ภายในคอนเทนเนอร์ Docker ที่ติดตั้งใน AWS Fargate!

โมดูล 2C: การติดตั้งอัตโนมัติโดยใช้บริการโค้ดของ AWS

ตอนนี้ เมื่อคุณมีบริการที่ทำงานแล้ว คุณอาจอยากเปลี่ยนแปลงโค้ดที่คุณต้องการใช้กับบริการ Flask ของคุณ ซึ่งหากคุณต้องทำตามขั้นตอนข้างต้นทุกครั้งที่ต้องการติดตั้งฟีเจอร์ใหม่ให้กับบริการของคุณ อาจจะทำให้ความเร็วในการพัฒนาของคุณเกิดความล่าช้าได้ นั่นคือเหตุผลที่มีการนำการผสานการทำงานอย่างต่อเนื่องและการส่งมอบอย่างต่อเนื่อง หรือ CI/CD มาใช้!

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

แผนผังสถาปัตยกรรม

สร้างสถาปัตยกรรมเว็บไซต์แบบไดนามิก - cloud9, เครื่องมือโค้ด, fargate
  • ก: สร้างบัคเก็ต S3 สำหรับสิ่งประดิษฐ์ไปป์ไลน์

    เราจะต้องสร้างบัคเก็ต S3 อีกหนึ่งชุดเพื่อใช้ในการเก็บสิ่งประดิษฐ์ชั่วคราวที่สร้างขึ้นในระหว่างการประมวลผลไปป์ไลน์ CI/CD ของเรา เลือกชื่อบัคเก็ตใหม่สำหรับสิ่งประดิษฐ์เหล่านี้และสร้างอีกหนึ่งรายการโดยใช้คำสั่ง CLI ต่อไปนี้:

    aws s3 mb s3://REPLACE_ME_CHOOSE_ARTIFACTS_BUCKET_NAME

    ถัดไป บัคเก็ตนี้ต้องมีนโยบายบัคเก็ตเพื่อกำหนดสิทธิ์สำหรับข้อมูลที่เก็บไว้ภายใน แต่ต่างจากบัคเก็ตเว็บไซต์ของเราที่อนุญาตให้เข้าถึงใครก็ได้ เฉพาะแค่ไปป์ไลน์ CI/CD เท่านั้นที่มีสิทธิ์เข้าถึงบัคเก็ตนี้ เราได้จัดเตรียมไฟล์ JSON ที่จำเป็นสำหรับนโยบายนี้ที่ ~/environment/aws-modern-application-workshop/module-2/aws-cli/artifacts-bucket-policy.json

    เปิดไฟล์นี้ และแทนที่สตริงหลายรายการภายในนั้นเพื่อรวมกับ ARN ที่ถูกสร้างขึ้นให้เป็นส่วนหนึ่งของ MythicalMysfitsCoreStack ก่อนหน้านี้ รวมทั้งชื่อบัคเก็ตใหม่ที่คุณเลือกสำหรับสิ่งประดิษฐ์ CI/CD ของคุณ

    เมื่อคุณแก้ไขและบันทึกไฟล์นี้แล้ว ให้เรียกใช้คำสั่งต่อไปนี้เพื่อให้สิทธิ์การเข้าถึงบัคเก็ตนี้กับไปป์ไลน์ CI/CD ของคุณ:

    aws s3api put-bucket-policy --bucket REPLACE_ME_ARTIFACTS_BUCKET_NAME --policy file://~/environment/aws-modern-application-workshop/module-2/aws-cli/artifacts-bucket-policy.json
    B: สร้างพื้นที่เก็บข้อมูล CodeCommit

    คุณจะต้องมีพื้นที่สำหรับพุชและเก็บโค้ดของคุณ สร้าง **พื้นที่เก็บข้อมูล AWS CodeCommit** โดยใช้ CLI เพื่อจุดประสงค์นี้:

    aws codecommit create-repository --repository-name MythicalMysfitsService-Repository
    C: สร้างโปรเจกต์ CodeBuild

    ด้วยพื้นที่เก็บข้อมูลเพื่อใช้เก็บโค้ดของเรา และบัคเก็ต S3 ที่จะถูกใช้สำหรับสิ่งประดิษฐ์ CI/CD ของเรา ให้เพิ่มไปยังสแตก CI/CD ด้วยวิธีการสร้างบริการที่จะเกิดขึ้น สิ่งนี้จะสำเร็จได้ด้วยการสร้างโปรเจกต์ AWS CodeBuild Project เมื่อใดก็ตามที่การดำเนินการสร้างถูกเรียกใช้ AWS CodeBuild จะจัดเตรียมเซิร์ฟเวอร์บิลด์ตามการกำหนดค่าและดำเนินการตามขั้นตอนที่จำเป็นในการสร้างอิมเมจ Docker ของเราโดยอัตโนมัติ แล้วพุชเวอร์ชันใหม่ไปยังพื้นที่เก็บข้อมูล ECR ที่เราสร้างไว้ (แล้วลดระดับการทำงานของเซิร์ฟเวอร์เมื่อการสร้างเสร็จสมบูรณ์)

    ขั้นตอนสำหรับการสร้างของเรา (ซึ่งแพ็คเกจโค้ด Python และการสร้าง/พุชคอนเทนเนอร์ Docker) จะถูกรวมอยู่ในไฟล์ ~/environment/aws-modern-application-workshop/module-2/app/buildspec.yml ไฟล์ buildspec.yml คือสิ่งที่คุณสร้างเพื่อสั่ง CodeBuild ว่าขั้นตอนใดที่จำเป็นสำหรับการใช้บิลด์ภายในโปรเจกต์ CodeBuild

    ในการสร้างโปรเจกต์ CodeBuild ไฟล์อินพุต CLI อื่นจำเป็นต้องได้รับการอัปเดตด้วยพารามิเตอร์เฉพาะสำหรับทรัพยากรของคุณ ซึ่งอยู่ที่ ~/environment/aws-modern-application-workshop/module-2/aws-cli/code-build-project.json ในทำนองเดียวกัน แทนที่ค่าภายในไฟล์นี้ตามที่คุณเคยทำมาก่อนจาก MythicalMysfitsCoreStackOutput เมื่อบันทึกแล้ว ให้ดำเนินการต่อไปนี้ด้วย CLI เพื่อสร้างโปรเจ็กต์:

    aws codebuild create-project --cli-input-json file://~/environment/aws-modern-application-workshop/module-2/aws-cli/code-build-project.json
    D: สร้างไปป์ไลน์ CodePipeline

    สุดท้ายนี้ เราต้องการวิธีการผสานรวมพื้นที่จัดเก็บ CodeCommit กับโปรเจกต์ CodeBuild ที่ต่อเนื่อง เพื่อให้การสร้างเกิดขึ้นโดยอัตโนมัติทุกครั้งที่มีการพุชการเปลี่ยนแปลงโค้ดไปยังพื้นที่เก็บข้อมูล จากนั้น เราต้องการวิธีจัดส่งที่ต่อเนื่องเพื่อส่งสิ่งประดิษฐ์ที่สร้างขึ้นใหม่นี้ไปยังบริการของเราใน ECS AWS CodePipeline เป็นบริการที่เชื่อมการดำเนินการเหล่านี้เข้าด้วยกันในไปป์ไลน์ที่คุณจะได้สร้างต่อไป

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

    ขั้นตอนทั้งหมดนี้ถูกกำหนดไว้ในไฟล์ JSON ที่คุณจะใช้เป็นอินพุตใน AWS CLI เพื่อสร้างไปป์ไลน์ ไฟล์นี้อยู่ที่ ~/environment/aws-modern-application-workshop/module-2/aws-cli/code-pipeline.json เปิดไฟล์และแทนที่คุณลักษณะที่จำเป็นภายในและทำการบันทึกไฟล์

    เมื่อบันทึกแล้ว ให้ทำการสร้างไปป์ไลน์ CodePipeline ด้วยคำสั่งต่อไปนี้:

    aws codepipeline create-pipeline --cli-input-json file://~/environment/aws-modern-application-workshop/module-2/aws-cli/code-pipeline.json
    E: เปิดใช้งานการเข้าถึงอัตโนมัติไปที่พื้นที่เก็บข้อมูลอิมเมจ ECR

    เราเหลือหนึ่งขั้นตอนสุดท้ายก่อนที่ไปป์ไลน์ CI/CD ของเราจะทำงานแบบครบวงจรสำเร็จ เมื่อระบุไปป์ไลน์ CI/CD แล้ว คุณจะไม่สามารถพุชคอนเทนเนอร์ของอิมเมจไปที่ ECR ด้วยตนเองได้อีกต่อไป CodeBuild จะทำการพุชอิมเมจใหม่นี้แทน

    เราต้องให้สิทธิ์ CodeBuild เพื่อดำเนินการกับพื้นที่เก็บข้อมูลอิมเมจของคุณด้วยนโยบายพื้นที่เก็บข้อมูล ECR* เอกสารนโยบายต้องได้รับการอัปเดตด้วย ARN เฉพาะสำหรับบทบาทของ CodeBuild ที่ถูกสร้างขึ้นโดย MythicalMysfitsCoreStack และเอกสารนโยบายนี้อยู่ที่ ~/environment/aws-modern-application-workshop/module-2/aws-cli/ecr-policy.json

    อัปเดตและบันทึกไฟล์นี้ จากนั้นเรียกใช้คำสั่งต่อไปนี้เพื่อสร้างนโยบาย:

    aws ecr set-repository-policy --repository-name mythicalmysfits/service --policy-text file://~/environment/aws-modern-application-workshop/module-2/aws-cli/ecr-policy.json

    เมื่อสร้างเสร็จเรียบร้อยแล้ว คุณจะมีไปป์ไลน์ CI/CD แบบครบวงจรที่ทำงานเพื่อจัดส่งการเปลี่ยนแปลงโค้ดไปยังบริการของคุณใน ECS โดยอัตโนมัติ

  • A: การใช้ Git กับ AWS CodeCommit

    เพื่อทดสอบไปป์ไลน์ใหม่ เราจำเป็นต้องกำหนดค่า git ภายใน Cloud9 IDE ของคุณและผสานรวมเข้ากับพื้นที่เก็บข้อมูล CodeCommit ของคุณ

    AWS CodeCommit มีตัวช่วยด้านการยืนยันสำหรับ git ที่เราจะใช้เพื่อทำให้การผสานการทำงานนี้เป็นเรื่องง่าย

    เรียกใช้คำสั่งต่อไปนี้ตามลำดับบนเทอร์มินัลเพื่อกำหนดค่า git ที่จะใช้กับ AWS CodeCommit (หากสำเร็จ จะไม่มีการรายงานการตอบสนองใดๆ):

    git config --global user.name "REPLACE_ME_WITH_YOUR_NAME"
    git config --global user.email REPLACE_ME_WITH_YOUR_EMAIL@example.com
    git config --global credential.helper '!aws codecommit credential-helper $@'
    git config --global credential.UseHttpPath true

    ถัดไป เปลี่ยนไดเรกทอรี IDE ของคุณ ไปยังไดเรกทอรีสภาพแวดล้อมโดยใช้เทอร์มินัล:

    cd ~/environment/

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

    git clone https://git-codecommit.REPLACE_REGION.amazonaws.com/v1/repos/MythicalMysfitsService-Repository

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

    cp -r ~/environment/aws-modern-application-workshop/module-2/app/* ~/environment/MythicalMysfitsService-Repository/
    B: การพุชการเปลี่ยนโค้ด

    ตอนนี้ โค้ดบริการที่สมบูรณ์ซึ่งเราใช้ในการสร้างบริการ Fargate ในโมดูลที่ 2 ถูกเก็บไว้ในที่พื้นที่เก็บข้อมูลภายในระบบที่เราเพิ่งโคลนจาก AWS CodeCommit เริ่มทำการเปลี่ยนบริการ Flask ก่อนที่จะยอมรับการเปลี่ยนแปลงของเรานี้ เพื่อแสดงให้เห็นว่าไปป์ไลน์ CI/CD ที่เราสร้างขึ้นนั้นใช้งานได้ ใน Cloud9 เปิดไฟล์ที่เก็บไว้ที่ ~/environment/MythicalMysfitsService-Repository/service/mysfits-response.json และเปลี่ยนอายุของหนึ่งใน mysfits ไปเป็นค่าอื่นและทำการบันทึกไฟล์

    หลังจากบันทึกไฟล์แล้ว ให้เปลี่ยนไดเร็กทอรีเป็นไดเร็กทอรีพื้นที่เก็บข้อมูลใหม่:

    cd ~/environment/MythicalMysfitsService-Repository/

    จากนั้น เรียกใช้คำสั่งต่อไปนี้เพื่อพุชการเปลี่ยนโค้ดของคุณ

    git add .
    git commit -m "I changed the age of one of the mysfits."
    git push

    หลังจากที่การเปลี่ยนแปลงถูกพุชไปยังพื้นที่เก็บข้อมูล คุณสามารถเปิดบริการ CodePipeline ในคอนโซล AWS เพื่อดูการเปลี่ยนแปลงของคุณเมื่อดำเนินการผ่านไปป์ไลน์ CI/CD หลังจากยอมรับการเปลี่ยนแปลงโค้ดของคุณแล้ว จะใช้เวลาประมาณ 5 ถึง 10 นาทีสำหรับการเปลี่ยนแปลงที่จะนำไปติดตั้งกับบริการปัจจุบันของคุณที่ทำงานอยู่ใน Fargate

    ในระหว่างนี้ AWS CodePipeline จะกระตุ้นการประสานการดำเนินงานของไปป์ไลน์เมื่อมีการตรวจสอบการเปลี่ยนแปลงในพื้นที่เก็บข้อมูล CodeCommit ของคุณ ทำการกระตุ้นโปรเจกต์ CodeBuild ของคุณเพื่อให้เกิดการสร้างใหม่ขึ้น และดึงอิมเมจ Docker ที่ถูกพุชไปยัง ECR โดย CodeBuild และแสดงผลบริการอัปเดต ECS โดยอัตโนมัติ เพื่อระบายการเชื่อมต่อคอนเทนเนอร์ที่มีซึ่งกำลังทำงานอยู่ในบริการของคุณและแทนที่ด้วยอิมเมจที่สร้างขึ้นใหม่ รีเฟรชเว็บไซต์ Mythical Mysfits ของคุณในเบราว์เซอร์ เพื่อดูผลการเปลี่ยนแปลง

    คุณสามารถดูความคืบหน้าของการเปลี่ยนโค้ดของคุณผ่านคอนโซล CodePipeline ได้ที่นี่ (ไม่จำเป็นต้องดำเนินการใดๆ เพียงแค่ดูการทำงานแบบอัตโนมัติ!): AWS CodePipeline

    นี่คือการสรุป โมดูลที่ 2

ถัดไป จัดเก็บข้อมูล Mysfit