aquasecurity/trivy-actionExécute Trivy en tant qu'action GitHub pour analyser votre image de conteneur Docker à la recherche de vulnérabilités
Action GitHub pour Trivy
[![GitHub Release][release-img]][release] [![GitHub Marketplace][marketplace-img]][marketplace] [![License][license-img]][license]
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'
### Pipeline CI de Scan (avec configuration Trivy)```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
Dans ce cas, trivy.yaml est une configuration YAML qui est incluse dans le dépôt. Des informations détaillées sont disponibles sur le site web de Trivy, mais un exemple est le suivant :```yaml
format: json
exit-code: 1
severity: CRITICAL
secret:
config: config/trivy/secret.yaml
Il est possible de définir toutes les options dans le fichier `trivy.yaml`. La spécification d'options individuelles via l'action est conservée à des fins de rétrocompatibilité. La définition des éléments suivants est nécessaire car ils ne peuvent pas être définis avec le fichier de configuration :
- `scan-ref` : si vous utilisez les analyses `fs, repo`.
- `image-ref` : si vous utilisez l'analyse `image`.
- `scan-type` : pour définir le type d'analyse, par ex. `image`, `fs`, `repo`, etc.
#### Ordre de préférence des options
Trivy utilise [Viper](https://github.com/spf13/viper) qui a un ordre de priorité défini pour les options. L'ordre est le suivant :
- Drapeau de l'action GitHub
- Variable d'environnement
- Fichier de configuration
- Par défaut
### Cache
L'action intègre une fonctionnalité de mise en cache et de restauration [de la base de données de vulnérabilités](https://github.com/aquasecurity/trivy-db), [de la base de données Java](https://github.com/aquasecurity/trivy-java-db) et [du bundle de vérifications](https://github.com/aquasecurity/trivy-checks) s'ils sont téléchargés lors de l'analyse.
Le cache est stocké par défaut dans le répertoire `$GITHUB_WORKSPACE/.cache/trivy`.
Le cache est restauré avant le début de l'analyse et enregistré après la fin de l'analyse.
Il utilise [actions/cache](https://github.com/actions/cache) en interne mais nécessite moins de paramètres de configuration.
L'entrée du cache est facultative et la mise en cache est activée par défaut.
#### Désactiver la mise en cache
Si vous souhaitez désactiver la mise en cache, définissez l'entrée `cache` sur `false`, mais nous recommandons de la garder activée pour éviter les problèmes de limitation de débit.```yaml
- name: Run Trivy scanner without cache
uses: aquasecurity/[email protected]
with:
scan-type: 'fs'
scan-ref: '.'
cache: 'false'
Veuillez noter qu'il existe des restrictions sur l'accès au cache entre les branches dans GitHub Actions.
Par défaut, un workflow peut accéder et restaurer un cache créé soit dans la branche courante, soit dans la branche par défaut (généralement main ou master).
Si vous devez partager des caches entre branches, vous devrez peut-être créer un cache dans la branche par défaut et le restaurer dans la branche courante.
Pour optimiser votre workflow, vous pouvez configurer une tâche cron pour mettre à jour régulièrement le cache dans la branche par défaut. Cela permet aux analyses suivantes d'utiliser la base de données (DB) en cache sans la télécharger à nouveau.```yaml
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 }}
Lors de l'exécution d'un scan, définissez les variables d'environnement `TRIVY_SKIP_DB_UPDATE` et `TRIVY_SKIP_JAVA_DB_UPDATE` pour ignorer le processus de téléchargement.```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
Par défaut, l'action appelle aquasecurity/setup-trivy comme première étape,
qui installe la version de trivy spécifiée par l'entrée version. Si vous avez déjà installé trivy par d'autres
moyens, par exemple en appelant aquasecurity/setup-trivy directement, ou si vous invoquez cette action plusieurs fois,
vous pouvez utiliser l'entrée skip-setup-trivy pour désactiver cette étape.
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
#### Ignorer la configuration lors de l'appel multiple de l'action Trivy
Un autre cas d'usage courant est lorsqu'une build appelle cette action plusieurs fois, dans ce cas, nous pouvons définir `skip-setup-trivy` sur `true` lors des invocations suivantes, par exemple.```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
Le Serveur GitHub Enterprise (GHES) utilise un github.token invalide pour le serveur https://github.com.
Par conséquent, vous ne pouvez pas installer Trivy en utilisant l'action setup-trivy.
Pour résoudre ce problème, vous devez écraser le jeton pour setup-trivy en utilisant l'entrée token-setup-trivy :```yaml
- name: Run Trivy scanner without cache
uses: aquasecurity/[email protected]
with:
scan-type: 'fs'
scan-ref: '.'
token-setup-trivy: ${{ secrets.GITHUB_PAT }}
GitHub a même [create-github-app-token](https://github.com/actions/create-github-app-token) pour des cas similaires.
### Analyse d'une archive Tarball```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'
L'action prend en charge les [modèles Trivy][trivy-templates].
Utilisez l'entrée template pour spécifier le chemin (n'oubliez pas de préfixer le chemin avec @) vers le fichier de modèle.```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"
#### Modèles par défaut
Trivy a [default templates][trivy-default-templates].
Par défaut, `setup-trivy` les installe dans le répertoire `$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"
Si vous avez GitHub code scanning disponible, vous pouvez utiliser Trivy comme outil de scan comme suit :```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'
Vous pouvez trouver un exemple plus détaillé ici : https://github.com/aquasecurity/trivy-sarif-demo/blob/master/.github/workflows/scan.yml
Si vous souhaitez télécharger les résultats SARIF vers GitHub Code scanning même en cas de code de sortie non nul de Trivy Scan, vous pouvez ajouter ce qui suit à votre étape de téléchargement :```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'
Voir ceci pour plus de détails : https://docs.github.com/en/actions/learn-github-actions/expressions#always
Il est également possible d'analyser vos dépôts Git avec l'analyse de dépôt intégrée de Trivy. Cela peut être pratique si vous souhaitez exécuter Trivy comme une vérification au moment de la construction sur chaque PR ouverte dans votre dépôt. Cela vous aide à identifier les vulnérabilités potentielles qui pourraient être introduites avec chaque PR.
Si vous disposez de l'analyse de code GitHub, vous pouvez utiliser Trivy comme outil d'analyse comme suit :```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'
### Utiliser Trivy pour scanner vos répertoires rootfs
Il est également possible de scanner vos répertoires rootfs avec le scan rootfs intégré de Trivy. Cela peut être pratique si vous souhaitez exécuter Trivy comme une vérification au moment de la construction sur chaque PR qui est ouverte dans votre dépôt. Cela vous aide à identifier les vulnérabilités potentielles qui pourraient être introduites avec chaque PR.
Si vous disposez de [GitHub code scanning](https://docs.github.com/en/github/finding-security-vulnerabilities-and-errors-in-your-code/about-code-scanning) disponible, vous pouvez utiliser Trivy comme outil de scan comme suit :```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'
Il est également possible de scanner vos dépôts IaC avec l'analyse de dépôt intégrée de Trivy. Cela peut être pratique si vous souhaitez exécuter Trivy comme une vérification au moment de la construction sur chaque PR qui est ouverte dans votre dépôt. Cela vous aide à identifier les vulnérabilités potentielles qui pourraient être introduites avec chaque PR.
Si vous avez GitHub code scanning disponible, vous pouvez utiliser Trivy comme outil de scan comme suit :```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'
**Remarque**: Si votre configuration Terraform contient des modules privés, configurez Git pour s'authentifier auprès du dépôt qui les héberge.
Cela peut être fait en ajoutant une étape dans votre workflow CI qui configure l'accès, par exemple en utilisant un Personal Access Token (PAT) ou des clés SSH:```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 }}
Cela garantit que Trivy peut télécharger des modules privés.
Il est possible pour Trivy de générer un SBOM de vos dépendances et de les soumettre à un consommateur comme GitHub Dependency Graph.
La fonctionnalité d'envoi d'un SBOM à GitHub n'est disponible que si vous avez actuellement GitHub Dependency Graph activé dans votre dépôt.
GITHUB_TOKEN) :```yamlname: Generate SBOM on: push: branches: - main
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
Lors de l'analyse d'images, vous pouvez vouloir analyser le JSON de sortie réel car Github Dependency n'affiche pas tous les détails, comme le chemin du fichier de chaque dépendance par exemple.
Vous pouvez envoyer le rapport en tant qu'artefact et le télécharger, par exemple en utilisant l'[action upload-artifact](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
Il est également possible de scanner votre registre privé avec la fonctionnalité de scan d'images intégrée de Trivy. Tout ce que vous avez à faire est de définir des variables d'environnement.
Docker Hub nécessite TRIVY_USERNAME et TRIVY_PASSWORD.
Vous n'avez pas besoin de définir des variables d'environnement lorsque vous téléchargez depuis un dépôt public.```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 utilise AWS SDK. Vous n'avez pas besoin d'installer l'outil CLI `aws`.
Vous pouvez utiliser les [variables d'environnement de l'AWS CLI][env-var].
[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'
Trivy utilise le Google Cloud SDK. Vous n'avez pas besoin d'installer la commande gcloud.
Si vous souhaitez utiliser le référentiel du projet cible, vous pouvez le définir via GOOGLE_APPLICATION_CREDENTIALS.```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'
#### Auto-hébergé
Le serveur BasicAuth nécessite `TRIVY_USERNAME` et `TRIVY_PASSWORD`.
si vous voulez utiliser le port 80, utilisez 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'
Il est également possible de parcourir un résultat de scan dans un résumé de workflow.
Cette étape est particulièrement utile pour les dépôts privés sans licence GitHub Advanced Security.```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 "
terraform' cat trivy.txt echo ''
echo "## Personnalisation
Priorité de configuration :
- [Entrées](#inputs)
- [Variables d'environnement](#environment-variables)
- [Fichier de configuration Trivy](#trivy-config-file)
- Valeurs par défaut
### entrées
Les entrées suivantes peuvent être utilisées comme clés `step.with` :
| Nom | Type | Par défaut | Description |
|------------------------------|---------|------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `scan-type` | String | `image` | Type d'analyse, p. ex. `image` ou `fs` |
| `input` | String | | Référence tar, p. ex. `alpine-latest.tar` |
| `image-ref` | String | | Référence d'image, p. ex. `alpine:3.10.2` |
| `scan-ref` | String | `/github/workspace/` | Référence d'analyse, p. ex. `/github/workspace/` ou `.` |
| `format` | String | `table` | Format de sortie (`table`, `json`, `template`, `sarif`, `cyclonedx`, `spdx`, `spdx-json`, `github`, `cosign-vuln`) |
| `template` | String | | Modèle de sortie (`@$HOME/.local/bin/trivy-bin/contrib/gitlab.tpl`, `@$HOME/.local/bin/trivy-bin/contrib/junit.tpl`) |
| `tf-vars` | String | | chemin vers le fichier de variables Terraform |
| `output` | String | | Enregistrer les résultats dans un fichier |
| `exit-code` | String | `0` | Code de sortie lorsque des vulnérabilités spécifiées sont trouvées |
| `ignore-unfixed` | Boolean | false | Ignorer les vulnérabilités non corrigées/non résolues |
| `vuln-type` | String | `os,library` | Types de vulnérabilités (os,library) |
| `severity` | String | `UNKNOWN,LOW,MEDIUM,HIGH,CRITICAL` | Gravités des vulnérabilités à analyser et à afficher |
| `skip-dirs` | String | | Liste séparée par des virgules des répertoires où le parcours est ignoré |
| `skip-files` | String | | Liste séparée par des virgules des fichiers où le parcours est ignoré |
| `cache-dir` | String | `$GITHUB_WORKSPACE/.cache/trivy` | Répertoire de cache. REMARQUE : Cette valeur ne peut pas être configurée par `trivy.yaml`. |
| `timeout` | String | `5m0s` | Durée du délai d'analyse |
| `ignore-policy` | String | | Filtrer les vulnérabilités avec le langage OPA rego |
| `hide-progress` | String | `false` | Supprimer la barre de progression et la sortie des logs |
| `list-all-pkgs` | String | | Afficher tous les paquets indépendamment des vulnérabilités |
| `scanners` | String | `vuln,secret` | liste séparée par des virgules des problèmes de sécurité à détecter (`vuln`,`secret`,`misconfig`,`license`) |
| `trivyignores` | String | | liste séparée par des virgules de chemins relatifs dans le dépôt vers un ou plusieurs fichiers `.trivyignore`, ou un seul fichier `.trivyignore.yaml`. |
| `trivy-config` | String | | Chemin vers la configuration trivy.yaml |
| `github-pat` | String | | Jeton d'authentification pour permettre l'envoi des résultats d'analyse SBOM au GitHub Dependency Graph. Peut être un jeton d'accès personnel GitHub (PAT) ou GITHUB_TOKEN |
| `limit-severities-for-sarif` | Boolean | false | Par défaut, le format *SARIF* force la sortie de toutes les vulnérabilités indépendamment des gravités configurées. Pour modifier ce comportement, définissez ce paramètre sur **true** |
| `docker-host` | String | | Par défaut, il est défini sur `unix://var/run/docker.sock`, mais peut être mis à jour pour aider avec les valeurs d'infrastructure conteneurisée (`unix:/` ou un autre préfixe est requis) |
| `version` | String | `v0.72.0` | Version de Trivy à utiliser, p. ex. `latest` ou `v0.72.0` |
| `skip-setup-trivy` | Boolean | false | Ignorer l'appel de l'action `setup-trivy` pour installer `trivy` |
| `token-setup-trivy` | Boolean | | Écraser `github.token` utilisé par `setup-trivy` pour cloner le dépôt `trivy` |
### Variables d'environnement
Vous pouvez utiliser les [variables d'environnement de Trivy][trivy-env] pour définir les options nécessaires (y compris les indicateurs qui ne sont pas pris en charge par les [Entrées](#inputs), comme `--secret-config`).
**NB** Dans certaines versions plus anciennes de l'Action, il y avait un bug qui faisait que les entrées d'un appel à l'Action fuyaient vers les appels suivants à l'Action. Cela pouvait entraîner que les workflows appelant l'Action plusieurs fois, par exemple pour effectuer plusieurs analyses, ou les mêmes analyses avec des formats de sortie différents, ne produisent pas le résultat souhaité. Vous pouvez vérifier si c'est le cas en regardant les informations de l'étape GitHub Actions ; si la section `env` affichée dans votre sortie Actions contient des variables d'environnement `TRIVY_*` que vous n'avez pas définies explicitement, alors vous pourriez être affecté par ce bug et devriez mettre à jour vers la dernière version de l'Action.
### Fichier de configuration Trivy
Lorsque vous utilisez l'[Entrée](#inputs) `trivy-config`, vous pouvez définir des options à l'aide du [fichier de configuration Trivy][trivy-config] (y compris les indicateurs qui ne sont pas pris en charge par les [Entrées](#inputs), comme `--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