doc/user/clusters/agent/vulnerabilities.md
{{< details >}}
{{< /details >}}
{{< history >}}
{{< /history >}}
In GitLab agent for Kubernetes 16.10.0 and later and GitLab agent Helm Chart 1.25.0 and later, operational container scanning (OCS) is supported for linux/arm64 and linux/amd64. For earlier versions, only linux/amd64 is supported.
You can use OCS to scan container images in your cluster for security vulnerabilities. In GitLab agent for Kubernetes 16.9 and later, OCS uses a wrapper image around Trivy to scan images for vulnerabilities. Before GitLab 16.9, OCS directly used the Trivy image.
OCS can be configured to run on a cadence by using agent config or a project's scan execution policy.
[!note] If both
agent configandscan execution policiesare configured, the configuration fromscan execution policytakes precedence.
To enable scanning of images within your Kubernetes cluster via the agent configuration, add a container_scanning configuration block to your agent
configuration with a cadence field containing a CRON expression for when the scans are run.
container_scanning:
cadence: '0 0 * * *' # Daily at 00:00 (Kubernetes cluster time)
The cadence field is required. GitLab supports the following types of CRON syntax for the cadence field:
0 18 * * *0 13 * * 0[!note] Other elements of the CRON syntax may work in the cadence field if supported by the cron used in your implementation. However, GitLab does not officially test or support them.
The CRON expression is evaluated in UTC using the system-time of the Kubernetes-agent pod.
By default, operational container scanning does not scan any workloads for vulnerabilities.
You can set the vulnerability_report block with the namespaces
field which can be used to select which namespaces are scanned. For example,
if you would like to scan only the default, kube-system namespaces, you can use this configuration:
container_scanning:
cadence: '0 0 * * *'
vulnerability_report:
namespaces:
- default
- kube-system
For every target namespace, all images in the following workload resources are scanned by default:
This can be customized by configuring the Trivy Kubernetes Resource Detection.
To enable scanning of images in your Kubernetes cluster by using scan execution policies, use the scan execution policy editor to create a new schedule rule.
[!note] The Kubernetes agent must be running in your cluster to scan running container images
Operational container scanning operates independently of GitLab pipelines. It is fully automated and managed by the Kubernetes Agent, which initiates new scans at the scheduled time configured in the Scan Execution Policy. The agent creates a dedicated Job within your cluster to perform the scan and report findings back to GitLab.
Here is an example of a policy which enables operational container scanning within the cluster the Kubernetes agent is attached to:
- name: Enforce container scanning in cluster connected through my-gitlab-agent for default and kube-system namespaces
enabled: true
rules:
- type: schedule
cadence: '0 10 * * *'
agents:
<agent-name>:
namespaces:
- 'default'
- 'kube-system'
actions:
- scan: container_scanning
The keys for a schedule rule are:
cadence (required): a CRON expression for when the scans are runagents:<agent-name> (required): The name of the agent to use for scanningagents:<agent-name>:namespaces (required): The Kubernetes namespaces to scan.[!note] Other elements of the CRON syntax may work in the cadence field if supported by the cron used in your implementation. However, GitLab does not officially test or support them.
The CRON expression is evaluated in UTC using the system-time of the Kubernetes-agent pod.
You can view the complete schema within the scan execution policy documentation.
To ensure accurate vulnerability tracking with OCS, you should create a separate GitLab project with OCS enabled for each cluster. If you have multiple clusters, be sure to use one project for each cluster.
OCS resolves vulnerabilities that are no longer found in your cluster after each scan by comparing the current scan vulnerabilities with those previously detected. Any vulnerabilities from earlier scans that are no longer present in the current scan are resolved for the GitLab project.
If multiple clusters are configured in the same project, an OCS scan in one cluster (for example, Project A) would resolve previously detected vulnerabilities from another cluster (for example, Project B), leading to incorrect vulnerability reporting.
By default the scanner pod's default resource requirements are:
requests:
cpu: 100m
memory: 100Mi
ephemeral_storage: 1Gi
limits:
cpu: 500m
memory: 500Mi
ephemeral_storage: 3Gi
You can customize it with a resource_requirements field.
container_scanning:
resource_requirements:
requests:
cpu: '0.2'
memory: 200Mi
ephemeral_storage: 2Gi
limits:
cpu: '0.7'
memory: 700Mi
ephemeral_storage: 4Gi
When using a fractional value for CPU, format the value as a string.
[!note]
- Resource requirements must be set using the agent configuration file, even when operational container scanning is enabled through scan execution policies.
- When using Google Kubernetes Engine (GKE) for Kubernetes orchestration, ephemeral storage limits are automatically set to equal requests.
During a scan, OCS deploys pods using an image from the Trivy K8s Wrapper repository, which transmits the vulnerability report generated by Trivy Kubernetes to OCS.
If your cluster's firewall restricts access to the Trivy K8s Wrapper repository, you can configure OCS to pull the image from a custom repository. Ensure that the custom repository mirrors the Trivy K8s Wrapper repository for compatibility.
container_scanning:
trivy_k8s_wrapper_image:
repository: "your-custom-registry/your-image-path"
{{< history >}}
{{< /history >}}
By default, the Trivy scan times out after five minutes. The agent itself provides an extra 15 minutes to read the chained configmaps and transmit the vulnerabilities.
To customize the Trivy timeout duration:
scanner_timeout field.For example:
container_scanning:
scanner_timeout: "3600s" # 60 minutes
{{< history >}}
{{< /history >}}
By default, the Trivy report is limited to 100 MB, which is sufficient for most scans. However, if you have a lot of workloads, you might need to increase the limit.
To do this:
report_max_size field.For example:
container_scanning:
report_max_size: "300000000" # 300 MB
{{< history >}}
{{< /history >}}
By default, Trivy looks for the following Kubernetes resource types to discover scannable images:
You can limit the Kubernetes resource types that Trivy discovers, for example to only scan "active" images.
To do this:
Specify the resource types with the resource_types field:
container_scanning:
vulnerability_report:
resource_types:
- Deployment
- Pod
- Job
{{< history >}}
{{< /history >}}
By default, the GitLab agent for Kubernetes deletes the Trivy report artifact after a scan has completed.
You can configure the agent to preserve the report artifact, so you can view the report in its raw state.
To do this:
Set delete_report_artifact to false:
container_scanning:
delete_report_artifact: false
{{< history >}}
{{< /history >}}
OCS scans for vulnerabilities for all severity levels by default.
To report only vulnerabilities at or above a specific severity level, set the configuration variable severity_threshold to that value.
After you set a severity threshold, vulnerabilities below the severity you choose are no longer returned in the Vulnerability Report, API payloads, and other reporting mechanisms.
This allows you to focus on vulnerabilities that meet your organization's risk tolerance needs.
Supported threshold values are UNKNOWN, LOW, MEDIUM, HIGH, and CRITICAL.
For example, to report vulnerabilities of high and critical severity:
container_scanning:
severity_threshold: "HIGH"
To view vulnerability information in GitLab:
This information can also be found under operational vulnerabilities.
[!note] You must have the Developer, Maintainer, or Owner role.
{{< history >}}
{{< /history >}}
To scan private images, the scanner relies on the image pull secrets (direct references and from the service account) to pull the image.
In GitLab agent for Kubernetes 16.9 and later, operational container scanning:
fips mode.Error running Trivy scan. Container terminated reason: OOMKilledOCS might fail with an OOM error if there are too many resources to be scanned or if the images being scanned are large.
To resolve this, configure the resource requirement to increase the amount of memory available.
Pod ephemeral local storage usage exceeds the total limit of containersOCS scans could fail for Kubernetes clusters that have low default ephemeral storage. For example, GKE autopilot sets the default ephemeral storage to 1 GB. This is an issue for OCS when scanning namespaces with large images, as there may not be enough space to store all data necessary for OCS.
To resolve this, configure the resource requirement to increase the amount of ephemeral storage available.
Another message indicative of this issue may be: OCS Scanning pod evicted due to low resources. Please configure higher resource limits.
Error running Trivy scan due to context timeoutOCS might fail to complete a scan if it takes Trivy too long to complete the scan. The default scan timeout is 5 minutes, with an extra 15 minutes for the agent to read the results and transmit the vulnerabilities.
To resolve this, configure the scanner timeout to increase the amount of memory available.
trivy report size limit exceededOCS might fail with this error if the generated Trivy report size is larger than the default maximum limit.
To resolve this, configure the max Trivy report size to increase the maximum allowed size of the Trivy report.