วิธีทดสอบ API อัตโนมัติบน Buildkite

คุณสามารถเรียกใช้การทดสอบ API แบบอัตโนมัติใน Buildkite ได้โดยการกำหนดขั้นตอนคำสั่งในไฟล์ .buildkite/pipeline.yml ซึ่งจะติดตั้ง Apidog CLI รันคำสั่ง apidog run กับสภาพแวดล้อม และอัปโหลดรายงาน HTML เป็นอาร์ติแฟกต์ของการสร้าง (build artifact) คู่มือนี้จะอธิบายขั้นตอนการทำงานทั้งหมด รวมถึงวิธีที่ Buildkite จัดการกับข้อมูลลับ (secrets) เพื่อไม่ให้โทเค็นการเข้าถึง Apidog ของคุณรั่วไหลไปในบันทึก (logs) เราถือว่าการทดสอบ Apidog ของคุณมีอยู่แล้ว คุณสร้างมันด้วยภาพเพียงครั้งเดียว จากนั้นก็เรียกใช้ด้วยคำสั่งเดียวใน CI

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

Buildkite คืออะไร

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

การแยกส่วนนี้มีความสำคัญ ส่วนควบคุมจะกำหนดตารางงาน แต่งานจะถูกรันบนเอเจนต์ คุณสามารถโฮสต์เอเจนต์ด้วยตัวเองบนโครงสร้างพื้นฐานหรือคลาวด์ของคุณ หรือคุณสามารถใช้ Buildkite-hosted agents ซึ่งเป็นการประมวลผลที่ Buildkite จัดการให้คุณ

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

ตัว Buildkite agent เป็นโอเพนซอร์ส เขียนด้วยภาษา Go และเผยแพร่ภายใต้ MIT License โดยมีซอร์สโค้ดอยู่บน GitHub แพลตฟอร์มและส่วนควบคุมที่อยู่รอบๆ นั้นเป็นผลิตภัณฑ์ SaaS เชิงพาณิชย์

Buildkite ใช้สำหรับอะไร

ทีมต่างๆ ใช้ Buildkite เพื่อรันงานอัตโนมัติทุกประเภทที่เกิดจากการเปลี่ยนแปลงโค้ด เช่น การสร้างอาร์ติแฟกต์, การรันการทดสอบหน่วย (unit tests) และการทดสอบรวม (integration tests), การปรับใช้บริการ (deploying services) และการรันการตรวจสอบแบบ end-to-end เนื่องจากเอเจนต์สามารถรันบนฮาร์ดแวร์ของคุณเองได้ จึงเป็นที่นิยมในทีมที่ต้องการควบคุมการประมวลผล, ขอบเขตเครือข่าย หรือฮาร์ดแวร์เช่น GPUs

การทดสอบ API เหมาะสมกับสิ่งนี้เป็นอย่างดี คุณต้องการให้การทดสอบของคุณเข้าถึงสภาพแวดล้อม staging หรือ test, ตรวจสอบการตอบสนองจริง และบล็อกการปรับใช้ (deploy) เมื่อข้อตกลงเสียหาย Buildkite มีประเภทขั้นตอน (step types) ที่ช่วยให้คุณจำลองขั้นตอนดังกล่าวได้อย่างแม่นยำ ซึ่งเราจะใช้ในส่วนด้านล่าง

หากคุณกำลังพิจารณา Buildkite เปรียบเทียบกับตัวเลือกอื่นๆ บทสรุปของเราเกี่ยวกับ เครื่องมือ Continuous Integration ที่ดีที่สุดสำหรับทีม API จะครอบคลุมถึงการเปรียบเทียบแพลตฟอร์มหลายตัวสำหรับกรณีการใช้งานนี้

วิธีการกำหนด Buildkite pipeline

