Trivy Action

GitHub Action für Trivy

[![GitHub Release][release-img]][release] [![GitHub Marketplace][marketplace-img]][marketplace] [![License][license-img]][license]

Inhaltsverzeichnis

Verwendung
Anpassen

Verwendung

CI-Pipeline scannen```yaml

name: build on: push: branches: - main pull_request: jobs: build: name: Build runs-on: ubuntu-24.04 steps: - name: Checkout code uses: actions/checkout@v4 - name: Build an image from Dockerfile run: docker build -t docker.io/my-organization/my-app:${{ github.sha }} . - name: Run Trivy vulnerability scanner uses: aquasecurity/[email protected] with: image-ref: 'docker.io/my-organization/my-app:${{ github.sha }}' format: 'table' exit-code: '1' ignore-unfixed: true vuln-type: 'os,library' severity: 'CRITICAL,HIGH'

### Scan der CI-Pipeline (mit Trivy-Konfiguration)```yaml
name: build
on:
  push:
    branches:
    - main
  pull_request:
jobs:
  build:
    name: Build
    runs-on: ubuntu-24.04
    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Run Trivy vulnerability scanner in fs mode
      uses: aquasecurity/[email protected]
      with:
        scan-type: 'fs'
        scan-ref: '.'
        trivy-config: trivy.yaml

In diesem Fall ist trivy.yaml eine YAML-Konfiguration, die als Teil des Repos eingecheckt wird. Detaillierte Informationen sind auf der Trivy-Website verfügbar, aber ein Beispiel ist wie folgt:```yaml format: json exit-code: 1 severity: CRITICAL secret: config: config/trivy/secret.yaml

Es ist möglich, alle Optionen in der Datei `trivy.yaml` zu definieren. Die Angabe einzelner Optionen über die Action dient der Abwärtskompatibilität. Die folgenden Optionen müssen definiert werden, da sie nicht mit der Konfigurationsdatei definiert werden können:
- `scan-ref`: Wenn `fs, repo`-Scans verwendet werden.
- `image-ref`: Wenn ein `image`-Scan verwendet wird.
- `scan-type`: Zur Definition des Scan-Typs, z. B. `image`, `fs`, `repo` usw.

#### Reihenfolge der Priorität für Optionen
Trivy verwendet [Viper](https://github.com/spf13/viper), das eine definierte Prioritätsreihenfolge für Optionen hat. Die Reihenfolge ist wie folgt:
- GitHub-Action-Flag
- Umgebungsvariable
- Konfigurationsdatei
- Standard

### Cache
Die Action verfügt über eine integrierte Funktion zum Caching und Wiederherstellen von [der Schwachstellen-DB](https://github.com/aquasecurity/trivy-db), [der Java-DB](https://github.com/aquasecurity/trivy-java-db) und [dem Checks-Bundle](https://github.com/aquasecurity/trivy-checks), sofern diese während des Scans heruntergeladen werden.
Der Cache wird standardmäßig im Verzeichnis `$GITHUB_WORKSPACE/.cache/trivy` gespeichert.
Der Cache wird vor dem Start des Scans wiederhergestellt und nach Abschluss des Scans gespeichert.

Es verwendet [actions/cache](https://github.com/actions/cache) unter der Haube, erfordert jedoch weniger Konfigurationseinstellungen.
Der Cache-Input ist optional, und das Caching ist standardmäßig aktiviert.

#### Deaktivieren des Cachings
Wenn Sie das Caching deaktivieren möchten, setzen Sie den `cache`-Input auf `false`, aber wir empfehlen, es aktiviert zu lassen, um Rate-Limiting-Probleme zu vermeiden.```yaml
    - name: Run Trivy scanner without cache
      uses: aquasecurity/[email protected]
      with:
        scan-type: 'fs'
        scan-ref: '.'
        cache: 'false'

Aktualisieren von Caches im Standard-Branch

Bitte beachten Sie, dass es Einschränkungen für den Cache-Zugriff zwischen Branches in GitHub Actions gibt. Standardmäßig kann ein Workflow auf einen Cache zugreifen und ihn wiederherstellen, der entweder im aktuellen Branch oder im Standard-Branch (normalerweise main oder master) erstellt wurde. Wenn Sie Caches über Branches hinweg teilen müssen, müssen Sie möglicherweise einen Cache im Standard-Branch erstellen und ihn im aktuellen Branch wiederherstellen.

