DevOps Bootcamp · บทเรียน

เวิร์กโฟลว์และแอ็กชันที่นำกลับมาใช้ซ้ำได้

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

เวิร์กโฟลว์และแอ็กชันที่นำกลับมาใช้ซ้ำได้ เป็นบทเรียน DevOps Bootcamp ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน DevOps Bootcamp และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส DevOps Bootcamp มีบทเรียนทั้งหมด 4 บทเรียน

บทนำสู่การนำเวิร์กโฟลว์กลับมาใช้ใหม่

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

เวิร์กโฟลว์ที่นำกลับมาใช้ใหม่ได้และแอ็กชันแบบกำหนดเองใน GitHub Actions ช่วยให้คุณหลีกเลี่ยงการทำงานซ้ำ ทำให้ไปป์ไลน์ CI/CD ดูแลรักษาได้ง่ายขึ้นและมีความแข็งแกร่งมากขึ้น

เหตุใดจึงนำเวิร์กโฟลว์กลับมาใช้ใหม่

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

การทำซ้ำ: มีโค้ดที่ต้องดูแลรักษามากขึ้น
ความไม่สอดคล้อง: อาจพลาดการอัปเดตในเวิร์กโฟลว์บางรายการได้ง่าย
ปัญหายุ่งยากในการดูแลรักษา: การเปลี่ยนแปลงต้องอัปเดตไฟล์จำนวนมาก

การนำกลับมาใช้ใหม่ช่วยแก้ปัญหาเหล่านี้

การกำหนดเวิร์กโฟลว์ที่นำกลับมาใช้ใหม่ได้

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

หากต้องการทำให้เวิร์กโฟลว์นำกลับมาใช้ใหม่ได้ ให้ใช้เหตุการณ์ workflow_call ซึ่งจะบอก GitHub Actions ว่าเวิร์กโฟลว์นี้มีไว้ให้เรียกใช้ ไม่ใช่ให้เริ่มทำงานจากเหตุการณ์ทั่วไป เช่น push หรือ pull_request

ตัวอย่างเวิร์กโฟลว์ที่นำกลับมาใช้ใหม่ได้

นี่คือตัวอย่างเวิร์กโฟลว์ที่นำกลับมาใช้ใหม่ได้แบบง่าย ซึ่งจำลองการสร้าง ให้บันทึกไฟล์นี้ไว้ที่ .github/workflows/reusable-build.yml

เวิร์กโฟลว์นี้กำหนด output ชื่อ build_id ซึ่งเวิร์กโฟลว์ที่เรียกใช้สามารถนำไปใช้ได้

name: Reusable Build Component

on:
  workflow_call:
    outputs:
      build_id:
        description: "The ID of the build operation"
        value: ${{ jobs.build.outputs.build_id }}

jobs:
  build:
    runs-on: ubuntu-latest
    outputs:
      build_id: ${{ steps.generate_id.outputs.id }}
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Generate build ID
        id: generate_id
        run: echo "id=$(date +%s)" >> "$GITHUB_OUTPUT"
      - name: Simulate build
        run: echo "Building project with ID ${{ steps.generate_id.outputs.id }}..."

การเรียกใช้เวิร์กโฟลว์ที่นำกลับมาใช้ใหม่ได้

หากต้องการใช้เวิร์กโฟลว์ที่นำกลับมาใช้ใหม่ได้ เวิร์กโฟลว์อื่น (หรือผู้เรียก) จะใช้คีย์เวิร์ด uses เช่นเดียวกับการใช้แอ็กชัน GitHub

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

ตัวอย่างเวิร์กโฟลว์ผู้เรียก

เวิร์กโฟลว์นี้ซึ่งบันทึกไว้เป็น .github/workflows/main-app-ci.yml จะเรียกใช้เวิร์กโฟลว์ reusable-build.yml ของเรา

สังเกตว่าเวิร์กโฟลว์นี้เข้าถึงผลลัพธ์ build_id จากเวิร์กโฟลว์ที่ถูกเรียกใช้โดยใช้ jobs.call-build.outputs.build_id

name: Main App CI

