Buyer’s Guide

Best Container Security Scanners

Written by Govind Kumar Lohar. Reviewed for technical accuracy by Deepak Gupta and Bhaskar Suthar on · Review panel

  • security
  • containers
  • kubernetes
  • appsec
  • devsecops

Independent buyer’s guide. No vendor paid to be included, ranked or described a particular way. Written for engineers, architects and the people who sign off on their tooling budget. Editorial policy.

Scan a normal application image built on a general-purpose distribution base and you will get a long list of findings. Almost none of them will be in your application. They will be in the operating system packages that came with the base layer: a compression library, an XML parser, a certificate handling utility, a shell you never invoke.

Somebody will then be assigned to fix the list. They will discover that most of the affected packages have no available update because the distribution has not published one yet, that several are marked as not affected by the distribution but flagged as vulnerable by the scanner anyway, and that a good number are in binaries your application will never execute. After a week of this, the team adds a severity threshold, then an exclusion list, then stops looking.

This is the defining failure of container scanning, and it is not a detection problem. The scanners are largely right: those packages really are present and really do have published vulnerabilities. The problem is that presence in a base layer is a terrible proxy for risk in your application, and no amount of tuning fixes a base image that ships three hundred packages when your service needs four.

Which is why the most effective thing in this category is not a scanner at all. It is changing what you put in the image. A minimal or distroless base removes the findings rather than triaging them, and it is the only approach here that gets better over time instead of worse. Pick a scanner second, and pick it mostly on where it enforces rather than on what it detects.

Key takeaways

  • Most container findings are in the base image, not your code. Reducing what the image contains is more effective than any amount of triage, and it is a one-time change rather than a recurring cost.
  • Distribution security trackers matter more than raw detection. A scanner that does not consult them reports backported fixes as unpatched, which is a large fraction of the noise on any distribution base.
  • Scanning finds problems and admission control prevents them. A pipeline that reports and does not block will ship the image anyway, because something is always urgent.
  • Scan the same image at build, in the registry on a schedule, and at admission. They answer different questions, and the registry rescan is the one that catches advisories published after your last deploy.

Why base image findings dominate, and what to do about it

An application image is layers. Your compiled binary or interpreted source and its dependencies are one part. Underneath sits whatever base you chose, and a general-purpose distribution base brings a package manager, a shell, core utilities, an SSL library, compression libraries, locale data and a long tail of things that exist because a general-purpose image has to serve general purposes.

Every one of those packages is a component with a version, and every version eventually accumulates advisories. Your application did not get less safe; the clock moved. That is why an image you have not changed grows new findings every week.

Four things actually reduce this, roughly in order of effect.

One: use a smaller base. The single most effective change available. Options, in increasing order of severity and benefit:

  • A slim variant of your current distribution. Drops documentation, locales and optional packages. A one-line change, meaningful reduction, nothing breaks.
  • An Alpine-style base built on musl and BusyBox. Dramatically fewer packages. The catch is real: musl is not glibc, and software that assumes glibc behaviour, particularly around DNS resolution, threading and locale handling, can behave differently in ways that are subtle rather than loud. Test properly rather than assuming it works because the container started.
  • A distroless base, containing your language runtime and nothing else. No shell, no package manager, no utilities. There is almost nothing left to have a vulnerability, and the findings list collapses accordingly.
  • A static binary in a scratch image, where the language supports it. Nothing but your binary. Zero operating system packages means zero operating system findings.

Two: separate build from runtime. Multi-stage builds exist precisely for this. Compilers, headers, package managers and build tooling belong in a stage that does not ship. An image carrying its own build toolchain is carrying both a large finding surface and a useful set of tools for anybody who gets a foothold in it.

Three: rebuild on a schedule, not on a release cadence. Most base image findings are fixed upstream and arrive only when you rebuild. An image built four months ago accumulates findings for every advisory since. Automated weekly rebuilds of unchanged applications remove more findings than any triage process, and they cost a pipeline run.

Four: pin by digest, not by tag. A tag is a mutable pointer, so base:3.2 can be entirely different bytes tomorrow. Digest pinning gives you reproducible builds and means the image you scanned is the image you shipped. Pair it with update automation so pinned does not become stale, which is the standard failure of pinning without a bot. The wider pinning discipline is covered in supply chain security and SBOM tools.