Um Ihren Workflow zu optimieren, können Sie einen Cron-Job einrichten, der den Cache im Standard-Branch regelmäßig aktualisiert. Dadurch können nachfolgende Scans die zwischengespeicherte DB verwenden, ohne sie erneut herunterzuladen.```yaml

Note: This workflow only updates the cache. You should create a separate workflow for your actual Trivy scans.

In your scan workflow, set TRIVY_SKIP_DB_UPDATE=true and TRIVY_SKIP_JAVA_DB_UPDATE=true.

name: Update Trivy Cache

on: schedule: - cron: '0 0 * * *' # Run daily at midnight UTC workflow_dispatch: # Allow manual triggering

jobs: update-trivy-db: runs-on: ubuntu-latest steps: - name: Setup oras uses: oras-project/setup-oras@v1

  - name: Get current date
    id: date
    run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT

  - name: Download and extract the vulnerability DB
    run: |
      mkdir -p $GITHUB_WORKSPACE/.cache/trivy/db
      oras pull ghcr.io/aquasecurity/trivy-db:2
      tar -xzf db.tar.gz -C $GITHUB_WORKSPACE/.cache/trivy/db
      rm db.tar.gz

  - name: Download and extract the Java DB
    run: |
      mkdir -p $GITHUB_WORKSPACE/.cache/trivy/java-db
      oras pull ghcr.io/aquasecurity/trivy-java-db:1
      tar -xzf javadb.tar.gz -C $GITHUB_WORKSPACE/.cache/trivy/java-db
      rm javadb.tar.gz

  - name: Cache DBs
    uses: actions/cache/save@v4
    with:
      path: ${{ github.workspace }}/.cache/trivy
      key: cache-trivy-${{ steps.date.outputs.date }}

Wenn Sie einen Scan ausführen, setzen Sie die Umgebungsvariablen `TRIVY_SKIP_DB_UPDATE` und `TRIVY_SKIP_JAVA_DB_UPDATE`, um den Download-Prozess zu überspringen.```yaml
    - name: Run Trivy scanner without downloading DBs
      uses: aquasecurity/[email protected]
      with:
        scan-type: 'image'
        scan-ref: 'myimage'
      env:
        TRIVY_SKIP_DB_UPDATE: true
        TRIVY_SKIP_JAVA_DB_UPDATE: true

Trivy-Einrichtung

Standardmäßig ruft die Aktion aquasecurity/setup-trivy als ersten Schritt auf, das die über den version-Input angegebene trivy-Version installiert. Wenn Sie trivy bereits auf andere Weise installiert haben, z. B. durch direkten Aufruf von aquasecurity/setup-trivy, oder diese Aktion mehrmals aufrufen, können Sie den skip-setup-trivy-Input verwenden, um diesen Schritt zu deaktivieren.

Trivy manuell einrichten```yaml

name: build on: push: branches: - main pull_request: jobs: build: name: Build runs-on: ubuntu-24.04 steps: - name: Checkout code uses: actions/checkout@v4

- name: Manual Trivy Setup
  uses: aquasecurity/[email protected]
  with:
    cache: true
    version: v0.72.0

- name: Run Trivy vulnerability scanner in repo mode
  uses: aquasecurity/[email protected]
  with:
    scan-type: 'fs'
    ignore-unfixed: true
    format: 'sarif'
    output: 'trivy-results.sarif'
    severity: 'CRITICAL'
    skip-setup-trivy: true

#### Überspringen des Setups bei mehrfachem Aufrufen der Trivy Action
Ein weiterer häufiger Anwendungsfall ist, wenn ein Build diese Action mehrfach aufruft. In diesem Fall können wir `skip-setup-trivy` bei nachfolgenden Aufrufen auf 
`true` setzen, z. B.```yaml
name: build

on:
  push:
    branches:
      - main
  pull_request:

jobs:
  test:
    runs-on: ubuntu-latest
    permissions:
      contents: read
    steps:
      - name: Check out Git repository
        uses: actions/checkout@v4

      # The first call to the action will invoke setup-trivy and install trivy
      - name: Generate Trivy Vulnerability Report
        uses: aquasecurity/[email protected]
        with:
          scan-type: "fs"
          output: trivy-report.json
          format: json
          scan-ref: .
          exit-code: 0

      - name: Upload Vulnerability Scan Results
        uses: actions/upload-artifact@v4
        with:
          name: trivy-report
          path: trivy-report.json
          retention-days: 30

      - name: Fail build on High/Criticial Vulnerabilities
        uses: aquasecurity/[email protected]
        with:
          scan-type: "fs"
          format: table
          scan-ref: .
          severity: HIGH,CRITICAL
          ignore-unfixed: true
          exit-code: 1
          # On a subsequent call to the action we know trivy is already installed so can skip this
          skip-setup-trivy: true