Buildkite pipeline คือรายการของขั้นตอนต่างๆ ตำแหน่งเริ่มต้นในการกำหนดคือไฟล์ที่ .buildkite/pipeline.yml ใน repository ของคุณ เมื่อการสร้างเริ่มต้นขึ้น Buildkite จะมองหาไดเรกทอรีชื่อ .buildkite ที่มีไฟล์ชื่อ pipeline.yml ไดเรกทอรี buildkite/ ที่ไม่ถูกซ่อนอยู่ที่ root ของ repo ก็สามารถใช้งานได้เช่นกัน

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

• ขั้นตอนคำสั่ง (Command steps) รันคำสั่ง shell บนเอเจนต์ นี่คือที่ที่การทดสอบของคุณจะทำงาน
• ขั้นตอนรอ (Wait steps) หยุด pipeline ชั่วคราวจนกว่าทุกขั้นตอนก่อนหน้าจะเสร็จสิ้น คุณเขียนมันเป็นรายการ - wait เปล่าๆ
• ขั้นตอนบล็อก (Block steps) สร้างการอนุมัติด้วยตนเอง ซึ่งเขียนเป็น - block: "Label" มนุษย์จะคลิกเพื่อดำเนินการต่อ ซึ่งมีประโยชน์ก่อนการปรับใช้เวอร์ชันโปรดักชัน

ขั้นตอนคำสั่ง (Command steps) รองรับชุดของคีย์ที่คุณจะใช้บ่อย: label และ key สำหรับการตั้งชื่อและการอ้างอิง, command หรือ commands สำหรับสคริปต์, env สำหรับตัวแปรสภาพแวดล้อม, agents สำหรับการกำหนดเป้าหมาย, secrets สำหรับการแทรกค่าลับ, artifact_paths สำหรับไฟล์ที่จะเก็บไว้, parallelism สำหรับการกระจายงาน และ matrix สำหรับการรันขั้นตอนเดียวกันกับชุดค่าต่างๆ

คีย์ agents คือ hash ของคู่แท็ก คุณใช้มันเพื่อกำหนดเส้นทางขั้นตอนไปยังเอเจนต์ที่ถูกต้อง เช่น queue: "tests" แท็กช่วยให้คุณเก็บงานทดสอบไว้บนเอเจนต์ที่มีการเข้าถึงเครือข่ายหรือเครื่องมือที่เหมาะสม

ไปป์ไลน์แบบคัดลอก-วางที่รันการทดสอบ API

นี่คือไฟล์ .buildkite/pipeline.yml ที่เรียบง่าย ซึ่งจะติดตั้ง Apidog CLI, รันสถานการณ์ทดสอบกับสภาพแวดล้อม และอัปโหลดรายงาน HTML Apidog CLI เป็นเครื่องมือ Node.js ที่ใช้รันสถานการณ์ทดสอบ Apidog ของคุณจากบรรทัดคำสั่ง

steps:
  - label: ":test_tube: API tests (Apidog)"
    key: "api-tests"
    command: |
      npm install -g apidog-cli
      apidog run \
        --access-token "$APIDOG_ACCESS_TOKEN" \
        -t 637132 \
        -e 358171 \
        -r html,cli
      buildkite-agent artifact upload "apidog-reports/**/*"
    agents:
      queue: "default"
    secrets:
      - APIDOG_ACCESS_TOKEN

ข้อสังเกตเกี่ยวกับแฟล็ก: -t คือ ID ของสถานการณ์ทดสอบหรือไดเรกทอรีสถานการณ์ที่คุณต้องการรัน -e คือ ID สภาพแวดล้อมรันไทม์ ซึ่งจะเลือก base URL และตัวแปรที่การทดสอบของคุณใช้ -r html,cli ขอทั้งสรุปเทอร์มินัลที่มนุษย์อ่านได้และไฟล์รายงาน HTML --access-token จะส่งโทเค็น Apidog ของคุณเพื่อให้ CLI สามารถเข้าถึงโปรเจกต์ของคุณได้

