Membuat tindakan GitHub kustom

8 menit

GitHub Actions adalah fitur canggih yang membantu Anda beralih dari kode ke cloud, semuanya dari kenyamanan dan kenyamanan repositori Anda sendiri. Di sini, Anda akan mempelajari tentang berbagai jenis tindakan GitHub dan perintah metadata, sintaks, dan alur kerja untuk membuat tindakan GitHub kustom.

Jenis tindakan GitHub

Diagram tiga jenis Aksi GitHub; Aksi Docker, JavaScript, dan langkah eksekusi komposit.

Tindakan adalah tugas individual yang dapat Anda gunakan untuk mengkustomisasi alur kerja. Anda dapat membuat tindakan Anda sendiri dengan menulis kode kustom yang berinteraksi dengan repositori Anda untuk melakukan tugas kustom, atau dengan menggunakan tindakan yang dibagikan komunitas GitHub. Menavigasi melalui berbagai tindakan, Anda akan melihat bahwa ada tiga jenis tindakan yang berbeda: Tindakan kontainer Docker, tindakan JavaScript, dan tindakan langkah-langkah eksekusi komposit. Mari lihat lebih dekat setiap langkahnya.

Tindakan kontainer Docker

Kontainer Docker mengemas lingkungan dengan kode tindakan GitHub. Ini berarti bahwa tindakan berjalan di lingkungan yang konsisten dan andal karena semua dependensinya berada dalam kontainer tersebut. Jika tindakan perlu berjalan dalam konfigurasi lingkungan tertentu, kontainer Docker adalah cara yang baik untuk dilakukan karena Anda dapat menyesuaikan sistem operasi dan alat. Kelemahannya adalah karena tugasnya harus membangun dan mengambil kontainer, tindakan kontainer Docker sering lebih lambat daripada tindakan JavaScript.

Sebelum membangun tindakan kontainer Docker, Anda harus memiliki pemahaman dasar tentang cara menggunakan variabel lingkungan dan sistem file kontainer Docker. Langkah yang harus diambil untuk membangun tindakan kontainer Docker minimal dan mudah:

Buat Dockerfile untuk menentukan perintah guna merakit gambar Docker.
Buat file metadata action.yml untuk menentukan input dan output tindakan. Atur nilai runs: using: ke docker dan nilai runs: image: ke Dockerfile dalam file.
Buat file entrypoint.sh untuk menjelaskan gambar docker.
Terapkan dan dorong tindakan untuk GitHub dengan file berikut: action.yml, entrypoint.sh, Dockerfile, dan README.md.

Tindakan JavaScript

Tindakan JavaScript dapat berjalan langsung di mesin runner, dan memisahkan kode tindakan dari lingkungan yang digunakan untuk menjalankan tindakan. Karena itu, kode tindakan disederhanakan dan dapat dijalankan lebih cepat daripada tindakan dalam kontainer Docker.

Sebagai prasyarat untuk membuat dan menggunakan tindakan JavaScript yang dikemas, Anda perlu mengunduh Node.js, yang mencakup npm. Sebagai langkah opsional (tetapi salah satu yang kami rekomendasikan) adalah menggunakan gitHub Actions Toolkit Node.js, yang merupakan kumpulan paket Node.js yang memungkinkan Anda untuk dengan cepat membangun tindakan JavaScript dengan lebih konsistensi.

Langkah-langkah untuk membangun tindakan JavaScript minimal dan mudah:

Buat action.yml file metadata untuk menentukan input dan output tindakan, serta beri tahu pelari tindakan cara mulai menjalankan tindakan JavaScript ini.
Buat file index.js dengan informasi konteks tentang paket Toolkit, perutean, dan fungsi tindakan lainnya.
Terapkan dan dorong tindakan untuk GitHub dengan file berikut: action.yml, index.js, node_modules, package.json, package-lock.json, dan README.md.

Tindakan langkah eksekusi komposit