on: [push]

jobs:
  call-build:
    uses: ./.github/workflows/reusable-build.yml
    outputs:
      build_id: ${{ jobs.call-build.outputs.build_id }}
  
  deploy:
    needs: call-build
    runs-on: ubuntu-latest
    steps:
      - name: Deploy app
        run: echo "Deploying app built with ID ${{ needs.call-build.outputs.build_id }}"

การส่งอินพุตไปยังเวิร์กโฟลว์ที่นำกลับมาใช้ได้

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

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

เวิร์กโฟลว์ที่นำกลับมาใช้ได้ซึ่งรับอินพุต

นี่คือ reusable-build.yml ฉบับปรับปรุงที่รับอินพุต target_env ได้ วิธีนี้ทำให้สามารถปรับแต่งตรรกะการสร้างแบบเดียวกันให้เหมาะกับสภาพแวดล้อมต่าง ๆ ได้

name: Reusable Build Component with Input

on:
  workflow_call:
    inputs:
      target_env:
        required: true
        type: string
        description: "The target environment for the build"
    outputs:
      build_id:
        description: "The ID of the build operation"
        value: ${{ jobs.build.outputs.build_id }}

jobs:
  build:
    runs-on: ubuntu-latest
    outputs:
      build_id: ${{ steps.generate_id.outputs.id }}
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Generate build ID
        id: generate_id
        run: echo "id=$(date +%s)" >> "$GITHUB_OUTPUT"
      - name: Simulate build for ${{ inputs.target_env }}
        run: echo "Building project for ${{ inputs.target_env }} with ID ${{ steps.generate_id.outputs.id }}..."

ตัวอย่างการเรียกใช้พร้อมอินพุต

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

name: Main App CI with Input

on: [push]

jobs:
  call-build-staging:
    uses: ./.github/workflows/reusable-build-with-input.yml
    with:
      target_env: 'staging'
    outputs:
      build_id: ${{ jobs.call-build-staging.outputs.build_id }}
  
  call-build-prod:
    uses: ./.github/workflows/reusable-build-with-input.yml
    with:
      target_env: 'production'
    outputs:
      build_id: ${{ jobs.call-build-prod.outputs.build_id }}

เวิร์กโฟลว์ที่นำกลับมาใช้ได้เทียบกับการทำงานแบบกำหนดเอง

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

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

ลองนึกภาพว่าเวิร์กโฟลว์เป็นสูตรอาหาร และการทำงานเป็นวัตถุดิบหรือขั้นตอนแต่ละรายการ

ตรวจสอบอย่างรวดเร็ว

ข้อใดต่อไปนี้คือประโยชน์สำคัญของการใช้เวิร์กโฟลว์ที่นำกลับมาใช้ได้ในการทำงานของ GitHub

สรุป: เวิร์กโฟลว์และการทำงานที่นำกลับมาใช้ได้

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

กำหนดโดยใช้ workflow_call
รับ inputs และส่ง outputs ได้
เวิร์กโฟลว์ผู้เรียกใช้คีย์เวิร์ด uses
แตกต่างจากการทำงานแบบกำหนดเอง ซึ่งเป็นส่วนประกอบพื้นฐานสำหรับงานเดียวภายในงานต่าง ๆ

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

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

บทเรียน “เวิร์กโฟลว์และแอ็กชันที่นำกลับมาใช้ซ้ำได้” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “เวิร์กโฟลว์และแอ็กชันที่นำกลับมาใช้ซ้ำได้” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส DevOps Bootcamp ให้อัปเกรดเป็น CoddyKit PRO คอร์ส DevOps Bootcamp มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “เวิร์กโฟลว์และแอ็กชันที่นำกลับมาใช้ซ้ำได้”

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

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน DevOps Bootcamp หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน DevOps Bootcamp บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “เวิร์กโฟลว์และแอ็กชันที่นำกลับมาใช้ซ้ำได้” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน DevOps Bootcamp นี้ได้ไหม

ได้ บทเรียน DevOps Bootcamp ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

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

← กลับไปที่ DevOps Bootcamp