PricingLoginStart free
CI/CD dengan GitHub Actions & Saluran DevOps · Pelajaran

Aliran Kerja dan Actions Boleh Guna Semula

Cipta dan manfaatkan aliran kerja boleh guna semula serta tindakan tersuai untuk memodulkan saluran paip dan menggalakkan konsistensi merentas repositori.

Pelajaran 3 daripada 412 langkah

Aliran Kerja dan Actions Boleh Guna Semula ialah pelajaran CI/CD dengan GitHub Actions & Saluran DevOps percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran CI/CD dengan GitHub Actions & Saluran DevOps, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus CI/CD dengan GitHub Actions & Saluran DevOps merangkumi sejumlah 4 pelajaran.

Pengenalan kepada Kebolehgunaan Semula Aliran Kerja

Dalam pembangunan perisian moden, kecekapan dan konsistensi sangat penting. Apabila projek anda berkembang, keperluan automasi anda juga bertambah.

Aliran kerja boleh guna semula dan tindakan tersuai dalam GitHub Actions membantu anda mengelakkan pengulangan, sekali gus menjadikan saluran paip CI/CD anda lebih mudah disenggara dan kukuh.

Mengapa Menggunakan Semula Aliran Kerja?

Bayangkan anda mempunyai berbilang aplikasi yang semuanya memerlukan langkah binaan, pengujian atau penggunaan yang sama. Menyalin dan menampal kod aliran kerja menyebabkan:

  • Penduaan: Lebih banyak kod untuk disenggara.
  • Ketidakselarasan: Mudah terlepas kemas kini merentasi aliran kerja.
  • Kesukaran Penyelenggaraan: Perubahan memerlukan pengemaskinian banyak fail.

Kebolehgunaan semula menyelesaikan masalah ini!

Mentakrifkan Aliran Kerja Boleh Guna Semula

Aliran kerja boleh guna semula ialah aliran kerja lengkap yang boleh dipanggil oleh aliran kerja lain. Aliran kerja ini disimpan dalam repositori anda dan bertindak seperti templat.

Untuk menjadikan aliran kerja boleh guna semula, anda menggunakan peristiwa workflow_call. Hal ini memberitahu GitHub Actions bahawa aliran kerja tersebut bertujuan untuk dipanggil, bukan dicetuskan oleh peristiwa biasa seperti push atau pull_request.

Contoh Aliran Kerja Boleh Guna Semula

Berikut ialah aliran kerja boleh guna semula yang mudah dan mensimulasikan binaan. Simpan aliran kerja ini dalam .github/workflows/reusable-build.yml.

Aliran kerja ini mentakrifkan output yang dipanggil build_id dan boleh digunakan oleh aliran kerja yang memanggilnya.

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 }}..."

Memanggil Aliran Kerja Boleh Guna Semula

Untuk menggunakan aliran kerja boleh guna semula, aliran kerja lain menggunakan kata kunci uses, sama seperti cara anda menggunakan tindakan GitHub.

Anda menentukan laluan ke fail aliran kerja boleh guna semula dalam repositori anda, atau malah daripada repositori lain atau versi tertentu.

Contoh Aliran Kerja Pemanggil

Aliran kerja ini, yang disimpan sebagai .github/workflows/main-app-ci.yml, memanggil aliran kerja reusable-build.yml kami.

Perhatikan cara aliran kerja ini mengakses output build_id daripada aliran kerja yang dipanggil menggunakan 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 }}"

Menghantar Masukan kepada Aliran Kerja Boleh Guna Semula

Aliran kerja boleh guna semula bukan sekadar templat statik; aliran ini boleh menerima masukan, menjadikannya sangat fleksibel.

Anda menentukan masukan yang dijangka dalam bahagian on: workflow_call: inputs: aliran kerja boleh guna semula, dengan menyatakan jenisnya, sama ada diperlukan dan memberikan perihalan. Aliran kerja pemanggil menghantar masukan ini menggunakan kata kunci with:.

