trivy-action — Ejecuta Trivy como acción de GitHub para escanear tu imagen de contenedor Docker en busca de vulnerabilidades | Kitploit

### Pipeline de CI de Escaneo (con Configuración de 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

Es posible definir todas las opciones en el archivo `trivy.yaml`. Especificar opciones individuales a través de la acción se conserva por motivos de compatibilidad hacia atrás. Es necesario definir lo siguiente, ya que no se puede definir con el archivo de configuración:
- `scan-ref`: Si se utilizan escaneos `fs, repo`.
- `image-ref`: Si se utiliza el escaneo `image`.
- `scan-type`: Para definir el tipo de escaneo, p. ej. `image`, `fs`, `repo`, etc.

#### Orden de preferencia para las opciones
Trivy utiliza [Viper](https://github.com/spf13/viper), que tiene un orden de precedencia definido para las opciones. El orden es el siguiente:
- Flag de GitHub Action
- Variable de entorno
- Archivo de configuración
- Predeterminado

### Caché
La acción tiene una funcionalidad integrada para almacenar en caché y restaurar [la base de datos de vulnerabilidades](https://github.com/aquasecurity/trivy-db), [la base de datos de Java](https://github.com/aquasecurity/trivy-java-db) y [el paquete de comprobaciones](https://github.com/aquasecurity/trivy-checks) si se descargan durante el escaneo.
La caché se almacena en el directorio `$GITHUB_WORKSPACE/.cache/trivy` de forma predeterminada.
La caché se restaura antes de que comience el escaneo y se guarda después de que finalice.

Utiliza [actions/cache](https://github.com/actions/cache) internamente, pero requiere menos ajustes de configuración.
La entrada `cache` es opcional y el almacenamiento en caché está activado de forma predeterminada.

#### Desactivar el almacenamiento en caché
Si desea desactivar el almacenamiento en caché, establezca la entrada `cache` en `false`, pero recomendamos mantenerlo habilitado para evitar problemas de limitación de velocidad.```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 }}

Al ejecutar un escaneo, establece las variables de entorno `TRIVY_SKIP_DB_UPDATE` y `TRIVY_SKIP_JAVA_DB_UPDATE` para omitir el proceso de descarga.```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

#### Omitir la configuración al llamar a Trivy Action varias veces
Otro caso de uso común es cuando una compilación llama a esta acción varias veces; en este caso, podemos establecer `skip-setup-trivy` en 
`true` en invocaciones posteriores, p. ej.```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 incluso tiene [create-github-app-token](https://github.com/actions/create-github-app-token) para casos similares.

### Escaneando un 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'

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

#### Plantillas por defecto
Trivy tiene [plantillas por defecto][trivy-default-templates].

Por defecto, `setup-trivy` las instala en el directorio `$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'

Puedes encontrar un ejemplo más detallado aquí: https://github.com/aquasecurity/trivy-sarif-demo/blob/master/.github/workflows/scan.yml

Si deseas subir los resultados SARIF al escaneo de código de GitHub incluso cuando el código de salida de Trivy Scan sea distinto de cero, puedes añadir lo siguiente a tu paso de subida:```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'

### Uso de Trivy para escanear tus directorios rootfs

También es posible escanear tus directorios rootfs con el escaneo rootfs integrado de Trivy. Esto puede resultar útil si quieres ejecutar Trivy como una comprobación en tiempo de compilación en cada PR que se abra en tu repositorio. Esto te ayuda a identificar posibles vulnerabilidades que podrían introducirse con cada PR.

Si tienes [escaneo de código de GitHub](https://docs.github.com/en/github/finding-security-vulnerabilities-and-errors-in-your-code/about-code-scanning) disponible, puedes usar Trivy como herramienta de escaneo de la siguiente manera:```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'

**Nota**: Si tu configuración de Terraform contiene módulos privados, configura Git para autenticarse con el repositorio que los aloja. 
Esto se puede hacer añadiendo un paso en tu flujo de trabajo de CI que configure el acceso, por ejemplo usando un token de acceso personal (PAT) o claves 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 }}

  - 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

Al escanear imágenes, es posible que quieras analizar el JSON de salida real, ya que Github Dependency no muestra todos los detalles, como la ruta de archivo de cada dependencia, por ejemplo.

Puedes subir el informe como un artefacto y descargarlo, por ejemplo, usando la [acción 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

  - 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 usa AWS SDK. No necesitas instalar la herramienta CLI de `aws`.
Puedes usar las [variables de entorno de 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'

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

#### Autohospedado
El servidor BasicAuth necesita `TRIVY_USERNAME` y `TRIVY_PASSWORD`.
Si quieres usar el puerto 80, usa 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'

## Personalización

Prioridad de configuración:
- [Entradas](#inputs)
- [Variables de entorno](#environment-variables)
- [Archivo de configuración de Trivy](#trivy-config-file)
- Valores predeterminados


### inputs

Las siguientes entradas se pueden usar como claves de `step.with`:

| Nombre                       | Tipo    | Predeterminado                 | Descripción                                                                                                                                                      |
|------------------------------|---------|--------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `scan-type`                  | String  | `image`                        | Tipo de escaneo, p. ej. `image` o `fs`                                                                                                                           |
| `input`                      | String  |                                | Referencia de tar, p. ej. `alpine-latest.tar`                                                                                                                    |
| `image-ref`                  | String  |                                | Referencia de imagen, p. ej. `alpine:3.10.2`                                                                                                                     |
| `scan-ref`                   | String  | `/github/workspace/`           | Referencia de escaneo, p. ej. `/github/workspace/` o `.`                                                                                                         |
| `format`                     | String  | `table`                        | Formato de salida (`table`, `json`, `template`, `sarif`, `cyclonedx`, `spdx`, `spdx-json`, `github`, `cosign-vuln`)                                             |
| `template`                   | String  |                                | Plantilla de salida (`@$HOME/.local/bin/trivy-bin/contrib/gitlab.tpl`, `@$HOME/.local/bin/trivy-bin/contrib/junit.tpl`)                                          |
| `tf-vars`                    | String  |                                | ruta al archivo de variables de Terraform                                                                                                                        |
| `output`                     | String  |                                | Guardar los resultados en un archivo                                                                                                                             |
| `exit-code`                  | String  | `0`                            | Código de salida cuando se encuentran las vulnerabilidades especificadas                                                                                         |
| `ignore-unfixed`             | Boolean | false                          | Ignorar vulnerabilidades sin parchear o sin corregir                                                                                                             |
| `vuln-type`                  | String  | `os,library`                   | Tipos de vulnerabilidad (os,library)                                                                                                                             |
| `severity`                   | String  | `UNKNOWN,LOW,MEDIUM,HIGH,CRITICAL` | Gravedades de las vulnerabilidades que se escanearán y mostrarán                                                                                                 |
| `skip-dirs`                  | String  |                                | Lista separada por comas de directorios en los que se omite el recorrido                                                                                         |
| `skip-files`                 | String  |                                | Lista separada por comas de archivos en los que se omite el recorrido                                                                                            |
| `cache-dir`                  | String  | `$GITHUB_WORKSPACE/.cache/trivy` | Directorio de caché. NOTA: Este valor no puede configurarse mediante `trivy.yaml`.                                                                               |
| `timeout`                    | String  | `5m0s`                         | Duración del tiempo de espera del escaneo                                                                                                                        |
| `ignore-policy`              | String  |                                | Filtrar vulnerabilidades con el lenguaje OPA rego                                                                                                                |
| `hide-progress`              | String  | `false`                        | Suprimir la barra de progreso y la salida de registro                                                                                                            |
| `list-all-pkgs`              | String  |                                | Mostrar todos los paquetes independientemente de la vulnerabilidad                                                                                               |
| `scanners`                   | String  | `vuln,secret`                  | lista separada por comas de qué problemas de seguridad detectar (`vuln`,`secret`,`misconfig`,`license`)                                                          |
| `trivyignores`               | String  |                                | lista separada por comas de rutas relativas dentro del repositorio a uno o más archivos `.trivyignore`, o un único archivo `.trivyignore.yaml`.                  |
| `trivy-config`               | String  |                                | Ruta al archivo de configuración `trivy.yaml`                                                                                                                    |
| `github-pat`                 | String  |                                | Token de autenticación para permitir el envío de resultados de escaneo SBOM al gráfico de dependencias de GitHub. Puede ser un token de acceso personal (PAT) de GitHub o `GITHUB_TOKEN` |
| `limit-severities-for-sarif` | Boolean | false                          | Por defecto, el formato *SARIF* obliga a mostrar todas las vulnerabilidades independientemente de las gravedades configuradas. Para anular este comportamiento, establezca este parámetro en **true** |
| `docker-host`                | String  |                                | Por defecto se establece en `unix://var/run/docker.sock`, pero puede actualizarse para ayudar con infraestructura basada en contenedores (se requiere `unix:/` u otro prefijo) |
| `version`                    | String  | `v0.72.0`                      | Versión de Trivy que se usará, p. ej. `latest` o `v0.72.0`                                                                                                       |
| `skip-setup-trivy`           | Boolean | false                          | Omitir la llamada a la acción `setup-trivy` para instalar `trivy`                                                                                                |
| `token-setup-trivy`          | Boolean |                                | Sobrescribir `github.token` utilizado por `setup-trivy` para clonar el repositorio `trivy`                                                                       |

### Variables de entorno

Puede utilizar [las variables de entorno de Trivy][trivy-env] para establecer las opciones necesarias (incluidas banderas que no son compatibles con [Entradas](#inputs), como `--secret-config`).

**NB** En algunas versiones anteriores de la acción existía un bug que hacía que las entradas de una llamada a la acción se filtraran 
a llamadas posteriores de la acción.  Esto podía provocar que los flujos de trabajo que llaman a la acción varias veces, p. ej. para ejecutar 
varios escaneos, o los mismos escaneos con diferentes formatos de salida, no produjeran la salida deseada.  Puede comprobar si este
es el caso revisando la información del paso de GitHub Actions: si la sección `env` que se muestra en la salida de GitHub Actions 
contiene variables de entorno `TRIVY_*` que usted no estableció explícitamente, es posible que se vea afectado por este bug y debería 
actualizar a la versión más reciente de la acción.

### Archivo de configuración de Trivy

Al usar la [entrada](#inputs) `trivy-config`, puede establecer opciones mediante el [archivo de configuración de Trivy][trivy-config] (incluidas banderas que no son compatibles con [Entradas](#inputs), como `--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

Más Populares

Uso

Escanear Pipeline de CI```yaml

Actualizar las cachés en la rama predeterminada

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.

Configuración de Trivy

Configurar Trivy manualmente```yaml

Usar un token no predeterminado para instalar Trivy

Using Trivy with templates

Uso de Trivy con GitHub Code Scanning

Usar Trivy para escanear tu repositorio Git

Usando Trivy para escanear Infraestructura como Código

Uso de Trivy para generar SBOM

Para enviar resultados a GitHub Dependency Graph, necesitarás crear un GitHub PAT o usar el token de acceso de instalación de GitHub (también conocido como `GITHUB_TOKEN`):```yaml

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

Usando Trivy para escanear tu registro privado

Registro de Docker Hub

GCR (Google Container Registry)

Uso de Trivy si no tienes el escaneo de código habilitado

trivy-action

Más Populares

Trivy Action

Tabla de contenido

Uso

Escanear Pipeline de CI```yaml

Actualizar las cachés en la rama predeterminada

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.

Configuración de Trivy

Configurar Trivy manualmente```yaml

Usar un token no predeterminado para instalar Trivy

Using Trivy with templates

Uso de Trivy con GitHub Code Scanning

Usar Trivy para escanear tu repositorio Git

Usando Trivy para escanear Infraestructura como Código

Uso de Trivy para generar SBOM

Para enviar resultados a GitHub Dependency Graph, necesitarás crear un GitHub PAT o usar el token de acceso de instalación de GitHub (también conocido como GITHUB_TOKEN):```yaml

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

Usando Trivy para escanear tu registro privado

Registro de Docker Hub

GCR (Google Container Registry)

Uso de Trivy si no tienes el escaneo de código habilitado

Para enviar resultados a GitHub Dependency Graph, necesitarás crear un GitHub PAT o usar el token de acceso de instalación de GitHub (también conocido como `GITHUB_TOKEN`):```yaml