The honest objection to distroless: debugging. No shell means no exec into the container to look around. That changes incident habits and teams resist it for good reason. The answers are ephemeral debug containers that attach a toolbox to a running pod without the image carrying one, and proper instrumentation so you are reading telemetry rather than poking at a filesystem. Both are better practice anyway, and the security benefit of an image with no shell is precisely that an attacker does not get one either.

Needs first-hand data: Take one production service and build it three ways: your current base, a slim variant, and distroless or static. Scan all three identically and record the finding count and image size for each. The reduction from base image choice alone is usually larger than anything you would achieve by triaging for a quarter, and having your own numbers makes the migration argument for you.

Why two scanners disagree about the same image

Run two scanners over one image and you get two different answers. This is not a bug in either and understanding why saves a great deal of arguing.

Different package identification. Detecting operating system packages from a package database is reliable. Detecting language dependencies inside the filesystem is less so, and detecting a binary that was compiled elsewhere and copied in is largely guesswork. Scanners differ in how far they go and how confidently they name what they find.

Different advisory sources. This is the big one. A distribution maintains its own security tracker recording which of its package versions are affected, which are patched, and which are marked not affected because the vulnerable code path is not compiled in. Distributions also backport fixes without changing the upstream version number, so a package can carry a version string that looks vulnerable and contain the patch. A scanner that consults the distribution tracker gets this right. A scanner that only matches upstream version ranges reports the package as vulnerable, and that single behaviour accounts for a large share of the noise in this category.

Different severity. Upstream scores, distribution scores and vendor scores diverge, sometimes substantially, because a distribution assessing a vulnerability in the context of how it compiles and ships the package will legitimately reach a different conclusion.

Different treatment of what is not installed. A file present on disk is not necessarily an installed package, and a library present is not necessarily loaded. Tools vary in whether they report these.

The practical consequence is that finding counts are not comparable across tools, and that a scanner which consults distribution trackers should be preferred over one that does not, more or less regardless of anything else on its feature list.

Where scanning belongs: build, registry, admission

Three placements, three different questions, and mature setups run all three.

At build, in the pipeline. The question is whether this change introduced something. It is the cheapest moment to fix, because whoever made the change is present. Gate narrowly here: fail on new findings above a threshold that have a fix available, not on the accumulated inventory. A build gate that fires on every unfixable base image finding teaches people to bypass it within a fortnight.

In the registry, on a schedule. The question is whether anything you already shipped became vulnerable since. This is the placement teams skip and it is the one that answers the question actually asked during an incident, which is whether the thing running in production is affected by an advisory published this morning. Nothing about your image changed; the advisory arrived. Continuous rescanning of stored images is the only way to know, and it is a strong reason to care about how your container registry integrates with your scanner.

At admission, in the cluster. The question is whether this image is allowed to run. An admission controller evaluates a policy when a workload is created and rejects it if the image fails. This is the only placement that is actually a control rather than a report, because everything earlier can be bypassed by pushing directly or deploying around the pipeline.

Admission policy is where teams over-reach. Blocking on vulnerability severity across the board means a new critical advisory in a base package takes down every deploy in the organisation until a patched base exists, which may be days. Policies that work in practice check properties that are binary and under your control: the image comes from an approved registry, it is signed by your build identity, it has been scanned within a defined window, it does not run as root, it has no critical findings with an available fix. The signature and provenance side of this is the subject of supply chain security and SBOM tools, and the deployment gate itself usually lives in your GitOps tooling.

Start admission policies in warn mode. Collect what would have been rejected for a few weeks, fix that, then enforce. Turning on enforcement first is how a security team loses the argument permanently.

Needs first-hand data: Run your intended admission policy in warn mode for one month and count how many real deployments it would have blocked, split by reason. If it would have blocked almost everything, the policy is wrong rather than your estate. If it would have blocked nothing, the policy is not checking anything meaningful.

Trivy

Trivy homepage

Trivy is the default open source scanner in this category and the one most commonly embedded inside other products. One binary scans images, filesystems, repositories, Kubernetes clusters and infrastructure code, detects both operating system packages and language dependencies, consults distribution security trackers, and generates or consumes standard SBOM documents. It also has an operator for continuous in-cluster scanning.