Nicht-Standard-Token zur Installation von Trivy verwenden

GitHub Enterprise Server (GHES) verwendet ein ungültiges github.token für den Server https://github.com. Daher können Sie Trivy nicht mit der Aktion setup-trivy installieren.

Um dieses Problem zu beheben, müssen Sie das Token für setup-trivy mit der Eingabe token-setup-trivy überschreiben:```yaml - name: Run Trivy scanner without cache uses: aquasecurity/[email protected] with: scan-type: 'fs' scan-ref: '.' token-setup-trivy: ${{ secrets.GITHUB_PAT }}

GitHub hat sogar [create-github-app-token](https://github.com/actions/create-github-app-token) für ähnliche Fälle.

### Einen Tarball scannen```yaml
name: build
on:
  push:
    branches:
    - main
  pull_request:
jobs:
  build:
    name: Build
    runs-on: ubuntu-24.04
    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Generate tarball from image
      run: |
        docker pull <your-docker-image>
        docker save -o vuln-image.tar <your-docker-image>

    - name: Run Trivy vulnerability scanner in tarball mode
      uses: aquasecurity/[email protected]
      with:
        input: /github/workspace/vuln-image.tar
        severity: 'CRITICAL,HIGH'

Trivy mit Vorlagen verwenden

Die Action unterstützt [Trivy-Vorlagen][trivy-templates].

Verwenden Sie die Eingabe template, um den Pfad zur Vorlagendatei anzugeben (denken Sie daran, dem Pfad ein @ voranzustellen).```yaml name: build on: push: branches: - main pull_request: jobs: build: name: Build runs-on: ubuntu-24.04 steps: - name: Checkout code uses: actions/checkout@v4

  - name: Run Trivy vulnerability scanner
    uses: aquasecurity/[email protected]
    with:
      scan-type: "fs"
      scan-ref: .
      format: 'template'
      template: "@path/to/my_template.tpl"

#### Standardvorlagen
Trivy hat [Standardvorlagen][trivy-default-templates].

Standardmäßig installiert `setup-trivy` diese in das Verzeichnis `$HOME/.local/bin/trivy-bin/contrib`.```yaml
name: build
on:
  push:
    branches:
      - main
  pull_request:
jobs:
  build:
    name: Build
    runs-on: ubuntu-24.04
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Run Trivy vulnerability scanner
        uses: aquasecurity/[email protected]
        with:
          scan-type: "fs"
          scan-ref: .
          format: 'template'
          template: "@$HOME/.local/bin/trivy-bin/contrib/html.tpl"

Trivy mit GitHub Code Scanning verwenden

Wenn GitHub code scanning für dich verfügbar ist, kannst du Trivy wie folgt als Scan-Tool verwenden:```yaml name: build on: push: branches: - main pull_request: jobs: build: name: Build runs-on: ubuntu-24.04 permissions: contents: read # Required to checkout and read repo files security-events: write # Required to upload SARIF files to Security tab steps: - name: Checkout code uses: actions/checkout@v4

  - name: Build an image from Dockerfile
    run: |
      docker build -t docker.io/my-organization/my-app:${{ github.sha }} .

  - name: Run Trivy vulnerability scanner
    uses: aquasecurity/[email protected]
    with:
      image-ref: 'docker.io/my-organization/my-app:${{ github.sha }}'
      format: 'sarif'
      output: 'trivy-results.sarif'

  - name: Upload Trivy scan results to GitHub Security tab
    uses: github/codeql-action/upload-sarif@v4
    with:
      sarif_file: 'trivy-results.sarif'

Ein ausführlicheres Beispiel finden Sie hier: https://github.com/aquasecurity/trivy-sarif-demo/blob/master/.github/workflows/scan.yml

Wenn Sie SARIF-Ergebnisse selbst bei einem Exit-Code ungleich Null von Trivy Scan zu GitHub Code scanning hochladen möchten, können Sie Folgendes zu Ihrem Upload-Schritt hinzufügen:```yaml
name: build
on:
  push:
    branches:
      - main
  pull_request:
