Hvordan bruker jeg GitHub-handlinger til å opprette arbeidsflyter for CI?

Fullført

Husk at målet ditt er å automatisere kodebygg- og publiseringsprosessen slik at funksjonene oppdateres hver gang en utvikler legger til en endring i kodebasen.

Hvis du vil implementere denne prosessen, lærer du hvordan du:

• Opprett en arbeidsflyt fra en mal.
• Unngå duplisering ved å bruke gjenbrukbare arbeidsflyter.
• Test mot flere mål.
• Skill bygg- og testjobber.

Opprette en arbeidsflyt fra en mal

Hvis du vil opprette en arbeidsflyt, er det vanlig å begynne med å bruke en mal. En mal har vanlige jobber og trinn som er forhåndskonfigurert for den bestemte typen automatisering du implementerer. Hvis du ikke er kjent med arbeidsflyter, jobber og trinn, kan du se Automatiser utviklingsoppgaver ved hjelp av GitHub Actions-modulen.

Velg Handlinger på hovedsiden i GitHub-repositoriet, og velg deretter Ny arbeidsflyt.

På siden Velg en arbeidsflyt kan du velge blant mange typer maler. Et eksempel er den Node.js malen. MalenNode.js installerer Node.js og alle avhengigheter, bygger kildekoden og kjører tester for ulike versjoner av Node.js. Et annet eksempel er Python-pakkemalen , som installerer Python og dens avhengigheter, og deretter kjører tester, inkludert lo, i flere versjoner av Python.

Hvis du vil begynne med Node.js arbeidsflytmal, skriver du inn Node.jsi søkeboksen.

Velg Konfigurer i Node.js-ruten i søkeresultatene.

En node.js.yml fil for prosjektet opprettes fra malen:

name: Node.js CI

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]

jobs:
  build:

    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [14.x, 16.x, 18.x]

    steps:
    - uses: actions/checkout@v3
    - name: Use Node.js ${{ matrix.node-version }}
      uses: actions/setup-node@v3
      with:
        node-version: ${{ matrix.node-version }}
        cache: 'npm'
    - run: npm ci
    - run: npm run build --if-present
    - run: npm test

Som vist i attributtet on , kjører dette eksemplet arbeidsflyten som svar på enten en push til repositoriet eller når en pull-forespørsel opprettes mot hovedgrenen.

Denne arbeidsflyten kjører én jobb, angitt av attributtet job .

Attributtet runs-on angir at arbeidsflyten kjører på ubuntu-latestfor operativsystemet. Attributtet node-version angir at det finnes tre bygg, én hver for Node.js versjon 14.x, 16.x og 18.x. Attributtet matrix er beskrevet i dybden senere i modulen.

I attributtet jobs bruker trinnene Handlingene for GitHub-handlinger/checkout@v3 til å hente koden fra repositoriet til en virtuell maskin (VM) og handlinger/oppsett-node@v3 for å konfigurere riktig versjon av Node.js. Du angir at du vil teste tre versjoner av Node.js ved hjelp av attributtet ${{ matrix.node-version }} . Dette attributtet refererer til matrisen du definerte tidligere. Attributtet cache angir en pakkebehandling for hurtigbufring i standardkatalogen.

Den siste delen av dette trinnet utfører kommandoer som Node.js prosjekter bruker. Kommandoen npm ci installerer avhengigheter fra package-lock.json filen. npm run build --if-present kjører et byggskript hvis det finnes. npm test kjører testrammeverket. Denne malen inneholder både bygg- og testtrinn i samme jobb.

Hvis du vil ha mer informasjon om npm, kan du se npm-dokumentasjonen:

• npm installer
• npm kjøre
• npm-test

Et team av utviklere kan dra nytte av å bruke gjenbrukbare arbeidsflyter til å effektivisere og standardisere gjentatte automatiseringstrinn. Ved å bruke gjenbrukbare arbeidsflyter kan du redusere redundans, forbedre vedlikeholdsevnen og sikre konsekvens på tvers av kontinuerlig integrering/kontinuerlig distribusjon (CI/CD)-datasamlebånd.

Unngå duplisering ved hjelp av gjenbrukbare arbeidsflyter

Etter hvert som grupper skalerer og prosjekter vokser, er det vanlig å se de samme trinnene som gjentas på tvers av flere arbeidsflytfiler. Disse trinnene kan omfatte kodeutsjekking, avhengighetsinstallasjon, testing og distribusjon. Denne typen duplisering fyller ikke bare kodebasen, men øker også vedlikeholdstiden når kodeendringer kreves. Gjenbrukbare arbeidsflyter løser dette problemet ved å la deg definere automatiseringslogikk én gang, og deretter kalle logikken fra andre arbeidsflyter.

Gjenbrukbare arbeidsflyter er spesielle Arbeidsflyter for GitHub-handlinger som andre arbeidsflyter kan kalle, på samme måte som funksjoner i programmering. Du oppretter dem for å dele gjentatt logikk, for eksempel byggetrinn, testprosedyrer eller distribusjonsstrategier. Når du har opprettet en arbeidsflyt som kan brukes på nytt, kan du referere til den fra en hvilken som helst annen arbeidsflyt i samme repositorium eller til og med i forskjellige repositorier.

Hvorfor bruke gjenbrukbare arbeidsflyter?

Dette er fordelene ved å bruke gjenbrukbare arbeidsflyter:

• Konsistens. Teams kan følge de samme automatiseringsstandardene på tvers av alle prosjekter.
• Effektivitet. I stedet for å kopiere og lime inn trinn, peker du bare på en gjenbrukbar arbeidsflyt.
• Enklere oppdateringer. Når en prosess endres, for eksempel ved å legge til et testtrinn, oppdaterer du den på ett sted. Deretter automatisk alle arbeidsflyter som bruker arbeidsflytfordelen.
• Skalerbarhet. Gjenbrukbare arbeidsflyter er ideelle for plattform- eller DevOps-team som administrerer flere tjenester.

Deretter kan du utforske hvordan du bruker gjenbrukbare arbeidsflyter til å forbedre prosjektene dine.

Implementere gjenbrukbare arbeidsflyter

Slik bruker du gjenbrukbare arbeidsflyter:

1. Opprett en gjenbrukbar arbeidsflyt i repositoriummappen. Filen inneholder automatiseringstrinnene du vil dele, for eksempel vanlige trinn som er involvert i testing, bygging og distribusjon.
2. Eksplisitt gjør det mulig for en arbeidsflyt å kunne brukes på nytt ved å konfigurere den workflow_call med hendelsen.
3. I hovedarbeidsflytene (anroperarbeidsflyter) refererer du til denne gjenbrukbare filen og gir eventuelle nødvendige inndata eller hemmeligheter.

Hvis du vil illustrere fordelene med gjenbrukbare arbeidsflyter, kan du vurdere følgende virkelige scenario.

Eksempel

Tenk deg at organisasjonen har 10 mikrotjenester. Alle 10 mikrotjenester trenger de samme trinnene for å:

• Kjør tester
• Lokode
• Distribuer til et bestemt miljø

Uten gjenbrukbare arbeidsflyter ender hvert repositorium opp med å duplisere den samme logikken på tvers av flere arbeidsflytfiler, noe som fører til gjentatte trinn og vanskeligere vedlikehold.

Hvis du bruker gjenbrukbare arbeidsflyter:

• Du definerer prosessen én gang i en sentral fil (for eksempel i ci-standard.yml).
• Du kaller denne filen fra hver mikrotjenestes egen arbeidsflyt, og sender inn variabler som miljø eller programnavnet.

Hvis et nytt sikkerhetstrinn eller et nytt verktøy legges til, for eksempel for å søke etter sårbarheter, legger du det bare til én gang i arbeidsflyten som kan brukes på nytt. Alle 10 mikrotjenester begynner umiddelbart å bruke den oppdaterte prosessen. Du trenger ikke å endre 10 mikrotjenester.

Ved å forstå hvordan gjenbrukbare arbeidsflyter fungerer og fordelene deres, kan du ta i bruk anbefalte fremgangsmåter for å maksimere effektiviteten og sikre sømløs integrering med CI/CD-datasamlebånd.

Beste fremgangsmåter

• Sentraliser gjenbrukbare arbeidsflyter i ett repositorium hvis du planlegger å dele dem på tvers av team.
• Bruk forgreninger eller koder til å versjonere arbeidsflytene (for eksempel bruk @v1), slik at du enkelt kan rulle tilbake endringer hvis det er nødvendig.
• Dokumentinndata og hemmeligheter tydelig. Gjenbrukbare arbeidsflyter er ofte avhengige av inndata og hemmeligheter. Teams må vite hvilken informasjon som skal brukes.
• Hvis du bare trenger å bruke noen få trinn på nytt, kan du kombinere gjenbrukbare arbeidsflyter med sammensatte handlinger i stedet for å opprette en fullstendig arbeidsflyt.

Gjenbrukbare arbeidsflyter er en effektiv måte å håndheve konsekvens på, redusere duplisering og skalere DevOps-praksiser i alle tekniske team. Uansett om du administrerer ett enkelt repositorium, mikrotjenester eller biblioteker med åpen kildekode, kan gjenbrukbare arbeidsflyter forenkle automatiseringen, slik at CI/CD-en er raskere, renere og enklere å administrere.

Tilpasse arbeidsflytmaler

I begynnelsen av denne modulen vurderte du et scenario der du må konfigurere CI for gruppen av utviklere. Malen Node.js er en god start, men du vil tilpasse den slik at den passer bedre til teamets krav. Du vil målrette mot ulike versjoner av Node.js og ulike operativsystemer. Du vil også at bygge- og testtrinnene skal være separate jobber.

Her er et eksempel på en tilpasset arbeidsflyt:

strategy:
  matrix:
    os: [ubuntu-latest, windows-latest]
    node-version: [16.x, 18.x]

I dette eksemplet konfigurerer du en byggmatrise for testing på tvers av flere operativsystemer og språkversjoner. Denne matrisen produserer fire bygg, én for hvert operativsystem sammenkoblet med hver versjon av Node.js.

Fire bygg og deres tester produserer en stor mengde loggdata. Det kan være vanskelig å sortere gjennom det hele. I eksemplet nedenfor flytter du testtrinnet til en dedikert testjobb. Denne jobben tester mot flere mål. Hvis du skiller trinnene for bygg og test, blir det enklere å arbeide med loggdataene.

test:
  runs-on: ${{ matrix.os }}
  strategy:
    matrix:
      os: [ubuntu-latest, windows-latest]
      node-version: [16.x, 18.x]
  steps:
  - uses: actions/checkout@v3
  - name: Use Node.js ${{ matrix.node-version }}
    uses: actions/setup-node@v3
    with:
      node-version: ${{ matrix.node-version }}
  - name: npm install, and test
    run: |
      npm install
      npm test
    env:
      CI: true