Pros

  • Consults distribution security data, which removes the largest single class of false positive on distribution bases
  • Covers images, language dependencies, infrastructure code and clusters in one tool with no meter
  • Fast enough to run on every build without anyone arguing about pipeline time
  • Generates and consumes standard SBOM formats, so it fits either direction of a supply chain workflow

Cons

  • No reachability analysis, so findings are presence-based and prioritisation is entirely your policy
  • No management layer, so triage, suppression and tracking across many images are your build
  • Default output on a general-purpose base is high volume, and a gate without tuning either blocks constantly or gets ignored
  • Offline and air-gapped operation requires deliberate database handling

Best for: Almost any team as the baseline scanner, particularly those who want one free tool across images, dependencies and clusters.

Pricing: Free and open source with no vendor and no bill. The maintaining company sells a separate commercial platform with management and reporting.

Grype

Grype does matching and deliberately not inventory. Point it at an image or hand it an SBOM and it matches components against vulnerability data from multiple sources including distribution trackers. The design point is separating generation from matching, which lets you generate an inventory once at build time and re-match it as advisories land without rebuilding or re-pulling the artefact.

Pros

  • Re-evaluates a stored SBOM against today’s advisories without touching the artefact, which is the right shape for registry rescanning
  • Multiple advisory sources including distribution trackers, reducing backported-fix noise
  • Simple output and exit codes make CI policy gates trivial to express
  • Composes cleanly with a separate generator, keeping inventory and matching auditable as distinct steps

Cons

  • Result quality is capped by the inventory it receives, so a weak SBOM produces a confident incomplete answer
  • No reachability, no fix guidance, no workflow
  • Covers matching only, so it is a component of a scanning setup rather than a complete one
  • Database updates need deliberate handling in offline builds

Best for: Teams building their own pipeline who want matching as a separate scriptable step, especially for scheduled re-evaluation of stored SBOMs.

Pricing: Free and open source with no vendor and no bill. The cost is build time and the triage process you build around it.

Snyk Container

Snyk Container is the container component of a broader commercial platform, and its most distinctive behaviour is base image advice: rather than listing findings, it tells you which alternative base image tag would remove the largest number of them with the smallest change. That directly addresses the real problem in this category, which is that the fix is usually a base image decision rather than a package upgrade.

Pros

  • Base image recommendations turn a long finding list into one actionable change, which is the correct fix
  • Shares a platform with dependency, code and infrastructure scanning, so one policy model covers everything
  • Links findings to the Dockerfile instruction that introduced them, which makes ownership obvious
  • Fix pull requests against the Dockerfile rather than a report handed to somebody else

Cons

  • Per-developer platform pricing scales badly across a large organisation with many images
  • Proprietary database means findings cannot be fully reproduced or audited outside the product
  • Depth varies across ecosystems and the variation is not visible from the interface
  • Broad platform means less depth in runtime and cluster context than the specialists

Best for: Teams already on the platform who want container findings expressed as base image and Dockerfile changes rather than as package lists.

Pricing: Free tier with a monthly test allowance, then per-developer subscription tiers. Alternatives are compared in Snyk alternatives.

Clair

Clair is the long-standing open source scanner designed as a service rather than as a command line tool. It ingests advisory data continuously, indexes image manifests, and exposes an API that a registry queries. That architecture is why it sits behind several registry implementations: it is built to answer questions about a large stored catalogue continuously, rather than to scan one image in a pipeline step.

Pros

  • Service architecture built for continuously re-evaluating a whole registry catalogue as advisories arrive
  • API-first design makes it straightforward to embed in a registry or an internal platform
  • Indexes a manifest once and re-matches it later without re-pulling the image, which scales well
  • Mature, open source, and already integrated into several registry products

Cons

  • Operating it means running a service with a database and an update pipeline, not invoking a binary
  • Focused on operating system packages, with weaker language dependency coverage than newer scanners
  • No user-facing workflow, triage or reporting of its own
  • Higher setup cost than command line scanners for teams who only need pipeline scanning

Best for: Platform teams running their own registry who need continuous catalogue-wide scanning behind an API rather than a per-build tool.

Pricing: Free and open source with no vendor and no bill. The cost is operating the service, its database and its advisory update pipeline.

Docker Scout

Docker Scout is scanning integrated into the container tooling developers already use. It evaluates images locally and in the registry, and its useful angle is comparison: it shows what a change to the Dockerfile or the base image does to the finding count, and it compares your image against alternatives before you build. Because it lives in the same interface as the build commands, it meets developers where they already are.