jobs:
  build:
    name: Build
    runs-on: ubuntu-24.04
    permissions:
      contents: read          # Required to checkout and read repo files
      security-events: write  # Required to upload SARIF files to Security tab
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Build an image from Dockerfile
        run: |
          docker build -t docker.io/my-organization/my-app:${{ github.sha }} .

      - name: Run Trivy vulnerability scanner
        uses: aquasecurity/[email protected]
        with:
          image-ref: 'docker.io/my-organization/my-app:${{ github.sha }}'
          format: 'sarif'
          output: 'trivy-results.sarif'

      - name: Upload Trivy scan results to GitHub Security tab
        uses: github/codeql-action/upload-sarif@v4
        if: always()
        with:
          sarif_file: 'trivy-results.sarif'

Siehe hier für weitere Details: https://docs.github.com/en/actions/learn-github-actions/expressions#always

Verwenden von Trivy zum Scannen Ihres Git-Repos

Es ist auch möglich, Ihre Git-Repos mit dem integrierten Repo-Scan von Trivy zu scannen. Dies kann praktisch sein, wenn Sie Trivy als Build-Zeit-Prüfung für jeden PR ausführen möchten, der in Ihrem Repo geöffnet wird. Dies hilft Ihnen, potenzielle Schwachstellen zu identifizieren, die mit jedem PR eingeführt werden könnten.

Wenn Ihnen GitHub-Code-Scanning zur Verfügung steht, können Sie Trivy wie folgt als Scan-Tool verwenden:```yaml name: build on: push: branches: - main pull_request: jobs: build: name: Build runs-on: ubuntu-24.04 permissions: contents: read # Required to checkout and read repo files security-events: write # Required to upload SARIF files to Security tab steps: - name: Checkout code uses: actions/checkout@v4

  - name: Run Trivy vulnerability scanner in repo mode
    uses: aquasecurity/[email protected]
    with:
      scan-type: 'fs'
      ignore-unfixed: true
      format: 'sarif'
      output: 'trivy-results.sarif'
      severity: 'CRITICAL'

  - name: Upload Trivy scan results to GitHub Security tab
    uses: github/codeql-action/upload-sarif@v4
    with:
      sarif_file: 'trivy-results.sarif'

### Trivy zum Scannen Ihrer Rootfs-Verzeichnisse verwenden
Es ist auch möglich, Ihre Rootfs-Verzeichnisse mit dem integrierten Rootfs-Scan von Trivy zu scannen. Das kann praktisch sein, wenn Sie Trivy als Build-Zeit-Prüfung bei jedem PR ausführen möchten, der in Ihrem Repository eröffnet wird. So können Sie potenzielle Schwachstellen identifizieren, die mit jedem PR eingeführt werden könnten.

Wenn Ihnen [GitHub code scanning](https://docs.github.com/en/github/finding-security-vulnerabilities-and-errors-in-your-code/about-code-scanning) zur Verfügung steht, können Sie Trivy wie folgt als Scan-Tool verwenden:```yaml
name: build
on:
  push:
    branches:
      - main
  pull_request:
jobs:
  build:
    name: Build
    runs-on: ubuntu-24.04
    permissions:
      contents: read          # Required to checkout and read repo files
      security-events: write  # Required to upload SARIF files to Security tab
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Run Trivy vulnerability scanner with rootfs command
        uses: aquasecurity/[email protected]
        with:
          scan-type: 'rootfs'
          scan-ref: 'rootfs-example-binary'
          ignore-unfixed: true
          format: 'sarif'
          output: 'trivy-results.sarif'
          severity: 'CRITICAL'

      - name: Upload Trivy scan results to GitHub Security tab
        uses: github/codeql-action/upload-sarif@v4
        with:
          sarif_file: 'trivy-results.sarif'

Verwenden von Trivy zum Scannen von Infrastructure as Code

Es ist auch möglich, Ihre IaC-Repos mit dem integrierten Repo-Scan von Trivy zu scannen. Das kann praktisch sein, wenn Sie Trivy als Build-Zeit-Check für jeden PR ausführen möchten, der in Ihrem Repo geöffnet wird. Dies hilft Ihnen, potenzielle Schwachstellen zu identifizieren, die mit jedem PR eingeführt werden könnten.