Aliran Kerja Boleh Guna Semula dengan Masukan

Berikut ialah reusable-build.yml yang dikemas kini dan menerima masukan target_env. Dengan ini, logik binaan yang sama boleh disesuaikan untuk persekitaran yang berbeza.

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 }}..."

Contoh Memanggil dengan Masukan

Kini, aliran kerja CI utama kita boleh memanggil komponen binaan boleh guna semula itu dua kali, sekali untuk 'pementasan' dan sekali untuk 'pengeluaran', dengan menghantar nilai target_env yang berbeza.

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 }}

Aliran Kerja Boleh Guna Semula berbanding Tindakan Tersuai

Walaupun kedua-duanya menggalakkan kebolehgunaan semula, kedua-duanya mempunyai tujuan yang berbeza:

  • Aliran Kerja Boleh Guna Semula: Mengatur urutan tugas. Aliran ini menentukan struktur aliran kerja yang lengkap (contohnya, binaan, ujian, penggunaan).
  • Tindakan Tersuai: Menjalankan satu tugas khusus dalam sesuatu tugas (contohnya, menyediakan Node.js, menerbitkan pakej). Tindakan ini ialah blok binaan *di dalam* langkah sesuatu tugas.

Anggap aliran kerja sebagai resipi, manakala tindakan ialah bahan atau langkah individu.

Semakan Pantas

Manakah antara berikut merupakan manfaat utama menggunakan aliran kerja boleh guna semula dalam GitHub Actions?

Jawab dalam pelajaran interaktif

Ulang Kaji: Aliran Kerja & Tindakan Boleh Guna Semula

Kami telah meneroka cara aliran kerja boleh guna semula membantu menjadikan saluran CI/CD anda lebih modular.

  • Aliran ini ditentukan menggunakan workflow_call.
  • Aliran ini boleh menerima inputs dan menyediakan outputs.
  • Aliran kerja pemanggil menggunakan kata kunci uses.
  • Aliran ini berbeza daripada tindakan tersuai, yang merupakan blok binaan untuk satu tugas dalam tugas.

Penggunaan semula menghasilkan automasi yang lebih cekap, konsisten dan mudah diselenggara dalam semua projek anda.

Percuma untuk bermula

Pelajari CI/CD dengan GitHub Actions & Saluran DevOps dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus
12
Pelajaran
48
Mula belajar secara percumaLihat kursus penuh

Soalan Lazim

Adakah pelajaran “Aliran Kerja dan Actions Boleh Guna Semula” percuma?

Ya — teks penuh “Aliran Kerja dan Actions Boleh Guna Semula” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus CI/CD dengan GitHub Actions & Saluran DevOps, tingkat taraf kepada CoddyKit PRO. Kursus CI/CD dengan GitHub Actions & Saluran DevOps merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Aliran Kerja dan Actions Boleh Guna Semula”?

Cipta dan manfaatkan aliran kerja boleh guna semula serta tindakan tersuai untuk memodulkan saluran paip dan menggalakkan konsistensi merentas repositori. Anda berlatih CI/CD dengan GitHub Actions & Saluran DevOps menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan CI/CD dengan GitHub Actions & Saluran DevOps?

Tiada pengalaman terdahulu diperlukan. Pembelajaran CI/CD dengan GitHub Actions & Saluran DevOps di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Aliran Kerja dan Actions Boleh Guna Semula” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran CI/CD dengan GitHub Actions & Saluran DevOps ini?

Ya. Setiap pelajaran CI/CD dengan GitHub Actions & Saluran DevOps menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

  1. Binaan Matriks untuk Pelbagai Persekitaran
  2. Mencache Kebergantungan untuk Kelajuan
  3. Aliran Kerja dan Actions Boleh Guna Semula
  4. Pelaksanaan Bersyarat dan Kebergantungan Tugas
← Kembali ke CI/CD dengan GitHub Actions & Saluran DevOps