Trivy Action

GitHub Action para Trivy

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

Índice

Uso
Personalização

Uso

Varredura do Pipeline de CI```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'

### Pipeline de CI de Varredura (com Config do 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

Neste caso, trivy.yaml é uma configuração YAML que é versionada como parte do repositório. Informações detalhadas estão disponíveis no site do Trivy, mas um exemplo é o seguinte:```yaml format: json exit-code: 1 severity: CRITICAL secret: config: config/trivy/secret.yaml

É possível definir todas as opções no arquivo `trivy.yaml`. Especificar opções individuais por meio da ação é mantido para fins de compatibilidade retroativa. A definição dos seguintes itens é necessária, pois eles não podem ser definidos com o arquivo de configuração:
- `scan-ref`: Se usar varreduras `fs, repo`.
- `image-ref`: Se usar varredura `image`.
- `scan-type`: Para definir o tipo de varredura, ex.: `image`, `fs`, `repo`, etc.

#### Ordem de preferência para opções
O Trivy usa [Viper](https://github.com/spf13/viper), que tem uma ordem de precedência definida para opções. A ordem é a seguinte:
- Flag do GitHub Action
- Variável de ambiente
- Arquivo de configuração
- Padrão

### Cache
A ação tem uma funcionalidade integrada para armazenar em cache e restaurar [o banco de dados de vulnerabilidades](https://github.com/aquasecurity/trivy-db), [o banco de dados Java](https://github.com/aquasecurity/trivy-java-db) e [o pacote de verificações](https://github.com/aquasecurity/trivy-checks) se forem baixados durante a varredura.
O cache é armazenado no diretório `$GITHUB_WORKSPACE/.cache/trivy` por padrão.
O cache é restaurado antes do início da varredura e salvo após o término da varredura.

Ele usa [actions/cache](https://github.com/actions/cache) internamente, mas requer menos configurações.
A entrada de cache é opcional, e o armazenamento em cache é ativado por padrão.

#### Desativando o cache
Se quiser desativar o cache, defina a entrada `cache` como `false`, mas recomendamos mantê-lo ativado para evitar problemas de limitação de taxa.```yaml
    - name: Run Trivy scanner without cache
      uses: aquasecurity/[email protected]
      with:
        scan-type: 'fs'
        scan-ref: '.'
        cache: 'false'

Atualizando caches no branch padrão

Observe que existem restrições de acesso ao cache entre branches no GitHub Actions. Por padrão, um workflow pode acessar e restaurar um cache criado no branch atual ou no branch padrão (geralmente main ou master). Se você precisar compartilhar caches entre branches, talvez seja necessário criar um cache no branch padrão e restaurá-lo no branch atual.

Para otimizar seu workflow, você pode configurar um job cron para atualizar regularmente o cache no branch padrão. Isso permite que as verificações subsequentes usem o banco de dados em cache sem baixá-lo novamente.```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 }}

Ao executar uma varredura, defina as variáveis de ambiente `TRIVY_SKIP_DB_UPDATE` e `TRIVY_SKIP_JAVA_DB_UPDATE` para ignorar o processo de download.```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

Configuração do Trivy

Por padrão, a ação chama aquasecurity/setup-trivy como primeira etapa que instala a versão do trivy especificada pela entrada version. Se você já instalou o trivy por outros meios, por exemplo, chamando aquasecurity/setup-trivy diretamente, ou se está invocando esta ação várias vezes, você pode usar a entrada skip-setup-trivy para desabilitar esta etapa.

Configurando o Trivy Manualmente```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

#### Ignorar a configuração ao chamar a Action Trivy várias vezes
Outro caso de uso comum é quando um build chama essa action várias vezes; nesse caso, podemos definir `skip-setup-trivy` como 
`true` em invocações subsequentes, por exemplo.```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

Usar token não padrão para instalar o Trivy

O GitHub Enterprise Server (GHES) usa um github.token inválido para o servidor https://github.com. Portanto, você não pode instalar o Trivy usando a action setup-trivy.

Para corrigir esse problema, você precisa sobrescrever o token do setup-trivy usando o input 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 até tem [create-github-app-token](https://github.com/actions/create-github-app-token) para casos semelhantes.

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

Usando Trivy com templates

A ação suporta [templates Trivy][trivy-templates].

Use a entrada template para especificar o caminho (lembre-se de prefixar o caminho com @) do arquivo de template.```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"

#### Modelos padrão
O Trivy tem [modelos padrão][trivy-default-templates].

Por padrão, o `setup-trivy` instala-os no diretório `$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"

Usando o Trivy com o GitHub Code Scanning

Se você tiver o GitHub code scanning disponível, poderá usar o Trivy como ferramenta de varredura da seguinte forma:```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'

Você pode encontrar um exemplo mais detalhado aqui: https://github.com/aquasecurity/trivy-sarif-demo/blob/master/.github/workflows/scan.yml

Se você quiser enviar os resultados SARIF para o GitHub Code scanning mesmo com um código de saída diferente de zero do Trivy Scan, você pode adicionar o seguinte à sua etapa de upload:```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'

Veja isto para mais detalhes: https://docs.github.com/en/actions/learn-github-actions/expressions#always

Usando o Trivy para escanear seu repositório Git

Também é possível escanear seus repositórios git com o scan de repositório integrado do Trivy. Isso pode ser útil se você quiser executar o Trivy como uma verificação em tempo de build em cada PR que for aberta no seu repositório. Isso ajuda você a identificar possíveis vulnerabilidades que possam ser introduzidas a cada PR.

Se você tiver o GitHub code scanning disponível, você pode usar o Trivy como ferramenta de varredura da seguinte forma:```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'

### Usando o Trivy para escanear seus diretórios rootfs
Também é possível escanear seus diretórios rootfs com o escaneamento rootfs integrado do Trivy. Isso pode ser útil se você quiser executar o Trivy como uma verificação em tempo de build em cada PR que for aberto no seu repositório. Isso ajuda a identificar possíveis vulnerabilidades que possam ser introduzidas em cada PR.

Se você tiver [GitHub code scanning](https://docs.github.com/en/github/finding-security-vulnerabilities-and-errors-in-your-code/about-code-scanning) disponível, você pode usar o Trivy como ferramenta de escaneamento da seguinte forma:```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'

Usando o Trivy para escanear Infraestrutura como Código

Também é possível escanear seus repositórios de IaC com o escaneamento de repositórios integrado do Trivy. Isso pode ser útil se você quiser executar o Trivy como uma verificação em tempo de build em cada PR que for aberto no seu repositório. Isso ajuda a identificar possíveis vulnerabilidades que possam ser introduzidas a cada PR.

Se você tiver GitHub code scanning disponível, pode usar o Trivy como ferramenta de escaneamento da seguinte forma:```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'

**Nota**: Se a sua configuração do Terraform contiver módulos privados, configure o Git para autenticar com o repositório que os hospeda. 
Isso pode ser feito adicionando uma etapa no seu fluxo de trabalho de CI que configure o acesso, por exemplo usando um Personal Access Token (PAT) ou chaves 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 }}

Isso garante que o Trivy possa baixar módulos privados.

Usando o Trivy para gerar SBOM

É possível que o Trivy gere um SBOM das suas dependências e o envie para um consumidor como o GitHub Dependency Graph.

O recurso de envio de um SBOM para o GitHub só está disponível se você tiver o GitHub Dependency Graph habilitado no seu repositório.

Para enviar resultados para o GitHub Dependency Graph, você precisará criar um GitHub PAT ou usar o token de acesso de instalação do GitHub (também conhecido como `GITHUB_TOKEN`):```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

Ao escanear imagens, você pode querer analisar o JSON de saída real, pois o Github Dependency não mostra todos os detalhes, como o caminho do arquivo de cada dependência, por exemplo.

Você pode enviar o relatório como um artefato e baixá-lo, por exemplo, usando a [ação 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

Usando o Trivy para escanear seu registro privado

Também é possível escanear seu registro privado com o escaneamento de imagens integrado do Trivy. Tudo o que você precisa fazer é definir as variáveis de ambiente.

Registro do Docker Hub

O Docker Hub precisa de TRIVY_USERNAME e TRIVY_PASSWORD. Você não precisa definir variáveis de ambiente ao baixar de um repositório público.```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)
O Trivy usa o AWS SDK. Você não precisa instalar a ferramenta CLI `aws`.
Você pode usar as [variáveis de ambiente da 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'

GCR (Google Container Registry)

Trivy usa o Google Cloud SDK. Você não precisa instalar o comando gcloud.

Se quiser usar o repositório do projeto de destino, você pode defini-lo 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-hospedado
O servidor BasicAuth precisa de `TRIVY_USERNAME` e `TRIVY_PASSWORD`.
se você quiser usar a porta 80, use 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'

Usando o Trivy se você não tiver a verificação de código ativada

Também é possível navegar por um resultado de verificação em um resumo do fluxo de trabalho.

Esta etapa é especialmente útil para repositórios privados sem licença do 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 "
Click to expand
" echo "" echo 'terraform' cat trivy.txt echo '' echo "
" } >> $GITHUB_STEP_SUMMARY fi

## Customizing

Prioridade de configuração:
- [Inputs](#inputs)
- [Variáveis de ambiente](#environment-variables)
- [Arquivo de configuração do Trivy](#trivy-config-file)
- Valores padrão

### inputs

As seguintes entradas podem ser usadas como chaves `step.with`:

| Nome                         | Tipo    | Padrão                            | Descrição                                                                                                                                                      |
|------------------------------|---------|------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `scan-type`                  | String  | `image`                            | Tipo de varredura, ex.: `image` ou `fs`                                                                                                                          |
| `input`                      | String  |                                    | Referência de arquivo Tar, ex.: `alpine-latest.tar`                                                                                                              |
| `image-ref`                  | String  |                                    | Referência de imagem, ex.: `alpine:3.10.2`                                                                                                                      |
| `scan-ref`                   | String  | `/github/workspace/`               | Referência de varredura, ex.: `/github/workspace/` ou `.`                                                                                                       |
| `format`                     | String  | `table`                            | Formato de saída (`table`, `json`, `template`, `sarif`, `cyclonedx`, `spdx`, `spdx-json`, `github`, `cosign-vuln`)                                              |
| `template`                   | String  |                                    | Modelo de saída (`@$HOME/.local/bin/trivy-bin/contrib/gitlab.tpl`, `@$HOME/.local/bin/trivy-bin/contrib/junit.tpl`)                                            |
| `tf-vars`                    | String  |                                    | caminho para o arquivo de variáveis do Terraform                                                                                                                 |
| `output`                     | String  |                                    | Salvar resultados em um arquivo                                                                                                                                 |
| `exit-code`                  | String  | `0`                                | Código de saída quando vulnerabilidades especificadas são encontradas                                                                                            |
| `ignore-unfixed`             | Boolean | false                              | Ignorar vulnerabilidades não corrigidas/sem correção                                                                                                            |
| `vuln-type`                  | String  | `os,library`                       | Tipos de vulnerabilidade (os,library)                                                                                                                            |
| `severity`                   | String  | `UNKNOWN,LOW,MEDIUM,HIGH,CRITICAL` | Gravidades das vulnerabilidades a serem verificadas e exibidas                                                                                                   |
| `skip-dirs`                  | String  |                                    | Lista separada por vírgulas de diretórios onde a travessia é ignorada                                                                                           |
| `skip-files`                 | String  |                                    | Lista separada por vírgulas de arquivos onde a travessia é ignorada                                                                                             |
| `cache-dir`                  | String  | `$GITHUB_WORKSPACE/.cache/trivy`   | Diretório de cache. NOTA: Este valor não pode ser configurado por `trivy.yaml`.                                                                                  |
| `timeout`                    | String  | `5m0s`                             | Duração do tempo limite da varredura                                                                                                                            |
| `ignore-policy`              | String  |                                    | Filtrar vulnerabilidades com a linguagem rego do OPA                                                                                                            |
| `hide-progress`              | String  | `false`                            | Suprimir barra de progresso e saída de log                                                                                                                      |
| `list-all-pkgs`              | String  |                                    | Gerar saída de todos os pacotes independentemente de vulnerabilidade                                                                                             |
| `scanners`                   | String  | `vuln,secret`                      | lista separada por vírgulas dos problemas de segurança a detectar (`vuln`,`secret`,`misconfig`,`license`)                                                       |
| `trivyignores`               | String  |                                    | lista separada por vírgulas de caminhos relativos no repositório para um ou mais arquivos `.trivyignore`, ou um único arquivo `.trivyignore.yaml`.               |
| `trivy-config`               | String  |                                    | Caminho para a configuração trivy.yaml                                                                                                                          |
| `github-pat`                 | String  |                                    | Token de autenticação para habilitar o envio de resultados de varredura SBOM para o GitHub Dependency Graph. Pode ser um GitHub Personal Access Token (PAT) ou GITHUB_TOKEN |
| `limit-severities-for-sarif` | Boolean | false                              | Por padrão, o formato *SARIF* força a saída de todas as vulnerabilidades, independentemente das gravidades configuradas. Para substituir esse comportamento, defina este parâmetro como **true** |
| `docker-host`                | String  |                                    | Por padrão, é definido como `unix://var/run/docker.sock`, mas pode ser atualizado para ajudar com valores de infraestrutura conteinerizada (é necessário `unix:/` ou outro prefixo). |
| `version`                    | String  | `v0.72.0`                          | Versão do Trivy a ser usada, ex.: `latest` ou `v0.72.0`                                                                                                         |
| `skip-setup-trivy`           | Boolean | false                              | Pular a chamada da ação `setup-trivy` para instalar o `trivy`                                                                                                    |
| `token-setup-trivy`          | Boolean |                                    | Substituir `github.token` usado por `setup-trivy` para fazer checkout do repositório `trivy`                                                                    |

### Environment variables

Você pode usar [variáveis de ambiente do Trivy][trivy-env] para definir as opções necessárias (incluindo flags que não são suportadas pelos [Inputs](#inputs), como `--secret-config`).

**NB** Em algumas versões mais antigas da Action havia um bug que fazia com que entradas de uma chamada da Action vazassem 
para chamadas subsequentes da Action.  Isso poderia fazer com que workflows que chamam a Action várias vezes, ex.: para executar 
várias varreduras, ou as mesmas varreduras com diferentes formatos de saída, não produzissem a saída desejada.  Você pode ver se esse
é o caso observando as informações da etapa do GitHub Actions; se a seção `env` mostrada na saída das suas Actions 
contiver variáveis de ambiente `TRIVY_*` que você não definiu explicitamente, você pode estar afetado por esse bug e deve 
atualizar para a versão mais recente da Action.

### Trivy config file

Ao usar o [Input](#inputs) `trivy-config`, você pode definir opções usando o [arquivo de configuração do Trivy][trivy-config] (incluindo flags que não são suportadas pelos [Inputs](#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

Mais Populares