Tindakan langkah-langkah eksekusi komposit memungkinkan Anda menggunakan kembali tindakan dengan menggunakan skrip shell. Anda bahkan dapat mencampur beberapa bahasa shell dalam tindakan yang sama. Jika Anda memiliki banyak skrip shell untuk mengotomatiskan beberapa tugas, Anda sekarang dapat dengan mudah mengubahnya menjadi tindakan dan menggunakannya kembali untuk alur kerja yang berbeda. Terkadang lebih mudah untuk hanya menulis skrip shell daripada menggunakan JavaScript atau membungkus kode dalam kontainer Docker.

Tindakan komposit yang dikemas

Tindakan komposit yang dikemas menggabungkan beberapa langkah ke dalam unit yang dapat digunakan kembali. Tindakan ini didefinisikan dalam repositori dan dapat direferensikan dalam alur kerja di berbagai repositori. Mengemas tindakan komposit menyederhanakan alur kerja, mengurangi duplikasi, dan meningkatkan keberlanjutan.

Saat membuat tindakan komposit kemasan, langkah-langkahnya ditentukan dalam satu action.yml file. File ini menentukan input, output, dan urutan perintah atau tindakan yang akan dijalankan. Tindakan komposit yang dipaketkan sangat berguna untuk mengotomatiskan tugas berulang atau menggabungkan beberapa perintah shell ke dalam satu tindakan yang dapat digunakan kembali.

Membuat qction komposit

1. Siapkan direktori untuk tindakan komposit

Anda harus menempatkan tindakan komposit Anda ke dalam direktori tersendiri di dalam repositori.

Contoh struktur direktori:

.github/actions/my-composite-action/
├── action.yml
└── scripts/
    └── my-script.sh

2. Tentukan `action.yml` file

Di dalam direktori my-composite-action, buat action.yml file.

name: "My Composite Action"
description: "A reusable composite action that checks out code and sets up Node.js"

inputs:
  node-version:
    description: "The Node.js version to use"
    required: true

runs:
  using: "composite"
  steps:
    - name: Checkout repository
      uses: actions/checkout@v4

    - name: Set up Node.js
      uses: actions/setup-node@v4
      with:
        node-version: ${{ inputs.node-version }}

Nota: Bidang menggunakan: "komposit" menunjukkan bahwa tindakan ini adalah tindakan komposit.

3. Gunakan tindakan komposit dalam alur kerja

Setelah tindakan komposit dibuat, tindakan tersebut dapat direferensikan dalam alur kerja GitHub Actions.

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Use my composite action
        uses: ./.github/actions/my-composite-action
        with:
          node-version: '18'

Jika tindakan komposit Anda dibagikan dari repositori lain, referensikan seperti ini:

uses: owner/repository/.github/actions/my-composite-action@v1

Cuplikan layar tindakan komposit yang digunakan dalam alur kerja.

Tambahkan output ke tindakan komposit

Tindakan komposit dapat menentukan output yang dapat digunakan alur kerja untuk meneruskan data antar langkah atau pekerjaan. Output sangat berguna untuk berbagi hasil atau nilai komputasi dari satu tindakan ke tindakan lainnya.

Contoh berikut menunjukkan cara menentukan dan menggunakan output dalam tindakan komposit:

Tentukan output di `action.yml`

File action.yml menentukan output bernama script-result. Output ini memperoleh nilainya dari output result pada langkah run-script. Langkah ini run-script menjalankan perintah Bash untuk mengatur nilai output.

outputs:
  script-result:
    description: "Result from the script"
    value: ${{ steps.run-script.outputs.result }}

runs:
  using: "composite"
  steps:
    - id: run-script
      run: echo "result=Success" >> $GITHUB_OUTPUT
      shell: bash

Tangkapan layar mendefinisikan output dalam tindakan komposit.

Menggunakan output dalam alur kerja

