trivy-action — Führt Trivy als GitHub-Action aus, um Ihr Docker-Container-Image auf Schwachstellen zu scannen. | Kitploit

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

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'

  - 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

- 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

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'

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

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

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

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

  - 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

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

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

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

Verwendung

CI-Pipeline scannen```yaml

Aktualisieren von Caches im Standard-Branch

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.

Trivy-Einrichtung

Trivy manuell einrichten```yaml

Nicht-Standard-Token zur Installation von Trivy verwenden

Trivy mit Vorlagen verwenden

Trivy mit GitHub Code Scanning verwenden

Verwenden von Trivy zum Scannen Ihres Git-Repos

Verwenden von Trivy zum Scannen von Infrastructure as Code

Mit Trivy ein SBOM erstellen

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

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

Verwenden von Trivy zum Scannen Ihrer privaten Registry

Docker-Hub-Registry

GCR (Google Container Registry)

Trivy verwenden, wenn kein Code-Scanning aktiviert ist

trivy-action

Beliebteste

Trivy Action

Inhaltsverzeichnis

Verwendung

CI-Pipeline scannen```yaml

Aktualisieren von Caches im Standard-Branch

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.

Trivy-Einrichtung

Trivy manuell einrichten```yaml

Nicht-Standard-Token zur Installation von Trivy verwenden

Trivy mit Vorlagen verwenden

Trivy mit GitHub Code Scanning verwenden

Verwenden von Trivy zum Scannen Ihres Git-Repos

Verwenden von Trivy zum Scannen von Infrastructure as Code

Mit Trivy ein SBOM erstellen

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

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

Verwenden von Trivy zum Scannen Ihrer privaten Registry

Docker-Hub-Registry

GCR (Google Container Registry)

Trivy verwenden, wenn kein Code-Scanning aktiviert ist

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