🥇การทดสอบโครงสร้างพื้นฐานเป็นโค้ดโดยใช้ Pulumi ตอนที่ 2

สวัสดีทุกคน. วันนี้เราแบ่งปันส่วนสุดท้ายของบทความกับคุณ "การทดสอบโครงสร้างพื้นฐานเป็นโค้ดด้วย Pulumi"ซึ่งงานแปลจัดทำขึ้นเพื่อนักศึกษารายวิชาโดยเฉพาะ "แนวทางปฏิบัติและเครื่องมือ DevOps".

การทดสอบการใช้งาน

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

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

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

ด้วยการรันโปรแกรมโดยใช้เฟรมเวิร์กนี้ คุณสามารถตรวจสอบสิ่งต่อไปนี้:

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

ดังที่เราจะได้เห็นเร็วๆ นี้ กรอบงานนี้ยังสามารถใช้เพื่อดำเนินการตรวจสอบรันไทม์ได้อีกด้วย

การทดสอบการรวมระบบอย่างง่าย

หากต้องการดูการดำเนินการนี้ เราจะดูที่พื้นที่เก็บข้อมูล pulumi/examplesเนื่องจากทีมของเราและชุมชน Pulumi ใช้เพื่อทดสอบคำขอดึง คอมมิต และบิลด์ทุกคืนของเราเอง

ด้านล่างนี้คือการทดสอบแบบง่ายของเรา ตัวอย่างที่ให้บัคเก็ต S3 และออบเจ็กต์อื่นๆ:

example_test.go:

package test
 
import (
    "os"
    "path"
    "testing"
 
    "github.com/pulumi/pulumi/pkg/testing/integration"
)
 
func TestExamples(t *testing.T) {
    awsRegion := os.Getenv("AWS_REGION")
    if awsRegion == "" {
        awsRegion = "us-west-1"
    }
    cwd, _ := os.Getwd()
    integration.ProgramTest(t, &integration.ProgramTestOptions{
        Quick:       true,
        SkipRefresh: true,
        Dir:         path.Join(cwd, "..", "..", "aws-js-s3-folder"),
        Config: map[string]string{
            "aws:region": awsRegion,
        },
    })
}

การทดสอบนี้ต้องผ่านวงจรชีวิตพื้นฐานของการสร้าง การแก้ไข และการทำลายสแต็กสำหรับโฟลเดอร์ aws-js-s3-folder. จะใช้เวลาประมาณหนึ่งนาทีในการรายงานการทดสอบที่ผ่าน:

$ go test .
PASS
ok      ... 43.993s

มีตัวเลือกมากมายในการปรับแต่งพฤติกรรมของการทดสอบเหล่านี้ ดูรายการตัวเลือกทั้งหมด ในโครงสร้าง ProgramTestOptions. ตัวอย่างเช่น คุณสามารถกำหนดค่าตำแหน่งข้อมูล Jaeger เพื่อติดตาม (Tracing) ระบุว่าคุณคาดว่าการทดสอบจะล้มเหลวหากการทดสอบเป็นลบ (ExpectFailure) ใช้ชุดของ "การแก้ไข" กับโปรแกรมเพื่อการเปลี่ยนแปลงสถานะตามลำดับ (EditDirs) และอีกมากมาย มาดูวิธีใช้เพื่อทดสอบการปรับใช้แอปพลิเคชันของคุณ

การตรวจสอบคุณสมบัติของทรัพยากร

การบูรณาการที่กล่าวถึงข้างต้นช่วยให้แน่ใจว่าโปรแกรมของเรา “ใช้งานได้”—ไม่ขัดข้อง แต่ถ้าเราต้องการตรวจสอบคุณสมบัติของสแต็กผลลัพธ์ล่ะ ตัวอย่างเช่น ทรัพยากรบางประเภทมี (หรือยังไม่ได้) ได้รับการจัดเตรียมและมีคุณลักษณะบางอย่าง

พารามิเตอร์ ExtraRuntimeValidation สำหรับ ProgramTestOptions ช่วยให้เราสามารถดูสถานะหลังการใช้งานที่บันทึกโดย Pulumi เพื่อให้เราตรวจสอบเพิ่มเติมได้ ซึ่งรวมถึงภาพรวมที่สมบูรณ์ของสถานะของสแต็กผลลัพธ์ รวมถึงการกำหนดค่า ค่าเอาต์พุตที่ส่งออก ทรัพยากรทั้งหมดและค่าคุณสมบัติ และการขึ้นต่อกันทั้งหมดระหว่างทรัพยากร

