Egyéni GitHub-művelet létrehozása

Befejezett

A GitHub Actions egy hatékony funkció, amely segít a kódból a felhőbe való váltásban, mindezt a saját adattára kényelméből és kényelméből. Itt megismerheti a GitHub-műveletek különböző típusait, valamint az egyéni GitHub-műveletek létrehozásához használt metaadatokat, szintaxist és munkafolyamat-parancsokat.

A GitHub-műveletek típusai

A műveletek egyéni feladatok, amelyekkel testre szabhatja a fejlesztési munkafolyamatokat. Saját műveleteket úgy hozhat létre, hogy egyéni kódot ír, amely az adattárral együttműködve egyéni feladatokat hajt végre, vagy a GitHub-közösség által megosztott műveletek használatával. A különböző műveletek végigvezetve megfigyelheti, hogy három különböző művelettípus létezik: a Docker-tárolóműveletek, a JavaScript-műveletek és az összetett futtatási lépések. Vizsgáljuk meg közelebbről az egyes művelettípusokat.

Docker-tárolóműveletek

A Docker-tárolók a környezetet a GitHub Actions-kóddal csomagolják. Ez azt jelenti, hogy a művelet konzisztens és megbízható környezetben fut, mivel az összes függősége a tárolón belül van. Ha a műveletnek egy adott környezeti konfigurációban kell futnia, a Docker-tárolók jó módszernek számítanak, mivel testre szabhatja az operációs rendszert és az eszközöket. A hátránya az, hogy mivel a feladatnak létre kell készítenie és le kell kérnie a tárolót, a Docker-tárolóműveletek gyakran lassabbak, mint a JavaScript-műveletek.

A Docker-tárolóműveletek létrehozása előtt ismernie kell a környezeti változók és a Docker-tároló fájlrendszerének használatát. A Docker-tárolóműveletek létrehozásához szükséges lépések ezután minimálisak és egyszerűek:

1. Hozzon létre egy parancsot Dockerfile a Docker-rendszerkép összeállításához.
2. Hozzon létre egy action.yml metaadatfájlt a művelet bemeneteinek és kimeneteinek meghatározásához. Állítsa be az runs: using: értéket docker a fájlban lévő értékre és runs: image: értékre Dockerfile .
3. Hozzon létre egy entrypoint.sh fájlt a Docker-rendszerkép leírásához.
4. Véglegesítse és küldje le a műveletet a GitHubra a következő fájlokkal: action.yml, entrypoint.sh, Dockerfileés README.md.

JavaScript-műveletek

A JavaScript-műveletek közvetlenül a futó gépen futtathatók, és elválaszthatják a műveleti kódot a művelet futtatásához használt környezettől. Emiatt a műveletkód egyszerűbb, és gyorsabban végrehajtható, mint a Docker-tárolón belüli műveletek.

A csomagolt JavaScript-műveletek létrehozásának és használatának előfeltételeként le kell töltenie Node.js, amely tartalmazza az npm-et is. Választható lépésként (de ajánlott) a GitHub Actions Toolkit Node.js használata, amely Node.js csomagok gyűjteménye, amely lehetővé teszi a JavaScript-műveletek gyorsabb, konzisztenciájú összeállítását.

A JavaScript-műveletek létrehozásához szükséges lépések minimálisak és egyszerűek:

1. Hozzon létre egy metaadatfájlt action.yml a művelet bemeneteinek és kimeneteinek meghatározásához, valamint a műveletfuttatónak a JavaScript-művelet futtatásának megkezdéséhez.
2. Hozzon létre egy index.js fájlt az eszközkészlet-csomagokkal, az útválasztással és a művelet egyéb funkcióival kapcsolatos környezeti információkkal.
3. Véglegesítse és küldje le a műveletet a GitHubra a következő fájlokkal: action.yml, index.js, node_modules, , package.jsonpackage-lock.jsonés README.md.

Összetett futtatási lépések műveletei

Az összetett futtatási lépések műveletei lehetővé teszik a műveletek rendszerhéjszkriptekkel való újrafelhasználását. Akár több rendszerhéjnyelvet is keverhet ugyanazon a műveleten belül. Ha számos rendszerhéjszkripttel automatizálhat több feladatot, mostantól egyszerűen műveletté alakíthatja őket, és felhasználhatja őket különböző munkafolyamatokhoz. Néha egyszerűbb csak egy rendszerhéjszkriptet írni, mint JavaScriptet használni, vagy a kódot egy Docker-tárolóba burkolni.

