Wiki

Page name

Content

Oversikt over alle 12 tilgjengelige contexts i GitHub Actions-workflows, med eksempel på output. En context er et objekt du leser verdier fra med `${{ ... }}`-syntaks, f.eks. `${{ github.sha }}`.

Noen contexts (som `github` og `runner`) er tilgjengelige overalt i en workflow, mens andre (`matrix`, `needs`, `inputs`) bare finnes når workflowen faktisk bruker den funksjonen.

## Oversikt

| Context | Hva den inneholder | Tilgjengelig |
|---|---|---|
| [`github`](#github) | Info om workflow-kjøringen og hendelsen som trigget den | Overalt |
| [`env`](#env) | Variabler satt i workflow, job eller step | Overalt |
| [`vars`](#vars) | Konfigurasjonsvariabler satt på org-, repo- eller miljønivå | Overalt |
| [`job`](#job) | Info om jobben som kjører nå | Job/step |
| [`jobs`](#jobs) | Outputs fra jobber i en reusable workflow | Kun i reusable workflows |
| [`steps`](#steps) | Outputs og resultater fra tidligere steps i samme job | Job/step |
| [`runner`](#runner) | Info om maskinen (runneren) som kjører jobben | Job/step |
| [`secrets`](#secrets) | Navn og verdier på secrets tilgjengelig for kjøringen | Overalt |
| [`strategy`](#strategy) | Info om matrise-strategien til jobben | Job med matrix-strategi |
| [`matrix`](#matrix) | De matrise-verdiene som gjelder for akkurat denne jobben | Job med matrix-strategi |
| [`needs`](#needs) | Outputs fra jobber denne jobben er avhengig av (`needs:`) | Job med needs: |
| [`inputs`](#inputs) | Input-verdier gitt til en reusable/manuelt trigget workflow | Reusable/manual workflow |

## github

Den mest brukte contexten. Inneholder informasjon om repoet, commiten, hendelsen som trigget workflowen, og selve kjøringen.

| Egenskap | Beskrivelse | Eksempel |
|---|---|---|
| `github.sha` | Commit-SHA som trigget workflowen | `ffac537e6cbbf934b08745a378932722df287a5` |
| `github.ref` | Full ref til branch/tag | `refs/heads/main` |
| `github.ref_name` | Kort navn på branch/tag | `main` |
| `github.ref_type` | Type ref | `branch` |
| `github.event_name` | Navn på hendelsen som trigget kjøringen | `push` |
| `github.event` | Hele webhook-payloaden som objekt | `{ "commits": [...], "pusher": {...} }` |
| `github.repository` | Eier og repo-navn | `geira/mitt-repo` |
| `github.repository_owner` | Brukernavn på eier | `geira` |
| `github.actor` | Brukeren som trigget kjøringen | `geira` |
| `github.run_id` | Unik ID for denne workflow-kjøringen | `1658821493` |
| `github.run_number` | Løpenummer for denne workflowen | `42` |
| `github.run_attempt` | Forsøksnummer (øker ved re-run) | `1` |
| `github.job` | ID på jobben som kjører nå | `build` |
| `github.workflow` | Navnet på workflowen | `CI` |
| `github.workspace` | Arbeidsmappe på runneren | `/home/runner/work/mitt-repo/mitt-repo` |
| `github.server_url` | URL til GitHub-serveren | `https://github.com` |
| `github.api_url` | URL til REST API-et | `https://api.github.com` |
| `github.token` | Auto-generert token for API-kall (bruk `secrets.GITHUB_TOKEN` i praksis) | `***` (maskert i logg) |
| `github.base_ref` | Mål-branch i en pull request | `main` |
| `github.head_ref` | Kilde-branch i en pull request | `feature/ny-knapp` |

```yaml
- name: Vis commit-info
  run: |
    echo "SHA: ${{ github.sha }}"
    echo "Branch: ${{ github.ref_name }}"
    echo "Trigget av: ${{ github.actor }}"
```

Output:
```
SHA: ffac537e6cbbf934b08745a378932722df287a5
Branch: main
Trigget av: geira
```

## env

Variabler du selv har definert med `env:` på workflow-, job- eller step-nivå. Brukes til å lese egne variabler i uttrykk (ikke i selve shell-scriptet, der brukes `$NAVN` direkte).

```yaml
env:
  NODE_ENV: production

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Vis miljø
        run: echo "Kjører i ${{ env.NODE_ENV }}"
```

Output:
```
Kjører i production
```

## vars

Konfigurasjonsvariabler satt i repo-, organisasjons- eller miljøinnstillingene på GitHub (Settings → Secrets and variables → Actions → Variables). I motsetning til `env` er disse ikke hardkodet i workflow-filen, og i motsetning til `secrets` er de ikke maskert i loggen.

```yaml
- name: Vis deploy-miljø
  run: echo "Deployer til ${{ vars.DEPLOY_ENV }}"
```

Output:
```
Deployer til staging
```

## job

Informasjon om jobben som kjører akkurat nå – status, container og service-containere.

| Egenskap | Beskrivelse | Eksempel |
|---|---|---|
| `job.status` | Nåværende resultat av jobben så langt | `success` |
| `job.container.id` | ID på jobbens container (hvis definert) | `d3d6c3d0d123` |
| `job.services.<navn>.id` | ID på en service-container | `a1b2c3d4e5f6` |

```yaml
- name: Sjekk status
  if: always()
  run: echo "Jobbstatus: ${{ job.status }}"
```

Output:
```
Jobbstatus: success
```

## jobs

Brukes inni en *reusable workflow* (`workflow_call`) for å definere hvilke outputs workflowen skal eksponere til den som kaller den. Ikke å forveksle med `needs`, som brukes i den kallende workflowen.

```yaml
# I selve den gjenbrukbare workflow-filen:
on:
  workflow_call:
    outputs:
      build-id:
        value: ${{ jobs.build.outputs.build-id }}

jobs:
  build:
    outputs:
      build-id: ${{ steps.set-id.outputs.id }}
    steps:
      - id: set-id
        run: echo "id=bygg-1234" >> "$GITHUB_OUTPUT"
```

Output (som annen workflow leser):
```
build-id: bygg-1234
```

## steps

Gir tilgang til outputs og resultat fra tidligere steps i *samme job*. Krever at steget har en `id`.

| Egenskap | Beskrivelse | Eksempel |
|---|---|---|
| `steps.<id>.outputs.<navn>` | En output-verdi definert av steget | `v1.4.2` |
| `steps.<id>.outcome` | Resultat før continue-on-error vurderes | `success` |
| `steps.<id>.conclusion` | Resultat etter continue-on-error er tatt hensyn til | `success` |

```yaml
- name: Hent versjon
  id: version
  run: echo "tag=v1.4.2" >> "$GITHUB_OUTPUT"

- name: Bruk versjonen
  run: echo "Bygger versjon ${{ steps.version.outputs.tag }}"
```

Output:
```
Bygger versjon v1.4.2
```

## runner

Informasjon om maskinen (runneren) som utfører jobben.

| Egenskap | Beskrivelse | Eksempel |
|---|---|---|
| `runner.os` | Operativsystem | `Linux` |
| `runner.arch` | Arkitektur | `X64` |
| `runner.name` | Navnet på runneren | `GitHub Actions 4` |
| `runner.temp` | Sti til midlertidig mappe | `/home/runner/work/_temp` |
| `runner.tool_cache` | Sti til forhåndsinstallerte verktøy | `/opt/hostedtoolcache` |
| `runner.environment` | GitHub-hostet eller selvhostet | `github-hosted` |

```yaml
- name: Vis runner-info
  run: echo "${{ runner.os }} / ${{ runner.arch }}"
```

Output:
```
Linux / X64
```

## secrets

Secrets tilgjengelig for kjøringen, inkludert det automatisk genererte `GITHUB_TOKEN` og egendefinerte secrets. GitHub maskerer alltid verdien i loggen.

```yaml
- name: Logg inn
  run: echo "Bruker token ${{ secrets.GITHUB_TOKEN }}"

- name: Bruk eget secret
  run: deploy --key "${{ secrets.DEPLOY_KEY }}"
```

Output:
```
Bruker token ***
```

## strategy

Detaljer om matrise-strategien til jobben – hvor mange jobber, hvilken posisjon denne jobben har, og innstillinger for parallellitet.

| Egenskap | Beskrivelse | Eksempel |
|---|---|---|
| `strategy.job-index` | Denne jobbens posisjon i matrisen (0-indeksert) | `1` |
| `strategy.job-total` | Totalt antall jobber i matrisen | `3` |
| `strategy.fail-fast` | Om alle jobber avbrytes hvis én feiler | `true` |
| `strategy.max-parallel` | Maks antall jobber som kjører samtidig | `2` |

```yaml
- name: Vis matrise-posisjon
  run: echo "Jobb ${{ strategy.job-index }} av ${{ strategy.job-total }}"
```

Output:
```
Jobb 1 av 3
```

## matrix

De konkrete matrise-verdiene som gjelder for akkurat denne jobb-instansen.

```yaml
jobs:
  test:
    strategy:
      matrix:
        node-version: [18.x, 20.x, 22.x]
    runs-on: ubuntu-latest
    steps:
      - name: Vis Node-versjon
        run: echo "Tester med Node ${{ matrix.node-version }}"
```

Output (én av tre jobber):
```
Tester med Node 20.x
```

## needs

Gir tilgang til resultat og outputs fra jobber denne jobben har erklært som avhengighet med `needs:`.

```yaml
jobs:
  build:
    runs-on: ubuntu-latest
    outputs:
      artifact-name: ${{ steps.build.outputs.name }}
    steps:
      - id: build
        run: echo "name=app-build-1234" >> "$GITHUB_OUTPUT"

deploy:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Deploy artefakt
        run: echo "Deployer ${{ needs.build.outputs.artifact-name }}"
```

Output:
```
Deployer app-build-1234
```

## inputs

Input-verdier gitt til en gjenbrukbar workflow (`workflow_call`) eller til en manuelt trigget workflow (`workflow_dispatch`).

```yaml
on:
  workflow_dispatch:
    inputs:
      environment:
        description: "Miljø å deploye til"
        default: "staging"
        type: string

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Vis valgt miljø
        run: echo "Deployer til ${{ inputs.environment }}"
```

Output (hvis "production" ble valgt manuelt):
```
Deployer til production
```

## Kilder

- https://docs.github.com/en/actions/reference/workflows-and-actions/contexts
- https://docs.github.com/en/actions/learn-github-actions/contexts