หากต้องการดูตัวอย่างพื้นฐานของสิ่งนี้ เรามาตรวจสอบว่าโปรแกรมของเราสร้างขึ้นมาหรือไม่ ถัง S3:

  integration.ProgramTest(t, &integration.ProgramTestOptions{
        // as before...
        ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
            var foundBuckets int
            for _, res := range stack.Deployment.Resources {
                if res.Type == "aws:s3/bucket:Bucket" {
                    foundBuckets++
                }
            }
            assert.Equal(t, 1, foundBuckets, "Expected to find a single AWS S3 Bucket")
        },
    })

ตอนนี้ เมื่อเรารัน go test มันจะไม่เพียงผ่านการทดสอบวงจรการใช้งานแบตเตอรี่เท่านั้น แต่ยังหลังจากปรับใช้สแต็กสำเร็จแล้ว มันจะทำการตรวจสอบเพิ่มเติมเกี่ยวกับสถานะผลลัพธ์อีกด้วย

การทดสอบรันไทม์

จนถึงตอนนี้ การทดสอบทั้งหมดเกี่ยวกับพฤติกรรมการปรับใช้และโมเดลทรัพยากร Pulumi เพียงอย่างเดียว จะทำอย่างไรถ้าคุณต้องการตรวจสอบว่าโครงสร้างพื้นฐานที่คุณจัดเตรียมไว้ใช้งานได้จริงหรือไม่ ตัวอย่างเช่น เมื่อเครื่องเสมือนกำลังทำงาน บัคเก็ต S3 จะมีสิ่งที่เราคาดหวัง และอื่นๆ

คุณอาจเดาได้แล้วว่าต้องทำอย่างไร: ตัวเลือก ExtraRuntimeValidation สำหรับ ProgramTestOptions - นี่เป็นโอกาสอันดีสำหรับสิ่งนี้ ณ จุดนี้ คุณจะรันการทดสอบ Go แบบกำหนดเองพร้อมสิทธิ์เข้าถึงสถานะเต็มของทรัพยากรของโปรแกรมของคุณ สถานะนี้ประกอบด้วยข้อมูล เช่น ที่อยู่ IP ของเครื่องเสมือน, URL และทุกสิ่งที่จำเป็นในการโต้ตอบกับแอปพลิเคชันระบบคลาวด์และโครงสร้างพื้นฐานที่เกิดขึ้นจริง

ตัวอย่างเช่น โปรแกรมทดสอบของเราจะส่งออกทรัพย์สิน webEndpoint ถังเรียกว่า websiteUrlซึ่งเป็น URL แบบเต็มที่เรากำหนดค่าได้ index document. แม้ว่าเราจะสามารถเจาะเข้าไปในไฟล์สถานะเพื่อค้นหาได้ bucket และอ่านคุณสมบัตินั้นโดยตรง แต่ในหลายกรณีสแต็กของเราจะส่งออกคุณสมบัติที่มีประโยชน์เช่นนี้ซึ่งเราพบว่าสะดวกในการใช้ตรวจสอบ:

integration.ProgramTest(t, &integration.ProgramTestOptions{
            // as before ...
        ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
            url := "http://" + stack.Outputs["websiteUrl"].(string)
            resp, err := http.Get(url)
            if !assert.NoError(t, err) {
                return
            }
            if !assert.Equal(t, 200, resp.StatusCode) {
                return
            }
            defer resp.Body.Close()
            body, err := ioutil.ReadAll(resp.Body)
            if !assert.NoError(t, err) {
                return
            }
            assert.Contains(t, string(body), "Hello, Pulumi!")
        },
    })

เช่นเดียวกับการตรวจสอบรันไทม์ครั้งก่อนๆ ของเรา การตรวจสอบนี้จะดำเนินการทันทีหลังจากเพิ่มสแต็ก ทั้งหมดนี้ตอบสนองต่อการเรียกง่ายๆ go test. และนั่นเป็นเพียงส่วนเล็กเท่านั้น คุณลักษณะการทดสอบ Go ทุกรายการที่คุณสามารถเขียนด้วยโค้ดนั้นพร้อมใช้งานแล้ว

การบูรณาการโครงสร้างพื้นฐานอย่างต่อเนื่อง

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

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

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

Pulumi รองรับระบบ CI ทั่วไป นี่คือบางส่วนของพวกเขา:

สำหรับข้อมูลโดยละเอียดเพิ่มเติม โปรดดูเอกสารประกอบของ การจัดส่งแบบต่อเนื่อง.

สภาพแวดล้อมชั่วคราว

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

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

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

ทั้งหมด

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

ปูลูมิ - ซอฟต์แวร์โอเพ่นซอร์ส ใช้งานได้ฟรีและทำงานร่วมกับภาษาโปรแกรมและคลาวด์ที่คุณชื่นชอบ - ลองวันนี้!

→ ส่วนแรก

ที่มา: will.com

การทดสอบโครงสร้างพื้นฐานเป็นโค้ดด้วย Pulumi ส่วนที่ 2