Setelah tindakan komposit dibuat, outputnya dapat diakses dalam alur kerja. Berikut adalah sebuah contoh:

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Run composite action
        id: my-action
        uses: ./.github/actions/my-composite-action

      - name: Display result
        run: echo "Script Result: ${{ steps.my-action.outputs.script-result }}"

Dalam contoh ini:

Tindakan komposit dipanggil menggunakan uses kata kunci.
Akses output script-result menggunakan sintaksis steps.<step-id>.outputs.<output-name>.
Tampilkan hasil dalam log alur kerja.

Tentukan output dalam tindakan komposit untuk membuat alur kerja yang dapat digunakan kembali dan modular. Pendekatan ini menyederhanakan berbagi data dan meningkatkan keberlanjutan.

Praktik terbaik untuk tindakan komposit

Praktik Terbaik	Deskripsi
Gunakan Pembuatan Versi	`v1` Gunakan tag untuk mereferensikan versi stabil 1.
Pertahankan Tindakan Modular	Kelompokkan langkah-langkah terkait di dalam tindakan komposit.
Dokumen Input & Output	Tambahkan deskripsi untuk input/output di `action.yml`.
Uji Sebelum Penerbitan	Validasi tindakan komposit dalam repositori pengujian.

Tindakan komposit dalam alur kerja

Tindakan komposit adalah cara yang ampuh untuk menyederhanakan alur kerja dengan menggabungkan beberapa langkah ke dalam unit yang dapat digunakan kembali. Tindakan ini memungkinkan Anda menentukan urutan perintah atau tindakan dalam satu action.yml file, sehingga lebih mudah untuk mempertahankan dan menggunakan kembali logika di seluruh alur kerja.

Manfaat tindakan komposit:

Penggunaan kembali - Tentukan tindakan sekali dan gunakan dalam beberapa alur kerja.
Keberlanjutan - Kurangi duplikasi dengan memusatkan logika dalam satu tindakan.
Modularitas - Menggabungkan beberapa perintah shell atau tindakan lain ke dalam satu unit.

Membuat tindakan untuk menyiapkan CLI pada runner GitHub Actions

Banyak alur kerja CI/CD memerlukan versi tertentu dari alat CLI untuk berinteraksi dengan layanan cloud, mengelola infrastruktur, atau menjalankan skrip. Meskipun runner yang dihosting GitHub telah diinstal sebelumnya dengan banyak alat, mereka mungkin tidak menyertakan versi yang tepat yang dibutuhkan alur kerja Anda, terutama jika versinya lebih lama atau tidak didukung. Alih-alih menginstal versi CLI yang diperlukan di setiap alur kerja, Anda dapat membuat Tindakan GitHub yang dapat digunakan kembali yang:

Memastikan penginstalan yang konsisten dari versi CLI yang diperlukan di seluruh pekerjaan.
Menyederhanakan alur kerja dengan memusatkan logika penginstalan.
Mengoptimalkan penyimpanan sementara untuk eksekusi alur kerja yang lebih cepat.

Cara mengembangkan tindakan penyiapan CLI

Tindakan penyiapan CLI adalah tindakan berbasis JavaScript yang menginstal dan mengonfigurasi CLI pada runner GitHub.

Langkah-langkah untuk membuat tindakan:

Langkah 1: Siapkan Direktori Tindakan

Untuk membuat direktori secara manual untuk tindakan penyiapan CLI Anda, ikuti langkah-langkah berikut:

Menavigasi ke repositori Anda

Cuplikan layar struktur repositori akar yang ditampilkan untuk tindakan JavaScript.

Membuat direktori baru untuk tindakan
Buat direktori baru bernama my-cli-action di .github/actions dalam folder. Ini memastikan tindakan Anda diatur dan mengikuti struktur gitHub yang direkomendasikan untuk tindakan kustom.
Menavigasi ke direktori baru
Ubah ke direktori yang baru dibuat untuk mulai menambahkan file untuk tindakan Anda:
Memverifikasi struktur direktori
Setelah membuat direktori, struktur repositori Anda akan terlihat seperti ini:

your-repository/
├── .github/
│   ├── actions/
│   │   ├── my-cli-action/

Cuplikan layar struktur direktori untuk tindakan JavaScript di dalam '.github/actions.'

Anda sekarang siap untuk melanjutkan pembuatan action.yml file dan file lain yang diperlukan untuk tindakan penyiapan CLI Anda.

Langkah 2: Tentukan file metadata action.yml

Buat file action.yml untuk menjelaskan tindakan.

name: "Setup MyCLI"
description: "Installs MyCLI and adds it to the PATH"
author: "Your Name"

inputs:
  version:
    description: "The CLI version to install"
    required: false
    default: "latest"

runs:
  using: "node16"
  main: "index.js"

Mengapa menggunakan : node16? Tindakan ini menjalankan kode JavaScript menggunakan Node.js 16.

Cuplikan layar file metadata YAML untuk Tindakan GitHub JavaScript.

Langkah 3: Buat skrip JavaScript untuk menginstal CLI

Di direktori yang sama, buat file bernama index.js dan tambahkan kode berikut:

const core = require('@actions/core');
const { execSync } = require('child_process');

async function run() {
  try {
    const version = core.getInput('version') || 'latest';
    
    console.log(`Installing MyCLI version: ${version}...`);

    execSync(`curl -fsSL https://cli.example.com/install.sh | sh`, { stdio: 'inherit' });

    console.log("MyCLI installed successfully.");
  } catch (error) {
    core.setFailed(`Installation failed: ${error.message}`);
  }
}

run();

Kode JavaScript di atas menggunakan core.getInput() untuk mengambil versi CLI yang ditentukan sebagai input. Kemudian menjalankan perintah curl untuk mengunduh dan menginstal CLI. Jika proses penginstalan gagal, tindakan menggunakan core.setFailed() untuk menandai alur kerja sebagai gagal.

Cuplikan layar kode JavaScript untuk index.js dalam GitHub Action.

Langkah 4: Uji tindakan secara lokal

Sebelum menggunakan tindakan dalam alur kerja, uji pada runner yang dihosting GitHub.
Buat file alur kerja (.github/workflows/test.yml) di repositori Anda:

name: Test MyCLI Setup