โฮสต์ Buildkite agent มีไบนารี buildkite-agent พร้อมใช้งานอยู่แล้ว เนื่องจากเป็นส่วนที่รันงาน คุณเพียงแค่ติดตั้ง apidog-cli ด้วยตัวเอง สำหรับข้อมูลเชิงลึกเกี่ยวกับแฟล็กแต่ละตัว โปรดดู คู่มือ Apidog CLI ฉบับสมบูรณ์

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

การส่งโทเค็นการเข้าถึง Apidog ด้วย Buildkite secrets

โทเค็นการเข้าถึง Apidog ของคุณคือข้อมูลรับรอง (credential) ไม่ควรอยู่ในไฟล์ pipeline.yml หรือพิมพ์ออกมาในบันทึกการสร้าง Buildkite มีฟีเจอร์เฉพาะสำหรับสิ่งนี้เรียกว่า Buildkite secrets

Buildkite secrets คือที่เก็บค่าแบบ key-value ที่มีการเข้ารหัส ค่าจะถูกเข้ารหัสเมื่อเก็บอยู่ (at rest) และเมื่อส่งผ่าน (in transit) ด้วย TLS, ถอดรหัสบนเซิร์ฟเวอร์ Buildkite และถูกจำกัดขอบเขตตามแต่ละคลัสเตอร์ ซึ่งแต่ละคลัสเตอร์มีคีย์การเข้ารหัสของตัวเอง มันทำงานได้ทั้งกับ Buildkite-hosted agents และ self-hosted agents ค่าลับใดๆ ที่ปรากฏในบันทึกของคุณจะถูกแก้ไขโดยอัตโนมัติ

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

steps:
  - command: |
      apidog run --access-token "$APIDOG_ACCESS_TOKEN" -t 637132 -e 358171 -r html,cli
    secrets:
      - APIDOG_ACCESS_TOKEN

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

steps:
  - command: |
      apidog run --access-token "$APIDOG_ACCESS_TOKEN" -t 637132 -e 358171 -r html,cli
    secrets:
      APIDOG_ACCESS_TOKEN: apidog_token   # env var name : Buildkite secret key

วิธีที่สองคือการดึงข้อมูลลับภายในสคริปต์ของคุณด้วย agent CLI อย่างชัดเจน วิธีนี้สะดวกเมื่อคุณต้องการควบคุมว่าจะอ่านค่าเมื่อใด:

APIDOG_ACCESS_TOKEN="$(buildkite-agent secret get apidog_token)"
apidog run --access-token "$APIDOG_ACCESS_TOKEN" -t 637132 -e 358171 -r html,cli

Buildkite secrets ไม่ใช่ตัวเลือกเดียวของคุณ บน self-hosted agents คุณสามารถใช้ environment agent hook ซึ่งเป็นสคริปต์ที่รันเมื่อเริ่มต้นแต่ละงานและส่งออกค่าไปยังสภาพแวดล้อม คุณสามารถควบคุมได้ด้วยตัวแปรเช่น $BUILDKITE_PIPELINE_SLUG หรือ $BUILDKITE_STEP_KEY เพื่อให้ข้อมูลลับโหลดสำหรับงานที่ถูกต้องเท่านั้น คุณยังสามารถดึงข้อมูลจากที่เก็บภายนอกเช่น AWS Secrets Manager, HashiCorp Vault หรือ GCP ผ่าน Buildkite plugins ซึ่งในกรณีนี้ข้อมูลลับจะไม่ถูกจัดเก็บหรือส่งไปยัง Buildkite

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

การอัปโหลดรายงาน HTML เป็นอาร์ติแฟกต์

รีพอร์เตอร์ -r html จะเขียนรายงาน HTML ไปยังเส้นทางภายในเครื่องในพื้นที่ทำงานของเอเจนต์ ไฟล์นั้นจะหายไปเมื่อสิ้นสุดงาน เว้นแต่คุณจะบันทึกไว้ คำสั่ง buildkite-agent artifact upload จะเก็บไฟล์นั้นไว้

buildkite-agent artifact upload "apidog-reports/**/*"