Wenn Ihnen GitHub code scanning zur Verfügung steht, können Sie Trivy wie folgt als Scan-Tool verwenden:```yaml name: build on: push: branches: - main pull_request: jobs: build: name: Build runs-on: ubuntu-24.04 permissions: contents: read # Required to checkout and read repo files security-events: write # Required to upload SARIF files to Security tab steps: - name: Checkout code uses: actions/checkout@v4

  - name: Run Trivy vulnerability scanner in IaC mode
    uses: aquasecurity/[email protected]
    with:
      scan-type: 'config'
      hide-progress: true
      format: 'sarif'
      output: 'trivy-results.sarif'
      exit-code: '1'
      severity: 'CRITICAL,HIGH'

  - name: Upload Trivy scan results to GitHub Security tab
    if: always()
    uses: github/codeql-action/upload-sarif@v4
    with:
      sarif_file: 'trivy-results.sarif'

**Hinweis**: Wenn Ihre Terraform-Konfiguration private Module enthält, konfigurieren Sie Git so, dass es sich beim Repository authentifiziert, das sie hostet. 
Dies kann durch einen Schritt in Ihrem CI-Workflow erfolgen, der den Zugriff einrichtet, zum Beispiel mit einem Personal Access Token (PAT) oder SSH-Schlüsseln:```yaml
- name: Configure Git for private modules
  run: |
    git config --global url."https://$GITHUB_USER:[email protected]/".insteadOf "https://github.com/"
  env:
    GITHUB_USER: ${{ github.actor }}
    PRIVATE_REPO_TOKEN: ${{ secrets.PRIVATE_REPO_TOKEN }}

Dadurch wird sichergestellt, dass Trivy private Module herunterladen kann.

Mit Trivy ein SBOM erstellen

Trivy kann ein SBOM Ihrer Abhängigkeiten erstellen und an einen Empfänger wie GitHub Dependency Graph übermitteln.

Die Funktion zum Senden einer SBOM an GitHub ist nur verfügbar, wenn Sie den GitHub Dependency Graph derzeit in Ihrem Repository aktiviert haben.

Um Ergebnisse an den GitHub Dependency Graph zu senden, müssen Sie ein GitHub-PAT erstellen oder das GitHub-Installationszugriffstoken (auch bekannt als `GITHUB_TOKEN`) verwenden:```yaml

name: Generate SBOM on: push: branches: - main

GITHUB_TOKEN authentication, add only if you're not going to use a PAT

permissions: contents: write

jobs: generate-sbom: runs-on: ubuntu-latest steps: - name: Checkout code uses: actions/checkout@v4

  - name: Run Trivy in GitHub SBOM mode and submit results to Dependency Graph
    uses: aquasecurity/[email protected]
    with:
      scan-type: 'fs'
      format: 'github'
      output: 'dependency-results.sbom.json'
      scan-ref: '.'
      github-pat: ${{ secrets.GITHUB_TOKEN }} # or ${{ secrets.github_pat_name }} if you're using a PAT

Beim Scannen von Bildern möchten Sie möglicherweise die tatsächliche JSON-Ausgabe parsen, da Github Dependency nicht alle Details anzeigt, wie beispielsweise den Dateipfad jeder Abhängigkeit.

Sie können den Bericht als Artefakt hochladen und herunterladen, beispielsweise mit der [upload-artifact action](https://github.com/actions/upload-artifact):```yaml
---
name: Generate SBOM
on:
  push:
    branches:
    - main

## GITHUB_TOKEN authentication, add only if you're not going to use a PAT
permissions:
  contents: write

jobs:
  generate-sbom:
    runs-on: ubuntu-latest
    steps:
      - name: Scan image in a private registry
        uses: aquasecurity/[email protected]
        with:
          image-ref: "private_image_registry/image_name:image_tag"
          scan-type: image
          format: 'github'
          output: 'dependency-results.sbom.json'
          github-pat: ${{ secrets.GITHUB_TOKEN }} # or ${{ secrets.github_pat_name }} if you're using a PAT
          severity: "MEDIUM,HIGH,CRITICAL"
          scanners: "vuln"
        env:
          TRIVY_USERNAME: "image_registry_admin_username"
          TRIVY_PASSWORD: "image_registry_admin_password"

      - name: Upload trivy report as a Github artifact
        uses: actions/upload-artifact@v4
        with:
          name: trivy-sbom-report
          path: '${{ github.workspace }}/dependency-results.sbom.json'
          retention-days: 20 # 90 is the default

