Cloud Agent, now in a Container: Host Security for Nodes You Can’t Touch
Table of Contents
A single container image that brings Vulnerability Management and Policy Audit to every Kubernetes node, on immutable and mutable Linux alike, deployed the way your container workloads already are.
Key Takeaways
- The Qualys Cloud Agent is now available as a container image on Docker Hub, bringing host-based Vulnerability Management and Policy Audit to every Kubernetes node without touching the host’s package manager.
- It runs as a Kubernetes DaemonSet, so every node that joins the cluster automatically gets an agent. It can be deployed and upgraded through YAML manifests or a unified Helm chart that also deploys Qualys Container Security sensors, for full-stack coverage in a single install.
- A single image covers container-optimized operating systems such as AWS Bottlerocket, Google Container-Optimized OS, and Red Hat CoreOS, as well as RPM- and Debian-based Linux, including Azure Linux, on both Intel/x64 and ARM.
- Policy Audit includes CIS-certified policies for AWS Bottlerocket and Google Container-Optimized OS, and all findings are prioritized with Qualys TruRisk alongside the rest of your estate.
- Paired with Qualys TotalCloud Kubernetes and Container Security (KCS), it delivers full-stack coverage across the host OS, running containers, and the Kubernetes control plane.
The AI Era Is a Container Era
The AI era isn’t arriving on bare metal. It’s arriving on Kubernetes. Model training pipelines, inference services, vector databases, and the agentic workloads that orchestrate them are being built as containers and scheduled across clusters that scale up and down by the minute. The unit of compute is no longer the server. It’s the container, and the node it happens to be running on right now.
That shift changes the math for security teams. The attack surface is no longer a fleet of servers you can enumerate and patch on a monthly cycle. It’s a fleet of nodes that may exist for hours, boot into operating systems that don’t allow you to install a package, and host workloads that move between them without warning. Every one of those nodes is a host, and every host operating system carries its own vulnerabilities and its own configuration risk, regardless of what’s running in the containers above it.
Qualys TotalCloud Kubernetes and Container Security (KCS) extends build-to-runtime coverage for images, containers, and serverless workloads.
The Problem: Host Security Wasn’t Built for Container Platforms
For years, securing a host meant one thing: install an RPM or a DEB on it. That model worked when hosts were long-lived and homogeneous. It breaks down in container platforms in two ways.
- Container-optimized operating systems don’t accept packages. AWS Bottlerocket, Google Container-Optimized OS (COS), Red Hat CoreOS, and their peers deliberately lock down the root filesystem and remove the package manager. There’s nothing to yum install. Security tooling has to run the way everything else on these nodes runs: as a container.
- Package-based deployment doesn’t fit orchestrated environments. Kubernetes teams manage everything through manifests, Helm charts, and GitOps pipelines. A security agent that has to be installed out of band, node by node, is the one thing on the cluster that isn’t declared, versioned, and reconciled like everything else. It also can’t keep up: a node pool that scales from ten nodes to two hundred during a training run needs security coverage on every node it creates, automatically.
The result is a coverage gap at the foundation. Teams invest in scanning container images and monitoring running containers, and rightly so. But the container runtime, the kubelet, the kernel, and every system library sit on the host OS. If that layer is unmonitored, a clean image running on a vulnerable node is still a vulnerable workload.
The Solution: Qualys Cloud Agent as a Container Image
The Qualys Cloud Agent is now available as a container image, published directly to Docker Hub under the verified Qualys publisher account. It runs on every node in your cluster as a DaemonSet and delivers the same host-based Vulnerability Management and Policy Audit that the Qualys Cloud Agent provides on any other platform, without touching the host’s package manager.
The image ships with the Qualys Cloud Agent pre-installed and dynamically pulls down the components it needs at runtime, such as application manifests and supporting utilities, so it stays lightweight while remaining fully functional. Because it’s deployed through Kubernetes, the orchestrator does the work your provisioning scripts used to do: every node that joins the cluster gets an agent, and every node that leaves takes its agent with it.
- Intel/x64 image: qualys/cloud-agent-container-x64
- ARM image: qualys/cloud-agent-container-arm
Once you’ve pulled the image, you can download the deployment YAMLs, and a Qualys Helm chart is published on Artifact Hub so the agent can be installed, versioned, and upgraded through the same Helm workflow as the rest of your cluster.
Why It Matters: The Benefits
Combined with TotalCloud KCS, the Containerized Cloud Agent gives you full-stack coverage across the host OS, running containers, and the Kubernetes control plane, for vulnerabilities, audit, and posture, as well as runtime security, drift, and threat detection.
Full Host Coverage for Container-Optimized and Immutable Operating Systems
Immutable operating systems are the right choice for container platforms: a smaller attack surface, atomic updates, and a root filesystem that can’t drift. But immutability cuts both ways. If you can’t install anything, you can’t install a traditional agent, and many teams have run these nodes blind. The Containerized Cloud Agent closes that gap. It runs as a privileged container with the host mounts it needs to assess the underlying OS, so Bottlerocket, COS, and CoreOS nodes get the same vulnerability and compliance visibility as a conventional Red Hat Enterprise Linux (RHEL) server, with no changes to the host image and no compromise to the immutability that made you choose that OS in the first place.
Qualys has been building this coverage across the major cloud platforms for years:
- Securing Red Hat CoreOS on OpenShift
- Scanning AWS Bottlerocket in Amazon EKS and Amazon ECS
- Scanning Container-Optimized OS in Google Kubernetes Engine
- Qualys for Microsoft Azure Linux in AKS and Azure Container Instances
Your Choice of Agent on Mutable Linux, Too
The Containerized Cloud Agent isn’t limited to immutable operating systems. It also runs on the RPM- and Debian-based distributions that make up the bulk of self-managed and cloud Kubernetes nodes today. That’s a meaningful change. Previously, a RHEL or Ubuntu node meant installing the RPM or DEB package, full stop. Now you choose. Teams with a mix of virtual machines (VMs) and containers can keep the package on VMs and use the Containerized Cloud Agent on cluster nodes. Teams that are all-in on Kubernetes can standardize on the Containerized Cloud Agent everywhere and never manage a host package again. Either way, the data lands in the same place, with the same detections and the same TruRisk scoring.
Deployment That Fits How You Already Run Kubernetes
The Containerized Cloud Agent is a DaemonSet, which means the orchestrator guarantees one agent per node, on every node, for the life of the cluster. Autoscaling node pools, spot instances that get reclaimed, and cluster upgrades that replace every node are all handled without a ticket, a script, or a human. Coverage becomes a property of the cluster rather than a task someone has to remember.
Because it’s delivered as a Helm chart and YAML manifests, the agent lives in the same GitOps repository as your workloads. Upgrading is a tag change and a pull request. Rolling back is a revert. Node selectors and tolerations let you target specific pools, and the same manifest works across dev, staging, and production. Security stops being the exception to your deployment model.
One Image Across Every Operating System
You don’t need a Bottlerocket build, a CoreOS build, and an Ubuntu build. A single Containerized Cloud Agent image runs across all supported operating systems. That collapses your deployment matrix: one image to vet through your supply-chain controls, one image to pin and version, one DaemonSet manifest to maintain. When a new agent release ships, it’s one tag to update across the entire estate. Images that comply with Federal Information Processing Standards (FIPS) are available for environments that require them.
Complete Coverage Across Intel and ARM
Cluster node pools increasingly mix x86 and ARM instances, with Graviton, Cobalt, and Axion sitting alongside traditional Intel and AMD nodes. Images are published for both Intel/x64 and ARM, so a multi-architecture cluster gets consistent coverage without special-casing by pool.
Full-Stack Coverage at a Glance
The Containerized Cloud Agent runs the complete Qualys Cloud Agent on every node, assessing the host OS against the Qualys KnowledgeBase for vulnerabilities and against Center for Internet Security (CIS) Benchmarks through Qualys Policy Audit. Here’s how coverage splits across the stack:
| Capability | Covered by |
| Vulnerability Management | Host: Containerized Cloud Agent. Containers: TotalCloud KCS |
| Drift detection | TotalCloud KCS |
| Compliance (CIS Benchmarks) | Data plane: Qualys Policy Audit. Control plane: TotalCloud KCS (Kubernetes Security Posture Management, or KSPM) |
| Threat detection and response/runtime security | TotalCloud KCS, via eBPF runtime sensors |
Findings from both Vulnerability Management and Policy Audit flow into the same Enterprise TruRisk Platform views, dashboards, and workflows your teams already use. A Kubernetes node is just another asset with a Qualys TruRisk score, sitting next to the VM, the laptop, and the cloud account, and prioritized the same way.
Getting Started
- Pull the image from Docker Hub: Intel/x64 or ARM.
- Download the deployment YAMLs or use the Qualys Helm chart.
- Deploy as a DaemonSet to your cluster with your Agent Activation Key, following the Intel or ARM getting started guide.
Platform-specific guides are available for AWS Bottlerocket, Google COS, and Red Hat CoreOS.
Coming in Cloud Agent 2.9.0
Today, images are available on Docker Hub. With Cloud Agent release 2.9.0, you’ll be able to download the Containerized Cloud Agent package directly from the Qualys platform alongside every other Cloud Agent installer. The Common Container tiles will appear in the Download and Install Cloud Agent workflow, with your activation key, supported OS list, and installation steps right there.
The Host Is Half the Story: Securing the Whole Container Stack with TotalCloud
The Containerized Cloud Agent secures the layer beneath your workloads. It doesn’t look inside the containers running on top of it, and it isn’t meant to. That job belongs to Qualys TotalCloud, and the two are designed as complementary halves of a single answer to the question every platform team eventually has to answer: how exposed are our container workloads, end to end?
Container risk doesn’t live in one layer. It spans the cloud account the cluster runs in, the node operating systems, the Kubernetes control plane and its configuration, the images in your registries, the containers running in production, and the identities and network paths that connect all of it. Securing any one of those layers in isolation leaves you with a partial view and a false sense of coverage. TotalCloud is built to cover all of them on one platform, with one risk score.
Container Security: From Registry to Runtime
TotalCloud’s Container Security sensor picks up where the host agent leaves off. Deployed as a lightweight container alongside your workloads, it discovers and inventories every image, container, and cluster across your environment and assesses them at every stage of the lifecycle:
- Build and registry: images are scanned for OS and application-layer vulnerabilities and embedded secrets as they land in registries or move through continuous integration and continuous delivery (CI/CD) pipelines, so a critical Common Vulnerabilities and Exposures (CVE) entry in a base layer is caught before it’s ever deployed, and admission policies can block it from being scheduled at all.
- Running containers: containers in production are continuously assessed against the same KnowledgeBase, with drift detection that flags containers that no longer match the image they were launched from.
- Kubernetes posture: clusters, namespaces, workloads, and role-based access control (RBAC) are assessed against CIS Kubernetes Benchmarks and best practices to surface over-privileged pods, exposed dashboards, missing network policies, and other control-plane misconfigurations.
- Runtime defense: behavioral monitoring of running containers detects and blocks malicious activity such as unexpected process execution, file tampering, and anomalous network connections, so an exploit that slips past the earlier stages is caught in the act.
TotalCloud KCS also holds the Red Hat Vulnerability Scanner Certification, which extends its detection accuracy to Red Hat OpenShift, RHEL, and CoreOS.
Want to see how TotalCloud secures containers from registry to runtime?
Cloud Posture, Identity, and Infrastructure-as-Code
Clusters don’t run in vacuums. TotalCloud’s cloud security posture management (CSPM) continuously assesses the AWS, Azure, and Google Cloud accounts your clusters live in, covering misconfigured storage, over-permissive identity and access management (IAM) roles, exposed services, and hundreds of other controls mapped to CIS and regulatory frameworks. Infrastructure-as-code scanning applies the same checks to Terraform, CloudFormation, and Kubernetes manifests in your repositories, so misconfigurations are fixed in the pull request rather than in production. Together, they close the loop around the cluster itself.
One Risk Picture, Scored with TruRisk
What makes this a platform rather than a collection of tools is that every finding, from the host agent, the container sensor, and the cloud posture assessment, is normalized, correlated, and scored with TruRisk in one place. That changes what you can see. A vulnerable kernel on a Bottlerocket node, a critical CVE in a base image, an over-privileged pod running on that node, and a public ingress in front of it are no longer four alerts in four consoles. They’re one attack path, with one risk score, and one clear answer to what to fix first. The same correlation lets you dismiss noise with confidence: a critical CVE in an image that never runs, on a node with no external exposure, is scored accordingly.
And because it’s all on the Enterprise TruRisk Platform, container risk sits alongside the rest of your attack surface. The Kubernetes node, the VM it replaced, the developer laptop that pushed the image, and the cloud account that owns all of them are managed, prioritized, and reported on the same way, by the same teams, with the same workflows.
Close the Gap from Host to Cloud
A clean image running on a vulnerable node is still a vulnerable workload. Pull the Containerized Cloud Agent from Docker Hub today and bring your Kubernetes nodes into the same Vulnerability Management and Policy Audit coverage as the rest of your estate. Then talk to your Qualys representative about TotalCloud to extend that coverage from the host to every image, container, cluster, and cloud account your workloads depend on.
Bring your Kubernetes nodes into the same Vulnerability Management and Policy Audit coverage as the rest of your estate.