Csomagolt összetett művelet

A csomagolt összetett műveletek több lépést is összecsomagoznak egy újrafelhasználható egységbe. Ezek a műveletek egy adattárban vannak definiálva, és különböző adattárak munkafolyamataiban lehet hivatkozni rájuk. Az összetett műveletek csomagolása leegyszerűsíti a munkafolyamatokat, csökkenti a duplikációkat, és javítja a karbantarthatóságot.

Csomagolt összetett művelet létrehozásakor a lépések egyetlen action.yml fájlban vannak meghatározva. Ez a fájl megadja a bemeneteket, kimeneteket, valamint a végrehajtandó parancsok vagy műveletek sorrendjét. A csomagolt összetett műveletek különösen hasznosak az ismétlődő feladatok automatizálására vagy több rendszerhéjparancs egyetlen újrafelhasználható műveletbe való kombinálására.

Összetett qction létrehozása

1. Címtár beállítása az összetett művelethez

Az összetett műveletet a saját könyvtárában kell elhelyeznie az adattárban.

Példa könyvtárstruktúra:

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

2. A fájl meghatározása action.yml

Az my-composite-action könyvtárban hozzon létre egy action.yml fájlt.

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

Jegyzet: A using: "composite" (összetett) mező azt jelzi, hogy ez a művelet összetett művelet.

3. Az összetett művelet használata munkafolyamatban

Az összetett művelet létrehozása után egy GitHub Actions-munkafolyamatban hivatkozhat rá.

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

Ha az összetett művelet meg van osztva egy másik adattárból, hivatkozzon rá a következő módon:

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

Kimenetek hozzáadása kompozit művelethez

Az összetett műveletek olyan kimeneteket határozhatnak meg, amelyekkel a munkafolyamatok adatokat továbbíthatnak a lépések vagy feladatok között. A kimenetek különösen hasznosak az eredmények vagy a számított értékek megosztásához egyik műveletről a másikra.

Az alábbi példa bemutatja, hogyan definiálhat és használhat kimenetet összetett műveletben:

Kimenet definiálása a következőben: action.yml

A action.yml fájl egy script-result nevű kimenetet határoz meg. Ez a kimenet az értékét a result lépés run-script kimenetéből kapja meg. A run-script lépés egy Bash-parancsot futtat a kimeneti érték beállításához.

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

A kimenet használata munkafolyamatban

Az összetett művelet létrehozása után a kimenete egy munkafolyamatban érhető el. Íme egy példa:

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

Ebben a példában:

• Az összetett műveletet a rendszer a uses kulcsszó használatával hívja meg.
• A kimenet script-result elérése a steps.<step-id>.outputs.<output-name> szintaxis használatával.
• Az eredmény megjelenítése a munkafolyamat-naplókban.

Az összetett műveletek kimeneteinek definiálása újrafelhasználható és moduláris munkafolyamatok létrehozásához. Ez a megközelítés leegyszerűsíti az adatmegosztást, és javítja a karbantarthatóságot.

Ajánlott eljárások összetett műveletekhez

Ajánlott eljárás	Leírás
Verziószámozás használata	Használjon címkét v1 az 1. stabil verzióra való hivatkozáshoz.
Műveletek moduláris megőrzése	Csoportosítsa a kapcsolódó lépéseket egy összetett műveleten belül.
Dokumentumbemenetek > kimenetek	Adja meg a bemenetek/kimenetek leírását a következőben action.yml: .
Tesztelés közzététel előtt	Ellenőrizze az összetett műveletet egy tesztadattárban.

Összetett művelet egy munkafolyamatban

Az összetett műveletek hatékony módszert jelentenek a munkafolyamatok egyszerűsítésére, ha több lépést egy újrafelhasználható egységbe egyesítenek. Ezek a műveletek lehetővé teszik parancsok vagy műveletek sorozatának definiálását egyetlen action.yml fájlban, így egyszerűbbé válik a logika fenntartása és újrafelhasználása a munkafolyamatokban.