Verwenden von Trivy zum Scannen Ihrer privaten Registry

Es ist auch möglich, Ihre private Registry mit Trivys integriertem Bildscan zu scannen. Alles, was Sie tun müssen, ist, ENV-Variablen zu setzen.

Docker-Hub-Registry

Docker Hub benötigt TRIVY_USERNAME und TRIVY_PASSWORD. Sie müssen keine ENV-Variablen setzen, wenn Sie aus einem öffentlichen Repository herunterladen.```yaml name: build on: push: branches: - main pull_request: jobs: build: name: Build runs-on: ubuntu-24.04 permissions: contents: read # Required to checkout and read repo files security-events: write # Required to upload SARIF results to the GitHub Security tab steps: - name: Checkout code uses: actions/checkout@v4

  - name: Run Trivy vulnerability scanner
    uses: aquasecurity/[email protected]
    with:
      image-ref: 'docker.io/my-organization/my-app:${{ github.sha }}'
      format: 'sarif'
      output: 'trivy-results.sarif'
    env:
      TRIVY_USERNAME: Username
      TRIVY_PASSWORD: Password

  - name: Upload Trivy scan results to GitHub Security tab
    uses: github/codeql-action/upload-sarif@v4
    with:
      sarif_file: 'trivy-results.sarif'

#### AWS ECR (Elastic Container Registry)
Trivy verwendet das AWS SDK. Du musst das `aws` CLI-Tool nicht installieren.
Du kannst [die ENV-Variablen der AWS CLI][env-var] verwenden.

[env-var]: https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html%60%60%60yaml
name: build
on:
  push:
    branches:
      - main
  pull_request:
jobs:
  build:
    name: Build
    runs-on: ubuntu-24.04
    permissions:
      contents: read          # Required to checkout and read repo files
      security-events: write  # Required to upload SARIF files to Security tab
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Run Trivy vulnerability scanner
        uses: aquasecurity/[email protected]
        with:
          image-ref: 'aws_account_id.dkr.ecr.region.amazonaws.com/imageName:${{ github.sha }}'
          format: 'sarif'
          output: 'trivy-results.sarif'
        env:
          AWS_ACCESS_KEY_ID: key_id
          AWS_SECRET_ACCESS_KEY: access_key
          AWS_DEFAULT_REGION: us-west-2

      - name: Upload Trivy scan results to GitHub Security tab
        uses: github/codeql-action/upload-sarif@v4
        with:
          sarif_file: 'trivy-results.sarif'

GCR (Google Container Registry)

Trivy verwendet das Google Cloud SDK. Sie müssen den Befehl gcloud nicht installieren.

Wenn Sie das Repository des Zielprojekts verwenden möchten, können Sie es über GOOGLE_APPLICATION_CREDENTIALS festlegen.```yaml name: build on: push: branches: - main pull_request: jobs: build: name: Build runs-on: ubuntu-24.04 permissions: contents: read # Required to checkout and read repo files security-events: write # Required to upload SARIF files to Security tab steps: - name: Checkout code uses: actions/checkout@v4

  - name: Run Trivy vulnerability scanner
    uses: aquasecurity/[email protected]
    with:
      image-ref: 'docker.io/my-organization/my-app:${{ github.sha }}'
      format: 'sarif'
      output: 'trivy-results.sarif'
    env:
      GOOGLE_APPLICATION_CREDENTIALS: /path/to/credential.json

  - name: Upload Trivy scan results to GitHub Security tab
    uses: github/codeql-action/upload-sarif@v4
    with:
      sarif_file: 'trivy-results.sarif'

#### Selbst gehostet
Der BasicAuth-Server benötigt `TRIVY_USERNAME` und `TRIVY_PASSWORD`.
Wenn du Port 80 verwenden möchtest, verwende NonSSL `TRIVY_NON_SSL=true`.```yaml
name: build
on:
  push:
    branches:
      - main
  pull_request:
jobs:
  build:
    name: Build
    runs-on: ubuntu-24.04
    permissions:
      contents: read          # Required to checkout and read repo files
      security-events: write  # Required to upload SARIF files to Security tab
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Run Trivy vulnerability scanner
        uses: aquasecurity/[email protected]
        with:
          image-ref: 'docker.io/my-organization/my-app:${{ github.sha }}'
          format: 'sarif'
          output: 'trivy-results.sarif'
        env:
          TRIVY_USERNAME: Username
          TRIVY_PASSWORD: Password

      - name: Upload Trivy scan results to GitHub Security tab
        uses: github/codeql-action/upload-sarif@v4
        with:
          sarif_file: 'trivy-results.sarif'

Trivy verwenden, wenn kein Code-Scanning aktiviert ist

Es ist auch möglich, ein Scan-Ergebnis in einer Workflow-Zusammenfassung einzusehen.

Dieser Schritt ist besonders nützlich für private Repositories ohne GitHub Advanced Security-Lizenz.```yaml