เครื่องหมายคำพูดรอบๆ รูปแบบ glob มีความสำคัญ มันจะหยุด shell ของคุณไม่ให้ขยายรูปแบบก่อนที่เอเจนต์จะเห็น ดังนั้นเอเจนต์จะเป็นผู้จับคู่เอง อาร์ติแฟกต์ที่อัปโหลดจะถูกส่งไปยังที่เก็บข้อมูลที่ Buildkite จัดการโดยค่าเริ่มต้น โดยมีระยะเวลาการเก็บรักษา 6 เดือนและจำกัดขนาด 5GB ต่ออาร์ติแฟกต์ คุณสามารถระบุปลายทางเป็นอาร์กิวเมนต์ที่สองได้หากต้องการส่งไปยังที่อื่น

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

การรันการทดสอบพร้อมกันในหลายสภาพแวดล้อม

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

steps:
  - label: ":test_tube: API tests {{matrix.env}}"
    command: |
      npm install -g apidog-cli
      apidog run --access-token "$APIDOG_ACCESS_TOKEN" -t 637132 -e "{{matrix.env}}" -r html,cli
      buildkite-agent artifact upload "apidog-reports/**/*"
    secrets:
      - APIDOG_ACCESS_TOKEN
    matrix:
      setup:
        env:
          - "358171"   # staging environment id
          - "358172"   # production environment id

ในที่นี้ {{matrix.env}} จะถูกแทนที่ทั้งใน label และแฟล็ก -e ดังนั้นแต่ละงานจะกำหนดเป้าหมายไปยังสภาพแวดล้อม Apidog ที่แตกต่างกัน หากคุณต้องการกระจายสำเนาที่เหมือนกันของงานเดียว ให้ตั้งค่า parallelism: 5 บนขั้นตอนแทนที่จะใช้ matrix

สำหรับการรันที่ขับเคลื่อนด้วยข้อมูล (data-driven runs) ซึ่งสถานการณ์หนึ่งจะวนซ้ำผ่านแถวของไฟล์ CSV หรือ JSON นั้น Apidog CLI จัดการด้วยแฟล็ก -d ของตัวเอง แทนที่จะใช้ Buildkite matrix คู่มือการทดสอบที่ขับเคลื่อนด้วยข้อมูลของ Apidog CLI แสดงวิธีการป้อนไฟล์ข้อมูลเข้าสู่สถานการณ์

การจำกัดการปรับใช้ด้วยการทดสอบ

รูปแบบที่พบบ่อยคือ: รันการทดสอบ, รอจนกว่าจะเสร็จสิ้น, ขอให้มนุษย์อนุมัติ, จากนั้นจึงปรับใช้ Buildkite จำลองสิ่งนี้ด้วยขั้นตอน wait และ block

steps:
  - label: ":test_tube: API tests"
    command: "npm install -g apidog-cli && apidog run --access-token \"$APIDOG_ACCESS_TOKEN\" -t 637132 -e 358171 -r html,cli"
    secrets:
      - APIDOG_ACCESS_TOKEN

  - wait

  - block: ":rocket: Deploy?"
    branches: "main"

  - label: ":rocket: Deploy"
    command: "scripts/deploy.sh"

ขั้นตอน wait จะระงับ pipeline ไว้จนกว่าการทดสอบจะเสร็จสมบูรณ์ ขั้นตอน block จะหยุดชั่วคราวเพื่อรอการคลิกด้วยตนเองและถูกจำกัดเฉพาะบน main branch ด้วย branches: ขั้นตอนการปรับใช้จะทำงานหลังจากมีคนอนุมัติเท่านั้น สิ่งนี้ช่วยป้องกันไม่ให้ชุดการทดสอบที่ล้มเหลวไปถึงเวอร์ชันโปรดักชัน สำหรับรูปแบบที่กว้างขึ้นเกี่ยวกับเรื่องนี้ โปรดดูที่ แนวทางปฏิบัติที่ดีที่สุดของ CI/CD สำหรับการทดสอบ API

การเพิ่มคำอธิบายประกอบสรุป