on:
  push:
    branches:
      - main
      - feature/*

1. Memicu alur kerja
Alur kerja dipicu ketika ada dorongan ke cabang utama dan cabang mana pun yang sesuai dengan pola fitur/*. Anda dapat menyesuaikan ini agar sesuai dengan strategi percabangan repositori Anda.

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

2. Klon repositori
Tindakan /checkout@v4 digunakan untuk mengkloning repositori ke runner. Ini memastikan bahwa alur kerja memiliki akses ke file repositori.

      - name: Install MyCLI
        uses: ./.github/actions/my-cli-action
        with:
          version: '1.2.3'

3. Jalankan tindakan kustom
Menggunakan: ./.github/actions/my-cli-action line mereferensikan tindakan kustom secara lokal. Pastikan bahwa direktori tindakan dan file action.yml disiapkan dengan benar. Input versi menentukan versi CLI yang akan diinstal—dalam hal ini, versi 1.2.3.

      - name: Verify CLI Installation
        run: |
          echo "Checking MyCLI version..."
          mycli --version

4. Verifikasi penginstalan CLI
Langkah ini menjalankan perintah shell untuk memverifikasi bahwa CLI berhasil diinstal. Ini memeriksa versi CLI yang diinstal dengan menjalankan mycli --version.

Cuplikan layar hasil pengujian Tindakan GitHub JavaScript.

Menguji secara lokal

Untuk menguji alur kerja ini secara lokal, gunakan act alat CLI:

act -j test

Ini mensimulasikan lingkungan Tindakan GitHub di komputer lokal Anda, memungkinkan Anda untuk men-debug dan memvalidasi alur kerja sebelum mendorong perubahan.

Tip pengoptimalan: Cache

Untuk meningkatkan performa alur kerja, cache-kan direktori penginstalan CLI dengan menggunakan tindakan actions/cache:

      - name: Cache MyCLI
        uses: actions/cache@v4
        with:
          path: ~/.mycli
          key: mycli-${{ runner.os }}-${{ inputs.version }}

Ini memastikan bahwa eksekusi berikutnya menggunakan kembali penginstalan CLI yang di-cache, mengurangi waktu penyiapan.

Praktik terbaik untuk tindakan penyiapan CLI

Praktik terbaik	Deskripsi
Gunakan Pembuatan Versi	Izinkan pengguna menentukan versi CLI melalui `inputs.version`.
Menangani Kesalahan dengan Benar	Gunakan `core.setFailed()` untuk keluar jika terjadi kesalahan.
Penginstalan Cache CLI	Optimalkan performa alur kerja menggunakan `actions/cache`.
Sediakan Dokumentasi	Jelaskan penggunaan dan input di `README.md`.

Memecahkan masalah tindakan JavaScript

Saat bekerja dengan Tindakan GitHub berbasis JavaScript, Anda mungkin mengalami perilaku, kesalahan, atau kegagalan yang tidak terduga selama eksekusi alur kerja. Unit ini menyediakan teknik dan alat untuk membantu Anda mengidentifikasi dan menyelesaikan masalah dalam tindakan JavaScript Anda.

Skenario pemecahan masalah umum

Masalah	Kemungkinan penyebab	Perbaikan yang disarankan
Tindakan gagal dengan pelacakan tumpukan	Kesalahan sintaksis atau runtime dalam `index.js`	Gunakan `console.log()` dan periksa log
Input adalah `undefined`	Nama input yang salah atau input yang hilang	Verifikasi `action.yml` dan cara input diteruskan
Variabel lingkungan tidak diatur	`core.exportVariable` atau `process.env` tidak digunakan dengan benar	Tinjau pengaturan variabel dalam kode
File tidak ditemukan	Jalur relatif hilang	Gunakan `__dirname` atau jalur lengkap ke file
Cache belum dipulihkan	Nilai `key` atau `path` yang salah	Periksa konfigurasi dan kunci cache

Gunakan Pengelogan untuk Penelusuran Kesalahan

Pesan log dengan `core.info`, `core.debug`, dan `console.log`

const core = require('@actions/core');

core.info("This is an info message");
core.debug("This is a debug message");
console.log("This is a raw console log");

✅ Gunakan core.debug untuk log debug — ini hanya muncul saat ACTIONS_STEP_DEBUG diatur ke true.

Mengaktifkan pengelogan debug

Anda dapat mengaktifkan log debug tingkat langkah dengan mengatur rahasia berikut:

ACTIONS_STEP_DEBUG=true

Untuk mengaktifkan log diagnostik runner, setel:

ACTIONS_RUNNER_DEBUG=true

Menetapkan rahasia untuk debug

Buka repositori GitHub Anda.
Navigasi ke Pengaturan>Rahasia dan variabel>Tindakan.
Tambahkan rahasia baru dengan nama dan nilai berikut:
- ACTIONS_STEP_DEBUG: true
- ACTIONS_RUNNER_DEBUG: true

Memeriksa log alur kerja

Saat alur kerja gagal, klik pekerjaan yang gagal di tab Tindakan. Perluas setiap langkah untuk:

Menampilkan log terperinci
Periksa output standar (stdout)
Lihat kode keluaran dari skrip
Mengidentifikasi pengecualian yang tidak tertangani

🔍 Contoh Output log

Error: Cannot find module '@actions/core'
Require stack:
- /home/runner/work/_actions/my-org/my-action/index.js

✅ Perbaikan: Jalankan npm instal @actions/core dan terapkan node_modules (atau gunakan ncc untuk membundel tindakan).

Menguji tindakan Anda secara lokal

Gunakan act — alat CLI untuk menjalankan GitHub Actions secara lokal. Contoh:

act -j test

🛠 Pastikan untuk mensimulasikan lingkungan GitHub Anda dengan benar saat menguji secara lokal.

Menangani kesalahan dengan anggun

Tangkap pengecualian dan gagal dengan pesan bermanfaat:

try {
  // your logic
} catch (error) {
  core.setFailed(`Action failed with error: ${error.message}`);
}

🔁 Ini memastikan GitHub menghentikan alur kerja pada kesalahan dan menyediakan log yang dapat dibaca.

Praktik terbaik untuk men-debug tindakan JavaScript

Latihan	Deskripsi
Gunakan core.debug()	Sembunyikan log verbose kecuali debugging diaktifkan.
Validasi action.yml	Pastikan input dan output ditentukan dengan benar.
Kode bundel	Gunakan `@vercel/ncc` untuk mengkompilasi JavaScript ke dalam satu file. Ini mengurangi dependensi dan memastikan semua modul yang diperlukan disertakan, mencegah kesalahan runtime yang disebabkan oleh file yang hilang.
Uji dengan tindakan	Jalankan simulasi secara lokal untuk iterasi yang lebih cepat.
Gunakan coba/tangkap	Mencegah alur kerja gagal tanpa pemberitahuan.

Memecahkan masalah tindakan kontainer Docker

Tindakan kontainer Docker sangat kuat untuk merangkum alat dan lingkungan kompleks dalam alur kerja GitHub Actions. Namun, pemecahan kesalahan tindakan ini bisa lebih menantang daripada tindakan JavaScript karena adanya lingkungan runtime yang terisolasi. Unit ini akan memandu Anda mengidentifikasi, mendiagnosis, dan menyelesaikan masalah dengan tindakan berbasis Docker.

Masalah umum dalam tindakan kontainer Docker

Masalah	Penyebab	Perbaikan yang disarankan
Tindakan gagal dimulai	`ENTRYPOINT` atau `CMD` salah dikonfigurasi	Pastikan Dockerfile memakai `ENTRYPOINT` dengan benar
Dependensi hilang	Dependensi tidak diinstal atau salah dikonfigurasi	Pastikan semua paket diinstal dalam gambar
Input tidak diterima	`INPUT_` variabel lingkungan tidak diakses	Gunakan `process.env.INPUT_<INPUT_NAME>` (atau shell setara)
File tidak ditemukan	Jalur file yang salah di dalam kontainer	Menggunakan jalur absolut atau memvalidasi struktur direktori
Izin ditolak	File atau skrip tidak memiliki izin eksekusi	Tambahkan `RUN chmod +x <script>` di Dockerfile
Kegagalan terkait jaringan	Layanan eksternal tidak dapat diakses	Validasi pengaturan jaringan dan logika pengulangan

Memahami siklus hidup tindakan Docker

Sebelum memecahkan masalah, sangat membantu untuk memahami cara tindakan kontainer Docker berjalan.

1. Pemicu Alur Kerja

Alur kerja GitHub Actions dimulai sebagai respons terhadap peristiwa yang dikonfigurasi—seperti push, , pull_requestatau manual workflow_dispatch.

2. Penyiapan Runner

GitHub menyediakan komputer virtual baru ( runner) untuk menjalankan alur kerja. Runner menyiapkan lingkungan dengan mengunduh definisi tindakan dan menyelesaikan dependensi.

3. Resolusi Tindakan

Jika tindakan menentukan runs.using: docker dalam filenya action.yml , GitHub mengenalinya sebagai tindakan berbasis Docker.

4. Image Build atau Pull

GitHub membangun gambar Docker yang ditentukan dalam tindakan Dockerfile atau menarik gambar bawaan jika ditentukan. Gambar ini mendefinisikan lingkungan tempat kode tindakan berjalan.

5. Eksekusi Kontainer

Runner meluncurkan kontainer Docker, memasang ruang kerja, dan menyuntikkan variabel lingkungan, termasuk rahasia dan input yang ditentukan dalam alur kerja.

6. Pelaksanaan Titik Masuk

GitHub menjalankan entrypoint perintah dari Dockerfile di dalam kontainer. Di sinilah logika tindakan kustom berjalan, biasanya skrip atau aplikasi.

7. Penanganan Hasil

Setiap output yang ditetapkan oleh tindakan kontainer ditangkap oleh runner dan diteruskan ke langkah-langkah berikutnya dalam alur kerja. Setelah selesai, kontainer dimatikan dan runner dibuang.

Catatan: Tindakan kontainer Docker berjalan di lingkungan yang bersih dan terisolasi. Status sistem file, alat yang diinstal, dan variabel lingkungan semuanya harus ditentukan dalam Dockerfile.

Teknik debugging

1. Tambahkan Pengelogan

Gunakan pernyataan echo, printf, atau logging dalam skrip titik masuk Anda.

echo "Starting Docker action..."
echo "Input VALUE: $INPUT_VALUE"

Catat semua input dan langkah-langkah penting untuk mendiagnosis di mana kegagalan terjadi.

2. Membangun dan menguji secara lokal

Gunakan Docker di komputer Anda untuk mensimulasikan perilaku kontainer:

docker build -t my-action .
docker run -e INPUT_NAME=value my-action

Pastikan variabel lingkungan meniru yang ditetapkan GitHub.

3. Gunakan CLI act untuk mensimulasikan alur kerja GitHub

Instal tindakan untuk menjalankan alur kerja GitHub Anda secara lokal:

act -j test-job

Bagus untuk menguji tindakan Docker dalam alur kerja tanpa mendorong ke GitHub.

4. Periksa konfigurasi Dockerfile

Pastikan Anda menentukan ENTRYPOINT atau CMD. Salin skrip Anda ke dalam gambar dan beri mereka izin eksekusi:

COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]

5. Periksa log GitHub

Klik eksekusi alur kerja yang gagal, perluas setiap langkah, dan periksa:

Log pembuatan Docker
Output standar dan kesalahan standar dari kontainer
Kode keluar dan jejak tumpukan 🔍 Log sering mengungkapkan paket yang hilang, masalah sintaksis, atau kesalahan izin.

Contoh: Kesalahan titik masuk

Error: container_linux.go:380: starting container process caused "exec: \"/entrypoint.sh\": permission denied"

✅ Perbaikan: Tambahkan RUN chmod +x /entrypoint.sh di Dockerfile Anda.

Pemetaan variabel lingkungan

Input GitHub	Variabel lingkungan Docker
`with: name: test`	`INPUT_NAME=test`
`GITHUB_WORKSPACE`	Dipetakan ke dalam `/github/workspace`
`GITHUB_EVENT_NAME`	Peristiwa yang memicu alur kerja

echo "Input was $INPUT_NAME"
echo "Working dir: $GITHUB_WORKSPACE"

Menggunakan rahasia pemecahan masalah

Aktifkan pengelogan tambahan dengan menambahkan rahasia ini ke repositori atau organisasi Anda:

Rahasia	Deskripsi
`ACTIONS_STEP_DEBUG`	Mengaktifkan pengelogan debug
`ACTIONS_RUNNER_DEBUG`	Mengaktifkan diagnostik runner

Praktik terbaik untuk pemecahan masalah tindakan Docker

Praktik Terbaik	Mengapa
Gunakan pengelogan dengan murah hati	Membantu melacak titik kegagalan
Selalu atur chmod +x	Hindari kesalahan izin pada skrip shell
Memvalidasi input dalam skrip Anda	Mengidentifikasi atau mencegah input yang hilang atau salah bentuk sejak awal
Meminimalkan dependensi kontainer	Gambar yang lebih kecil lebih mudah di-debug
Uji secara lokal dengan docker run atau act	Iterasi yang lebih cepat dan umpan balik langsung

Saran dan Komentar

Apakah halaman ini membantu?