name: Run Trivy scanner uses: aquasecurity/[email protected] with: scan-type: config hide-progress: true output: trivy.txt
name: Publish Trivy Output to Summary run: | if [[ -s trivy.txt ]]; then { echo "### Security Output" echo "
Click to expand
" echo "" echo 'terraform' cat trivy.txt echo '' echo "
" } >> $GITHUB_STEP_SUMMARY fi

## Customizing

Configuration priority:
- [Eingaben](#inputs)
- [Umgebungsvariablen](#environment-variables)
- [Trivy-Konfigurationsdatei](#trivy-config-file)
- Standardwerte


### inputs

Die folgenden Eingaben können als `step.with`-Schlüssel verwendet werden:

| Name                         | Typ     | Standard                          | Beschreibung                                                                                                                                                     |
|------------------------------|---------|------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `scan-type`                  | String  | `image`                            | Scan-Typ, z. B. `image` oder `fs`                                                                                                                                  |
| `input`                      | String  |                                    | Tar-Referenz, z. B. `alpine-latest.tar`                                                                                                                          |
| `image-ref`                  | String  |                                    | Image-Referenz, z. B. `alpine:3.10.2`                                                                                                                            |
| `scan-ref`                   | String  | `/github/workspace/`               | Scan-Referenz, z. B. `/github/workspace/` oder `.`                                                                                                                 |
| `format`                     | String  | `table`                            | Ausgabeformat (`table`, `json`, `template`, `sarif`, `cyclonedx`, `spdx`, `spdx-json`, `github`, `cosign-vuln`)                                                  |
| `template`                   | String  |                                    | Ausgabetemplate (`@$HOME/.local/bin/trivy-bin/contrib/gitlab.tpl`, `@$HOME/.local/bin/trivy-bin/contrib/junit.tpl`)                                              |
| `tf-vars`                    | String  |                                    | Pfad zur Terraform-Variablendatei                                                                                                                                 |
| `output`                     | String  |                                    | Ergebnisse in einer Datei speichern                                                                                                                                           |
| `exit-code`                  | String  | `0`                                | Exit-Code, wenn die angegebenen Schwachstellen gefunden werden                                                                                                               |
| `ignore-unfixed`             | Boolean | false                              | Nicht gepatchte/ungefixte Schwachstellen ignorieren                                                                                                                         |
| `vuln-type`                  | String  | `os,library`                       | Schwachstellentypen (os,library)                                                                                                                                 |
| `severity`                   | String  | `UNKNOWN,LOW,MEDIUM,HIGH,CRITICAL` | Schweregrade der Schwachstellen, nach denen gescannt und die angezeigt werden sollen                                                                                                       |
| `skip-dirs`                  | String  |                                    | Durch Komma getrennte Liste von Verzeichnissen, in denen die Durchsuchung übersprungen wird                                                                                                   |
| `skip-files`                 | String  |                                    | Durch Komma getrennte Liste von Dateien, für die die Durchsuchung übersprungen wird                                                                                                         |
| `cache-dir`                  | String  | `$GITHUB_WORKSPACE/.cache/trivy`   | Cache-Verzeichnis. HINWEIS: Dieser Wert kann nicht über `trivy.yaml` konfiguriert werden.                                                                                          |
| `timeout`                    | String  | `5m0s`                             | Scan-Timeout-Dauer                                                                                                                                            |
| `ignore-policy`              | String  |                                    | Schwachstellen mit der OPA-Regosprache filtern                                                                                                                    |
| `hide-progress`              | String  | `false`                            | Fortschrittsbalken und Protokollausgabe unterdrücken                                                                                                                             |
| `list-all-pkgs`              | String  |                                    | Alle Pakete unabhängig von Schwachstellen ausgeben                                                                                                                  |
| `scanners`                   | String  | `vuln,secret`                      | Durch Komma getrennte Liste der zu erkennenden Sicherheitsprobleme (`vuln`,`secret`,`misconfig`,`license`)                                                                   |
| `trivyignores`               | String  |                                    | Durch Komma getrennte Liste von relativen Pfaden innerhalb des Repositorys zu einer oder mehreren `.trivyignore`-Dateien oder einer einzelnen `.trivyignore.yaml`-Datei.                          |
| `trivy-config`               | String  |                                    | Pfad zur trivy.yaml-Konfiguration                                                                                                                                        |
| `github-pat`                 | String  |                                    | Authentifizierungstoken zum Aktivieren des Sendens von SBOM-Scanergebnissen an den GitHub-Dependency-Graph. Kann entweder ein GitHub Personal Access Token (PAT) oder GITHUB_TOKEN sein.          |
| `limit-severities-for-sarif` | Boolean | false                              | Standardmäßig erzwingt das *SARIF*-Format die Ausgabe aller Schwachstellen unabhängig von den konfigurierten Schweregraden. Um dieses Verhalten zu überschreiben, setzen Sie diesen Parameter auf **true**   |
| `docker-host`                | String  |                                    | Standardmäßig ist er auf `unix://var/run/docker.sock` gesetzt, kann aber aktualisiert werden, um containerisierte Infrastrukturwerte zu unterstützen (`unix:/` oder ein anderes Präfix ist erforderlich) |
| `version`                    | String  | `v0.72.0`                          | Zu verwendende Trivy-Version, z. B. `latest` oder `v0.72.0`                                                                                                                 |
| `skip-setup-trivy`           | Boolean | false                              | Überspringen des Aufrufs der `setup-trivy`-Aktion zum Installieren von `trivy`                                                                                                         |
| `token-setup-trivy`          | Boolean |                                    | `github.token` überschreiben, das von `setup-trivy` zum Auschecken des `trivy`-Repositorys verwendet wird                                                                                |

### Environment variables
Sie können [Trivy-Umgebungsvariablen][trivy-env] verwenden, um die erforderlichen Optionen festzulegen (einschließlich Flags, die von [Eingaben](#inputs) nicht unterstützt werden, wie z. B. `--secret-config`).

**Hinweis** In einigen älteren Versionen der Aktion gab es einen Fehler, der dazu führte, dass Eingaben von einem Aufruf der Aktion in 
nachfolgende Aufrufe der Aktion übergingen.  Dies konnte dazu führen, dass Workflows, die die Aktion mehrmals aufrufen, z. B. um 
mehrere Scans oder dieselben Scans mit unterschiedlichen Ausgabeformaten auszuführen, nicht die gewünschte Ausgabe erzeugten.  Sie können feststellen, ob dies
der Fall ist, indem Sie sich die Schrittinformationen der GitHub Actions ansehen: Wenn der in Ihrer Actions-Ausgabe angezeigte `env`-Abschnitt 
`TRIVY_*`-Umgebungsvariablen enthält, die Sie nicht explizit gesetzt haben, sind Sie möglicherweise von diesem Fehler betroffen und sollten 
auf die neueste Version der Aktion aktualisieren.

### Trivy config file
Bei Verwendung der `trivy-config`-[Eingabe](#inputs) können Sie Optionen über die [Trivy-Konfigurationsdatei][trivy-config] festlegen (einschließlich Flags, die von [Eingaben](#inputs) nicht unterstützt werden, wie z. B. `--secret-config`).

[release]: https://github.com/aquasecurity/trivy-action/releases/latest
[release-img]: https://img.shields.io/github/release/aquasecurity/trivy-action.svg?logo=github
[marketplace]: https://github.com/marketplace/actions/aqua-security-trivy
[marketplace-img]: https://img.shields.io/badge/marketplace-trivy--action-blue?logo=github
[license]: https://raw.githubusercontent.com/aquasecurity/trivy-action/master/LICENSE
[license-img]: https://img.shields.io/github/license/aquasecurity/trivy-action
[trivy-env]: https://aquasecurity.github.io/trivy/latest/docs/configuration/#environment-variables
[trivy-config]: https://aquasecurity.github.io/trivy/latest/docs/references/configuration/config-file/
[trivy-templates]: https://aquasecurity.github.io/trivy/latest/docs/configuration/reporting/#template
[trivy-default-templates]: https://aquasecurity.github.io/trivy/latest/docs/configuration/reporting/#template

trivy-action

Beliebteste