บันทึกการสร้างมักจะยาว คำอธิบายประกอบจะแสดงสรุปสั้นๆ ที่จัดรูปแบบไว้ที่ด้านบนของหน้าการสร้าง คุณสามารถสร้างได้โดยการส่ง Markdown ไปยัง buildkite-agent annotate

cat << 'EOF' | buildkite-agent annotate --style "success" --context "apidog"
### API test results
All Apidog scenarios passed. [Download the full HTML report](artifact://apidog-reports/index.html)
EOF

แฟล็ก --style ควบคุมสีและไอคอน โดยมีค่าเป็น info, warning, error และ success แฟล็ก --context จะกำหนด ID ที่ไม่ซ้ำกันให้กับคำอธิบายประกอบ ดังนั้นขั้นตอนถัดไปที่มี context เดียวกันจะอัปเดตคำอธิบายประกอบเดิมแทนที่จะเพิ่มอันใหม่ ลิงก์ artifact:// จะนำผู้ตรวจสอบไปยังรายงาน HTML ที่อัปโหลดโดยตรง

Apidog เข้ากันได้ดีอย่างไร

ไปป์ไลน์ข้างต้นถูกทำให้สั้นโดยเจตนา งานหนักในการเขียนและดูแลการทดสอบเกิดขึ้นใน Apidog ไม่ใช่ใน YAML

Apidog เป็นแพลตฟอร์ม API แบบครบวงจรสำหรับการออกแบบ, ดีบัก, ทดสอบ, จำลอง (mocking) และจัดทำเอกสาร API คุณสร้างสถานการณ์ทดสอบใน visual editor: เชื่อมโยงคำขอ, ส่งข้อมูลระหว่างขั้นตอน และเพิ่มการยืนยันโดยไม่ต้องเขียนสคริปต์ เนื่องจากสถานการณ์เหล่านี้อยู่ในโปรเจกต์ Apidog ของคุณ ทีมของคุณจึงสามารถแก้ไขได้ในที่เดียวและควบคุมเวอร์ชันด้วยการรองรับ branch

CLI เป็นสะพานเชื่อมสู่ CI คุณสร้างสถานการณ์ครั้งเดียว, คัดลอก ID สถานการณ์และสภาพแวดล้อม และการรวม CI ทั้งหมดจะใช้คำสั่ง apidog run เพียงคำสั่งเดียว เมื่อคุณอัปเดตการทดสอบใน Apidog การสร้าง Buildkite ครั้งถัดไปจะรับการเปลี่ยนแปลงโดยไม่มีการแก้ไข YAML คุณสมบัติคำสั่งเดียวนี้เองที่ทำให้ Apidog สามารถทำงานร่วมกับ Buildkite, GitHub Actions หรือระบบอื่นๆ ได้อย่างราบรื่น เราครอบคลุมคำสั่งเดียวกันนี้บนแพลตฟอร์มอื่นๆ ใน คู่มือ Apidog CLI CI/CD pipeline และ Apidog CLI กับ GitHub Actions

หากต้องการลองใช้จากเครื่องของคุณเองก่อน ก่อนที่จะนำไปใช้กับ CI ให้รันคำสั่งเดียวกันนี้ในเครื่องของคุณด้วยโทเค็นของคุณ:

apidog run --access-token "$APIDOG_ACCESS_TOKEN" -t 637132 -e 358171 -r cli,html

ดาวน์โหลด Apidog ฟรี สร้างสถานการณ์ทดสอบ และนำคำสั่ง apidog run แบบบรรทัดเดียวไปใส่ใน Buildkite pipeline ของคุณ

คำถามที่พบบ่อย

Buildkite คืออะไร?

Buildkite เป็นแพลตฟอร์ม CI/CD ที่มีการออกแบบแบบไฮบริด ส่วนควบคุม (control plane) ที่โฮสต์อยู่จะรันแดชบอร์ดและจัดการการสร้าง (builds) ในขณะที่เอเจนต์จะรันงานจริง เอเจนต์สามารถรันบนโครงสร้างพื้นฐานของคุณเองหรือบน Buildkite-hosted compute ได้ ไม่เกี่ยวข้องกับ Docker BuildKit ซึ่งเป็นเครื่องมือสร้างอิมเมจที่แยกต่างหากแต่มีชื่อคล้ายกัน

Buildkite ใช้สำหรับอะไร?

ทีมต่างๆ ใช้ Buildkite เพื่อทำให้งานที่เกิดจากการเปลี่ยนแปลงโค้ดเป็นไปโดยอัตโนมัติ: การสร้างอาร์ติแฟกต์, การรันการทดสอบ และการปรับใช้ เป็นเรื่องปกติสำหรับทีมที่ต้องการให้การสร้างของพวกเขารันบนฮาร์ดแวร์ของตนเองหรือภายในเครือข่ายของตนเอง สำหรับทีม API มันจะรันการทดสอบอัตโนมัติกับสภาพแวดล้อม staging และ production และสามารถบล็อกการปรับใช้ได้เมื่อการทดสอบล้มเหลว

Buildkite เป็นโอเพนซอร์สหรือไม่?

Buildkite agent เป็นโอเพนซอร์ส มันถูกเขียนด้วยภาษา Go และเผยแพร่ภายใต้ MIT License โดยมีซอร์สโค้ดอยู่บน GitHub แพลตฟอร์มและส่วนควบคุมรอบๆ เอเจนต์นั้นเป็นผลิตภัณฑ์ SaaS เชิงพาณิชย์ ดังนั้นเฉพาะตัวเอเจนต์เท่านั้นที่เป็นโอเพนซอร์ส

Buildkite ฟรีหรือไม่?

ใช่ Buildkite มีแผนฟรีที่เรียกว่า Personal ไม่มีค่าใช้จ่าย, ไม่ต้องใช้บัตรเครดิต และไม่มีวันหมดอายุ มันรวมงานพร้อมกัน 3 งาน, ผู้ใช้ 1 คน, การเก็บรักษาข้อมูล 90 วัน, นาทีของ Buildkite-hosted agents บน Linux 500 นาทีต่อเดือน และการรันการทดสอบ 50,000 ครั้งต่อเดือน นอกจากนี้ยังมีช่วงทดลองใช้งาน All Access 30 วันสำหรับการประเมินคุณสมบัติที่ต้องชำระเงิน

คุณอัปโหลดอาร์ติแฟกต์ใน Buildkite ได้อย่างไร?

คุณรันคำสั่ง buildkite-agent artifact upload "<pattern>" ภายในขั้นตอนคำสั่ง (command step) ใส่เครื่องหมายคำพูดรอบรูปแบบ glob เพื่อให้เอเจนต์เป็นผู้จับคู่แทนที่จะเป็น shell ไฟล์จะถูกส่งไปยังที่เก็บข้อมูลที่ Buildkite จัดการโดยค่าเริ่มต้น โดยมีระยะเวลาการเก็บรักษา 6 เดือนและจำกัดขนาด 5GB ต่ออาร์ติแฟกต์ สำหรับการทดสอบ API คุณอัปโหลดรายงาน HTML เพื่อให้ผู้ตรวจสอบสามารถเปิดดูได้จากแท็บ Artifacts ของการสร้าง

คุณรันการทดสอบ API ใน Buildkite pipeline ได้อย่างไร?

เพิ่มขั้นตอนคำสั่ง (command step) ลงใน .buildkite/pipeline.yml เพื่อติดตั้ง Apidog CLI ด้วย npm install -g apidog-cli จากนั้นรัน apidog run พร้อมกับ ID ของสถานการณ์ทดสอบ, ID สภาพแวดล้อมผ่านทาง -e และ -r html,cli สำหรับรายงาน ส่งโทเค็นการเข้าถึงของคุณผ่าน Buildkite secret และอัปโหลดรายงาน HTML ด้วย buildkite-agent artifact upload เพื่อให้ผลลัพธ์ยังคงอยู่หลังจากการสร้าง