Az összetett műveletek előnyei:

• Újrahasználhatóság – Egyszer definiálhatja a műveleteket, és több munkafolyamatban is használhatja őket.
• Karbantarthatóság – A duplikáció csökkentése a logika egyetlen műveletben történő központosításával.
• Modularitás – Több rendszerhéjparancs vagy más művelet kombinálása egyetlen egységben.

Hozz létre egy műveletet a parancssori felület létrehozásához a GitHub Actions futtató környezeteken.

Számos CI-/CD-munkafolyamathoz szükség van egy CLI-eszköz adott verziójára a felhőszolgáltatásokkal való interakcióhoz, az infrastruktúra kezeléséhez vagy szkriptek futtatásához. Bár a GitHub által üzemeltetett futók számos eszközzel rendelkeznek előre telepítve, előfordulhat, hogy nem tartalmazzák a munkafolyamathoz szükséges verziót, különösen akkor, ha régebbi vagy nem támogatott verzióról van szó. A parancssori felület szükséges verziójának minden munkafolyamatban való telepítése helyett létrehozhat egy újrafelhasználható GitHub-műveletet , amely:

• Biztosítja a parancssori felület szükséges verziójának konzisztens telepítését a feladatok között.
• Leegyszerűsíti a munkafolyamatokat a telepítési logika központosításával.
• Optimalizálja a gyorsítótárazást a munkafolyamatok gyorsabb végrehajtására.

Parancssori felület beállítási műveletének fejlesztése

A parancssori felület beállítási művelete egy JavaScript-alapú művelet , amely telepíti és konfigurálja a parancssori felületet egy GitHub-futón.

A művelet létrehozásának lépései:

1. lépés: A műveletkönyvtár beállítása

Ha manuálisan szeretné létrehozni a címtárat a parancssori felület beállítási műveletéhez, kövesse az alábbi lépéseket:

1. Navigálás az adattárhoz

2. Új könyvtár létrehozása a művelethez
   Hozzon létre egy új könyvtárat my-cli-action a .github/actions mappában. Ez biztosítja a művelet rendszerezését, és követi a GitHub egyéni műveletekhez ajánlott struktúráját.

3. Ugrás az új könyvtárra
   Váltson az újonnan létrehozott könyvtárra a művelethez tartozó fájlok hozzáadásának megkezdéséhez:

4. A címtárstruktúra ellenőrzése
   A címtár létrehozása után az adattár struktúrájának a következőképpen kell kinéznie:

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

Most már készen áll a action.yml fájl és más szükséges fájlok létrehozására a parancssori beállításhoz.

2. lépés: A action.yml metaadatfájl definiálása

Hozzon létre egy action.yml fájlt a művelet leírásához.

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"

Miért érdemes használni a következőt: node16? Ez a művelet JavaScript-kódot futtat a Node.js 16 használatával.

3. lépés: JavaScript-szkript létrehozása a parancssori felület telepítéséhez

Ugyanabban a könyvtárban hozzon létre egy index.js nevű fájlt, és adja hozzá a következő kódot:

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();

A fenti JavaScript-kód a core.getInput() használatával kéri le a bemenetként megadott CLI-verziót. Ezután végrehajt egy curl-parancsot a parancssori felület letöltéséhez és telepítéséhez. Ha a telepítési folyamat sikertelen, a művelet a core.setFailed() használatával jelöli meg a munkafolyamatot sikertelenként.

4. lépés: A művelet helyi tesztelése

A művelet munkafolyamatban való használata előtt tesztelje azt egy GitHub által üzemeltetett futón.
Hozzon létre egy munkafolyamatfájlt (.github/workflows/test.yml) az adattárban:

name: Test MyCLI Setup

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