Pros

  • Present in the developer workflow at the moment the base image is chosen, which is when the decision matters
  • Image comparison shows the effect of a base image change directly rather than requiring two scans and a diff
  • Low friction to start, with nothing new to install for teams already on the tooling
  • Policy evaluation covering supply chain properties as well as vulnerabilities

Cons

  • Tied to one vendor’s ecosystem and registry integration, which is a constraint if you are elsewhere
  • Less depth and less configurability than the dedicated scanners for policy and reporting
  • Advanced features are gated behind paid subscription tiers
  • Not a cluster runtime security tool, so it covers only part of the problem

Best for: Teams already standardised on that tooling who want scanning and base image comparison in the developer loop with essentially no setup.

Pricing: Basic capability included with the tooling subscription, with advanced policy and registry integration in higher paid tiers.

Aqua

Aqua is a full container security platform rather than a scanner: image scanning and assurance policy, registry integration, admission control, and runtime protection enforcing what a container is permitted to do once running. The coherent argument for it is the same policy following an artefact from build through admission to runtime, which is genuinely hard to assemble from separate tools.

Pros

  • One policy model spanning build, registry, admission and runtime, rather than four tools to reconcile
  • Runtime enforcement can block unexpected process execution and network behaviour, not only report it
  • Assurance policies express image requirements beyond vulnerabilities, including provenance and configuration
  • Strong support for regulated environments, including air-gapped deployment

Cons

  • Enterprise platform with enterprise deployment weight, including agents and control plane to operate
  • Runtime enforcement requires careful tuning or it blocks legitimate behaviour in production
  • Overlaps substantially with cloud posture tooling you may already run
  • Enterprise sales motion with no meaningful self-serve evaluation path

Best for: Organisations running containers at scale that need one enforced policy from build to runtime, particularly under regulatory obligations.

Pricing: Annual enterprise subscription, typically scaled by protected workloads or nodes, quoted rather than listed.

Sysdig

Sysdig approaches container security from runtime observation, built on kernel-level instrumentation. Its distinguishing capability is using what actually executes to prioritise findings: if a vulnerable package is never loaded by any running container, it is deprioritised, and if it is in the execution path it moves up. That is runtime reachability for containers, and it is the most direct available answer to base image noise short of removing the packages.

Pros

  • Runtime observation of which packages actually load turns a long list into a short one, based on evidence rather than inference
  • Deep kernel-level visibility supports both threat detection and forensic investigation after an event
  • Connects image findings to the specific running workloads affected, which makes ownership and urgency concrete
  • Strong detection rule ecosystem for runtime behaviour, with an open source engine underneath

Cons

  • Requires an agent on every node, which is an operational and performance consideration you must evaluate
  • Prioritisation is only as good as the observation window, and a feature exercised rarely can look unused
  • Platform breadth means cost and complexity beyond what a team wanting image scanning needs
  • Runtime detection rules generate their own tuning burden, separate from vulnerability triage

Best for: Teams running substantial container estates who want vulnerability prioritisation grounded in what actually executes, plus runtime threat detection.

Pricing: Subscription scaled by hosts or nodes under monitoring, with tiers separating vulnerability management from runtime detection.

Wiz

Wiz homepage

Wiz comes at containers from the cloud side. It builds a graph of your cloud environment and evaluates images in the context of everything around them: whether the workload is internet-reachable, what identity it holds, what data it can access. A vulnerable package in a container that is publicly exposed and holds a permissive role is a completely different risk from the identical package in an isolated batch job, and the graph is what lets the tool say so.

Pros

  • Contextual prioritisation using exposure, identity and data access, which is closer to real risk than any severity score
  • Agentless scanning of workloads means broad coverage without deploying anything to every node
  • Attack path analysis shows the chain from exposure to impact, which is what makes a finding persuasive to non-engineers
  • Covers cloud posture and containers together, so the boundary between them stops being a gap

Cons

  • Enterprise pricing and sales motion, aimed well above the team that wants a scanner in a pipeline
  • Agentless scanning trades some depth and immediacy against not running an agent
  • Broad cloud platform, so container scanning is one capability among many rather than the focus
  • Requires broad read access across your cloud accounts, which is its own review