1. A munkafolyamat aktiválása
A munkafolyamat aktiválódik a main ágra és bármely egyéb ágra történő leküldések esetén, amelyek megfelelnek a feature/* mintának. Ezt úgy módosíthatja, hogy megfeleljen az adattár elágaztatási stratégiájának.

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

2. Az adattár klónozása
Az actions/checkout@v4 művelettel klónozza az adattárat a futtatókörnyezetbe. Ez biztosítja, hogy a munkafolyamat hozzáférhessen az adattár fájljaihoz.

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

3. Futtassa az egyéni műveletet
A felhasználások: ./.github/actions/my-cli-action line helyileg hivatkozik az egyéni műveletre. Győződjön meg arról, hogy a műveletkönyvtár és a action.yml fájl megfelelően van beállítva. A verzióbemenet határozza meg a telepíteni kívánt PARANCSSOR-verziót – ebben az esetben az 1.2.3-at.

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

4. A parancssori felület telepítésének ellenőrzése
Ez a lépés egy rendszerhéjparancs futtatásával ellenőrzi, hogy a parancssori felület telepítése sikeresen megtörtént-e. A mycli --version futtatásával ellenőrzi a telepített parancssori felület verzióját.

Helyi tesztelés

A munkafolyamat helyi teszteléséhez használja a CLI eszközt act.

act -j test

Ez szimulálja a GitHub Actions környezetet a helyi gépen, lehetővé téve a munkafolyamat hibakeresését és ellenőrzését a módosítások elküldése előtt.

Optimalizálási tipp: Gyorsítótárazás

A munkafolyamat teljesítményének javítása érdekében gyorsítótárazza a parancssori felület telepítési könyvtárát a actions/cache művelettel:

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

Ez biztosítja, hogy a későbbi futtatások újra felhasználják a gyorsítótárazott parancssori felület telepítését, csökkentve a telepítési időt.

Ajánlott eljárások a parancssori felület beállítási műveleteihez

Ajánlott eljárás	Leírás
Verziószámozás használata	A felhasználók megadhatják a CLI verziót inputs.version.
Hibák megfelelő kezelése	Hibák esetén használja a core.setFailed() kilépéshez.
Gyorsítótár parancssori felületének telepítése	A munkafolyamat teljesítményének optimalizálása a következővel actions/cache: .
Dokumentáció megadása	A használat és a bemenetek ismertetése a következőben: README.md.

JavaScript-műveletek hibaelhárítása

A JavaScript-alapú GitHub Actions használatakor váratlan viselkedés, hibák vagy hibák léphetnek fel a munkafolyamat végrehajtása során. Ez az egység technikákat és eszközöket biztosít a JavaScript-műveletek problémáinak azonosításához és megoldásához.

Gyakori hibaelhárítási forgatókönyvek

Probléma	Lehetséges ok	Javasolt javítás
A művelet veremkövetéssel meghiúsul	Szintaxis- vagy futásidejű hiba a következőben: index.js	Használja a console.log() és ellenőrizze a naplókat
A bemenetek a következők: undefined	Helytelen bemeneti név vagy hiányzó bemenet	A action.yml ellenőrzése és a bemenetek átadásának módja
A környezeti változók nincsenek beállítva	core.exportVariable vagy process.env nem megfelelően használják	A változók kódbeállításának áttekintése
A fájl nem található	Hiányzó relatív elérési utak	Használja a __dirname vagy a fájlok teljes elérési útját.
A gyorsítótár nem állítható vissza	Hibás key vagy path értékek	Gyorsítótár konfigurációjának és kulcsának ellenőrzése

Naplózás használata hibakereséshez

Naplózza az üzeneteket core.info, core.debug és 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");

✅ Használja a core.debug függvényt hibakeresési naplókhoz – ezek csak akkor jelennek meg, ha ACTIONS_STEP_DEBUG igaz értékre van állítva.

Hibakeresési naplózás engedélyezése

A következő titkos kód beállításával engedélyezheti a lépésszintű hibakeresési naplókat:

ACTIONS_STEP_DEBUG=true

A futó diagnosztikai naplók engedélyezéséhez állítsa be a következőt:

ACTIONS_RUNNER_DEBUG=true

Titkos kódok beállítása hibakereséshez

1. Nyissa meg a GitHub-adattárat.
2. Lépjen a Beállítások>titkos kulcsok és változók>műveletek elemre.
3. Adjon hozzá új titkos kulcsokat a következő névvel és értékekkel:
   • ACTIONS_STEP_DEBUG: true
   • ACTIONS_RUNNER_DEBUG: true

Munkafolyamat-naplók vizsgálata

Ha egy munkafolyamat meghiúsul, kattintson a sikertelen feladatra a Műveletek lapon. Bontsa ki az egyes lépéseket a következőre:

• Részletes naplók megtekintése
• Standard kimenet ellenőrzése (stdout)
• A szkriptek kilépési kódjának megtekintése
• Kezeletlen kivételek azonosítása

🔍 Napló kimeneti példa

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

✅ Javítás: Futtassa az npm install parancsot @actions/core, és véglegesítse a node_modules könyvtárat (vagy használja az ncc-t az akció becsomagolásához).

A művelet helyi tesztelése

A GitHub Actions helyi futtatásához használja az act nevű parancssori eszközt. Példa:

act -j test

🛠 Győződjön meg arról, hogy a GitHub-környezetet megfelelően szimulálja a helyi tesztelés során.

Hibák kezelése elegáns módon

Kivételeket foghat ki, és hasznos üzenetekkel hiúsulhat meg:

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

🔁 Ez biztosítja, hogy a GitHub hiba miatt leállítja a munkafolyamatot, és olvasható naplókat biztosítson.

JavaScript-műveletek hibakeresésének ajánlott eljárásai

Gyakorlat	Leírás
A core.debug() használata	Rejtsd el a részletes naplókat, kivéve, ha a hibakeresés engedélyezve van.
Action.yml ellenőrzése	Győződjön meg arról, hogy a bemenetek és kimenetek helyesen vannak definiálva.
Csomagkód	Használja @vercel/ncc, hogy a JavaScript fájlokat egyetlen fájlba lefordítsa. Ez csökkenti a függőségeket, és biztosítja, hogy az összes szükséges modul szerepeljen benne, megakadályozva a hiányzó fájlok által okozott futtatókörnyezeti hibákat.
Teszt aktussal	A gyorsabb iterációk érdekében szimulációkat futtasson helyben.
Try/catch használata	Megakadályozza, hogy a munkafolyamatok csendben meghiúsulnak.

Docker-tárolóműveletek hibaelhárítása

A Docker-tárolóműveletek hatékonyak összetett eszközök és környezetek GitHub Actions-munkafolyamatokban való beágyazására. Ezeknek a műveleteknek a hibakeresése azonban nagyobb kihívást jelenthet, mint a JavaScript-műveletek az izolált futtatókörnyezet miatt. Ez az egység végigvezeti a Docker-alapú műveletek hibáinak azonosításán, diagnosztizálásán és megoldásán.

A Docker-tárolóműveletek gyakori problémái

Probléma	Oka	Javasolt javítás
A művelet nem indul el	ENTRYPOINT vagy CMD helytelenül van konfigurálva	Ellenőrizze, hogy a Dockerfile helyesen használja-e a fájlt ENTRYPOINT
Hiányzó függőségek	A függőségek nincsenek telepítve, vagy helytelenül vannak konfigurálva.	Győződjön meg arról, hogy az összes csomag telepítve van a lemezképen
Nem fogadott bemenetek	INPUT_ környezeti változók nem érhetők el	Használja a process.env.INPUT_<INPUT_NAME> (vagy a rendszerhéj megfelelőjét)
A fájl nem található	Helytelen fájl elérési útja a tárolóban	Abszolút elérési utak használata vagy a címtárstruktúra ellenőrzése
Engedély megtagadva	A fájl vagy szkript nem rendelkezik végrehajtási engedéllyel	Hozzáadás RUN chmod +x <script> a Dockerfile-ban
Hálózattal kapcsolatos hibák	A külső szolgáltatások nem érhetők el	Hálózati beállítások ellenőrzése és újrapróbálkozás logikája

A Docker-művelet életciklusának ismertetése

A hibaelhárítás előtt érdemes tisztában lenni a Docker-tárolóműveletek futtatásának módjával.

1. Munkafolyamat-eseményindító

Egy GitHub Actions-munkafolyamat egy konfigurált eseményre – például egy push, pull_requestvagy manuális workflow_dispatch– válaszként indul el.

2. Futó beállítása

A GitHub egy új virtuális gépet (a futót) helyez üzembe a munkafolyamat végrehajtásához. A futó a műveletdefiníciók letöltésével és a függőségek feloldásával készíti elő a környezetet.

3. Műveletmegoldás

Ha a művelet szerepel runs.using: docker a fájlban action.yml , a GitHub Docker-alapú műveletként ismeri fel.

4. Képfájl létrehozása vagy lekérése

A GitHub létrehozza a műveletben Dockerfile definiált Docker-rendszerképet, vagy amennyiben az meg van adva, lekéri az előre összeállított rendszerképet. Ez a rendszerkép határozza meg azt a környezetet, amelyben a műveleti kód fut.

5. Konténer végrehajtása

A futó elindítja a Docker-tárolót, csatlakoztatja a munkaterületet, és környezeti változókat injektál, beleértve a munkafolyamatban definiált titkos kulcsokat és bemeneteket.

6. Belépési pont futtatások

A GitHub végrehajtja a entrypoint parancsot a tárolón belüli Dockerfile-ból. Itt fut az egyéni műveleti logika, általában egy szkript vagy alkalmazás.

7. Eredménykezelés

A tárolóművelet által beállított kimeneteket a futó rögzíti, és átadja a munkafolyamat későbbi lépéseinek. Miután befejeződik, a tároló leáll, és a futót eldobják.

Megjegyzés: A Docker-tárolóműveletek tiszta, elkülönített környezetben futnak. A fájlrendszer állapotát, a telepített eszközöket és a környezeti változókat a Dockerfile-on belül kell definiálni.

Hibakeresési technikák

A naplózás hozzáadása

Echo, printf vagy naplózási utasításokat használjon a belépésipont-szkriptben:

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

Naplózza az összes kritikus bemenetet és lépést a hiba előfordulásának diagnosztizálásához.

2. Helyi buildelés és tesztelés

A docker használata a számítógépen a tároló viselkedésének szimulálásához:

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

Győződjön meg arról, hogy a környezeti változók a GitHub-készleteket utánozzák.

3. Az act CLI használata GitHub-munkafolyamatok szimulálásához

Telepítse az alkalmazást a GitHub-folyamatok helyi futtatásához.

act -j test-job

Nagyszerűen tesztelhet Docker-műveleteket munkafolyamatokban anélkül, hogy leküldi a GitHubra.

4. Dockerfile konfigurációjának ellenőrzése

Győződjön meg arról, hogy az ENTRYPOINT vagy a CMD definiálva van. Másolja a szkripteket a képre, és adjon nekik végrehajtási engedélyt:

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

5. GitHub-naplók vizsgálata

Kattintson egy sikertelen munkafolyamat-futtatásra, bontsa ki az egyes lépéseket, és vizsgálja meg a következőt:

• Docker építési naplók
• Szabványos kimenet és szabványos hibaüzenet a konténerből
• Kilépési kódok és veremkövetések 🔍 A naplók gyakran hiányzó csomagokat, szintaxisproblémákat vagy engedélyhibákat fednek fel.

Példa: Belépési pont hibája

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

✅ Javítás: RUN chmod +x /entrypoint.sh hozzáadása a Dockerfile-hoz.

Környezeti változók leképezése

GitHub-bemenet	Docker környezeti változó
with: name: test	INPUT_NAME=test
GITHUB_WORKSPACE	leképezve a /github/workspace
GITHUB_EVENT_NAME	A munkafolyamatot aktiváló esemény

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

Hibaelhárítási titkos kódok használata

További naplózás engedélyezéséhez adja hozzá ezeket a titkos kulcsokat az adattárhoz vagy a szervezethez:

Titok	Leírás
ACTIONS_STEP_DEBUG	Hibakeresési naplózás engedélyezése
ACTIONS_RUNNER_DEBUG	Futódiagnosztika engedélyezése

Ajánlott eljárások a Docker-művelet hibakereséséhez

Ajánlott eljárás	Miért
A naplózás nagyvonalú használata	Segít a hibapontok nyomon követésében
Mindig állítsa be a chmod +x értéket	A rendszerhéjszkriptekkel kapcsolatos engedélyhibák elkerülése
Bemenetek ellenőrzése a szkriptben	Hiányzó vagy hibásan formázott bemenetek korai elfogása
Tárolófüggőségek minimalizálása	A kisebb képek könnyebben hibakeresést végezhetnek
Helyi tesztelés Docker-futtatással vagy művelettel	Gyorsabb iterációk és azonnali visszajelzés