Best for: Organisations that want container findings prioritised by real cloud exposure and blast radius rather than by severity, alongside broader posture management.

Pricing: Annual enterprise subscription, scaled by cloud workloads under management, quoted rather than listed.

How to choose

One. Fix the base image before you choose a scanner. Building the same service on a minimal or distroless base removes findings permanently and costs a day. Nothing you buy will do more than that, and an evaluation run against a bloated base is measuring your base image rather than the tools.

Two. Require distribution tracker integration. This determines how much of your finding list is real. A scanner that reports backported fixes as unpatched will burn your team’s goodwill in weeks, and no dashboard fixes it.

Three. Decide whether you need enforcement or only reporting. If images ship regardless of findings, you have a reporting tool and should buy the cheapest one that reports well. If you want images actually blocked, you need admission control and you should evaluate that mechanism specifically, including how it behaves when the scanner is unavailable.

Four. Decide whether you need runtime context. With a few services, you know what runs and prioritisation by hand is fine. With hundreds, runtime observation or cloud exposure context is what makes the queue tractable, and it is the main thing the expensive platforms are actually selling.

Five. Check registry integration specifically. Continuous rescanning of stored images is the placement most teams skip and the one that answers the question asked during an incident. Confirm the tool rescans on a schedule rather than only on push.

ToolScopeEnforcementPicks itself when
TrivyImages, dependencies, IaC, clustersPipeline gate, operatorYou want one free baseline scanner
GrypeMatching from image or SBOMPipeline gateYou are assembling your own pipeline
Snyk ContainerImages and DockerfilesPipeline gateFindings should become base image changes
ClairRegistry catalogue scanningAPI, via registryYou operate your own registry
Docker ScoutImages in the developer loopPolicy evaluationYou are already on that tooling
AquaBuild to runtime platformAdmission and runtimeOne enforced policy end to end
SysdigRuntime and imagesAdmission and runtimePrioritisation by what actually executes
WizCloud and workload contextPolicy, mostly reportingPrioritisation by cloud exposure

Needs first-hand data: Scan your top ten production images with two scanners configured identically, then hand-triage the findings where they disagree. The disagreements are almost always distribution backports or package identification, and knowing which of your two candidates is right on your specific bases is worth more than any feature comparison.

Frequently asked questions

Why does our image have findings when our code has none?

Because the findings are in the base layer, not in your code. A general-purpose distribution base ships a large number of operating system packages, all of which accumulate advisories over time regardless of what your application does. The effective response is not triage, it is reducing what the image contains by moving to a slim, distroless or static base and rebuilding on a schedule. That converts a recurring weekly cost into a one-time change.

Should a vulnerability finding block a deploy?

Only on a narrow, defensible rule. Blocking on any critical finding means a new advisory in a base package halts every deploy in the organisation until a patched base exists, which is not always the same day, and the practical result is an emergency bypass that then stays enabled. A workable gate blocks on findings that are critical, have a fix available, and are newly introduced by the change in question. Everything else belongs in a tracked queue with an owner and a date, and in scheduled rebuilds that pick up fixes automatically.

Is distroless worth losing shell access?

For most production services, yes, and the objection is more about habit than capability. The debugging path becomes an ephemeral debug container attached to the running pod, which gives you a full toolbox without the image carrying one permanently, plus proper telemetry so that investigation starts from logs and traces rather than from a shell. The security gain is direct: an attacker who achieves code execution in a distroless container has no shell, no package manager and no utilities to work with.

Do we need both image scanning and runtime security?

They answer different questions and the honest sequencing is that scanning comes first. Scanning tells you what is in the artefact and whether it has known issues, and it is cheap, preventive and something every team should do. Runtime security tells you what a container is actually doing and can stop behaviour that no scan predicts, including exploitation of something with no advisory at all. Runtime is genuinely valuable and it is also an agent on every node and a tuning burden, so it belongs after you have fixed your base images and have scanning working, not before.

How does container scanning relate to dependency scanning?

Same matching mechanism, different inventory. Dependency scanning reads your manifests and lockfiles to find the packages your application declared. Container scanning reads the assembled image to find everything present in it, which includes those application dependencies plus every operating system package in the base plus anything a build step copied in. The image is the more complete picture and the one that reflects what actually ships, which is why both exist. The application side is covered in dependency scanning and SCA tools.