Microsoft Defender for Containers, UAE

Alerts only fire for what happens after you enable it. Everything already running is invisible.

Microsoft states that security alerts are only triggered for actions and deployments that occur after you enable Defender for Containers on your subscription. Enabling it does not audit your existing cluster. It starts watching from that moment, which is a good reason to enable it today.

Microsoft Defender for Containers for UAE organisations
  • 60+Kubernetes-aware analytics and anomaly detections
  • 5 domainsPosture, vulnerability, runtime, supply chain, deployment
  • AgentlessDiscovery and vulnerability assessment
  • DailyVulnerability re-scans, with zero configuration
What Defender for Containers covers

Eight capabilities, and the split between agentless and sensor matters.

Some of this works the moment you enable the plan with no footprint in your clusters. Some of it requires the Defender sensor to be deployed. Knowing which is which determines what you actually have after enablement.

Agentless discovery with zero footprint

API-based discovery of your Kubernetes clusters, configurations and deployments with nothing installed in the cluster. For organisations where adding a component to a production cluster requires a change process, this is the part that delivers value before that conversation happens.

Vulnerability assessment across registries and running containers

Agentless assessment of container registry images, running containers and supported Kubernetes nodes, with daily re-scans, zero configuration, coverage for operating system and language packages, and exploitability insights. Registries covered include Azure Container Registry, AWS ECR, Google Artifact Registry and Google Container Registry.

Findings signed for integrity

The vulnerability findings artifact is signed with a Microsoft certificate for integrity and authenticity, and associated with the container image in the registry for validation needs. That signature matters when the findings become an input to a deployment gate rather than a report somebody reads.

Gated deployment against your own policy

Gated deployment rules can audit or block deployments when images do not meet your organisation vulnerability policy. This is the step that turns scanning from information into control, and it is the one most organisations postpone because it can stop a release.

Runtime detection at cluster, node and workload level

Over 60 Kubernetes-aware analytics, AI and anomaly detections based on your runtime workload, using both sensor-based coverage requiring the Defender sensor and agentless coverage based on analysis of Kubernetes audit logs. Alerts map to the MITRE ATT&CK matrix for Containers.

Binary drift detection, and blocking

Sensor-based capabilities that alert on unauthorised external processes within containers and, separately, block them. Drift policies let you define the conditions, which is what distinguishes a legitimate operational action from a process that has no business running in a container.

Data plane hardening through admission control

With Azure Policy for Kubernetes installed, every request to the Kubernetes API server is monitored against a predefined set of best practices before being persisted to the cluster. Microsoft own example is mandating that privileged containers are not created, with future requests blocked.

Knowing which clusters are actually protected

Deployment and monitoring covers clusters missing sensors or not fully protected. In estates where teams create clusters independently, that view is what stops container security being a thing you did once for the clusters you knew about at the time.

The sentence that decides when to enable

Security alerts only fire for actions and deployments that occur after you enable it.

Microsoft states this directly, and it has a clear practical implication: enabling the plan is not a way to find out what has already happened.

  • Runtime threat detection starts from enablement. A cluster that has been compromised beforehand does not produce retrospective alerts, and nothing about the portal makes the absence of history obvious. That is an argument for enabling early rather than at the point somebody suspects a problem.
  • Posture and vulnerability capabilities behave differently. Agentless discovery and vulnerability assessment look at what exists now, so images and configurations in place before enablement are assessed. It is specifically the runtime alerting that is forward looking.
  • The split matters when planning a response to an incident. If a container security question arises and the plan was enabled last week, the vulnerability and configuration picture is complete while the runtime alert history covers only that week.
  • The related planning point is the sensor. Some capabilities are agentless and work immediately, while antimalware, DNS detection and binary drift detection and blocking are sensor-based. A cluster without the Defender sensor has posture coverage and not runtime coverage, which is easy to misread as full protection.
Ask us to check sensor coverage
How we approach it

Four things that make container security land in a real organisation.

Container security is unusual in that the security team rarely owns the clusters. Almost every practical difficulty comes from that, and the sequencing is what resolves it.

We start with what needs no permission

Agentless discovery is API based with zero footprint, and agentless vulnerability assessment needs no configuration. That means an inventory, configuration findings and vulnerability data before any conversation about installing something in a production cluster, which changes the tone of that conversation.

We are explicit about what the sensor adds

Antimalware, DNS detection and binary drift detection and blocking are sensor-based. A cluster with posture coverage and no sensor is partly protected in a way that summary views do not make obvious, and calling that out prevents a false sense of completeness.

We introduce gating in audit mode first

Gated deployment rules can audit or block deployments when images do not meet your vulnerability policy. Blocking first is how a security control becomes the thing engineering teams route around. Auditing first produces the data that makes the policy negotiable and then agreed.

We enable early because alerting is not retrospective

Security alerts only trigger for actions and deployments occurring after enablement. There is no version of this where you turn it on during an incident and learn what happened last month. Enabling it before you need it is the entire value of enabling it early.

How a deployment runs

Four phases across roughly six to eight weeks.

The agentless half can be live in days. The sensor deployment and the gated deployment decision are what take the time, because both touch clusters that development teams own.
  1. 01
    Week 1

    Enable and see what agentless discovery finds

    The plan enabled and agentless discovery running, which needs nothing installed. This alone produces a cluster inventory, configuration findings and vulnerability assessment across registry images and running containers, frequently including clusters the security team did not know existed.

    • Plan enabled at subscription scope
    • Cluster inventory from agentless discovery
    • Registry and running container vulnerability findings
    • Control plane hardening recommendations reviewed
  2. 02
    Weeks 2 to 4

    Deploy the sensor where runtime protection matters

    Sensor deployment negotiated with the teams who own the clusters, prioritised by what the workload does rather than by cluster count. Antimalware, DNS detection and binary drift capabilities all depend on it, so this is where runtime coverage actually comes from.

    • Sensor deployed to prioritised clusters
    • Clusters missing sensors identified and tracked
    • Runtime alerts flowing and routed
    • Defender XDR investigation path confirmed
  3. 03
    Weeks 5 to 6

    Harden the data plane through admission control

    Azure Policy for Kubernetes installed so every request to the API server is checked against best practices before being persisted. Started in audit so teams see what would be rejected, then enforcement on the rules everybody agrees with, such as privileged containers.

    • Azure Policy for Kubernetes installed
    • Policies run in audit and reviewed with owners
    • Enforcement enabled on agreed rules
    • Exception process defined for legitimate cases
  4. 04
    Weeks 7 to 8

    Gate deployments and set drift policy

    Gated deployment rules configured to audit first and then block where images do not meet the vulnerability policy, and binary drift policies defined so alerting distinguishes legitimate activity from genuine threats rather than generating noise.

    • Vulnerability policy agreed with engineering
    • Gated deployment in audit, then enforcing
    • Binary drift policies defined per workload type
    • Blocking enabled where drift policy is confident
Where this matters

Six situations where container security needs attention.

The common thread is a container estate that grew from a development decision rather than an infrastructure programme, which describes most of them.

A business whose developers built the Kubernetes estate

Clusters created by engineering teams to solve delivery problems, with security involved late or not at all. Agentless discovery produces the inventory that conversation needs, and it frequently finds clusters nobody outside one team knew about.

A regulated firm asked about container vulnerability management

The question is usually whether images are scanned and whether vulnerable ones can be deployed. Daily re-scans with exploitability insights answer the first, and gated deployment rules that block images failing your vulnerability policy answer the second concretely.

An organisation running privileged containers by default

Extremely common and rarely deliberate. Azure Policy for Kubernetes checks every request to the API server against best practices before it is persisted, and Microsoft own example is mandating that privileged containers are not created, with future requests blocked.

An operator with clusters across cloud and on-premises

Defender for Containers protects containerised assets across multicloud and on-premises environments, and vulnerability assessment covers registries across Azure, AWS and Google. For estates that ended up multicloud by acquisition rather than design, one consistent view is the main benefit.

A company that had a cryptomining incident

Binary drift detection alerts on unauthorised external processes within containers and drift blocking prevents them, both sensor-based. That is the direct control for the classic container compromise, where a legitimate workload starts running a process nobody deployed.

A business whose exposure came from a service definition

Documented detections include exposed Kubernetes dashboards and exposed services where a LoadBalancer type is created or updated and publicly exposes workloads. Those are configuration mistakes that produce internet exposure, and they are the detections most likely to matter first.

Three positions

How UAE organisations secure containers.

The middle column is the most common, and it is a reasonable interim state: posture visibility without touching production clusters. The gap is that runtime protection is the half that needs the sensor.
Cluster inventory
Agentless plus sensor plus gatingComplete
Agentless onlyComplete
Registry scanning in the pipelineNone
Image vulnerability findings
Agentless plus sensor plus gatingYes, daily
Agentless onlyYes, daily
Registry scanning in the pipelineAt build time only
Running container assessment
Agentless plus sensor plus gatingYes
Agentless onlyYes
Registry scanning in the pipelineNo
Runtime threat detection
Agentless plus sensor plus gatingFull
Agentless onlyAudit log based only
Registry scanning in the pipelineNone
Antimalware inside containers
Agentless plus sensor plus gatingYes
Agentless onlyNo
Registry scanning in the pipelineNo
Binary drift blocked
Agentless plus sensor plus gatingYes
Agentless onlyNo
Registry scanning in the pipelineNo
Admission control hardening
Agentless plus sensor plus gatingYes
Agentless onlyNo
Registry scanning in the pipelineNo
Vulnerable images blocked at deploy
Agentless plus sensor plus gatingYes
Agentless onlyNo
Registry scanning in the pipelineSometimes
Cluster changes require engagement
Agentless plus sensor plus gatingYes
Agentless onlyNo
Registry scanning in the pipelineNo
Time to first value
Agentless plus sensor plus gatingDays for posture
Agentless onlyDays
Registry scanning in the pipelineAlready in place
Agentless against sensor based

What you get without touching the cluster, and what needs the sensor.

This split is the most useful thing to understand before enablement, because it determines what a change-averse organisation can adopt immediately.
CapabilityRequires the Defender sensor
Kubernetes cluster and configuration discoveryNo, API based with zero footprint
Registry image vulnerability assessmentNo, agentless
Running container vulnerability assessmentNo, agentless
Kubernetes node vulnerability assessmentNo, agentless for supported nodes
Control plane hardening recommendationsNo
Detection from Kubernetes audit logsNo, agentless coverage
Antimalware within containersYes
DNS detection from container workloadsYes
Binary drift detection and blockingYes
Data plane hardening by admission controlNeeds Azure Policy for Kubernetes
How an engagement runs

Five steps, sequenced around who owns the clusters.

The technical order and the organisational order are the same here: take what needs no permission first, and use its findings to justify what does.
  1. 1

    Enable and run agentless discovery

    Zero footprint API-based discovery of clusters, configurations and deployments, plus agentless vulnerability assessment of registry images, running containers and supported nodes with daily re-scans. All of this without installing anything, which means it can happen this week.

  2. 2

    Review posture findings with the cluster owners

    Control plane hardening recommendations and vulnerability findings taken to the teams who own the clusters, with exploitability insights used to prioritise. This is the conversation that establishes whether sensor deployment will be straightforward or contested.

  3. 3

    Deploy the sensor where runtime coverage matters

    Prioritised by what the workload does rather than uniformly, since antimalware, DNS detection and binary drift capabilities all depend on the sensor. Clusters missing sensors tracked explicitly so partial coverage is visible rather than assumed away.

  4. 4

    Add admission control, in audit before enforcement

    Azure Policy for Kubernetes installed so every API server request is checked against best practices before being persisted. Run in audit so teams see what would be rejected, then enforcement on rules with genuine agreement, starting with privileged containers.

  5. 5

    Gate deployments and tune drift policy

    Gated deployment rules auditing first and then blocking images that fail the vulnerability policy, and binary drift policies defined so alerts distinguish legitimate operational activity from genuine threats. Both need engineering agreement to survive contact with a release deadline.

Straight answers

What organisations ask about Defender for Containers.

Coverage check

Fifteen questions about your own container estate.

The first group is usually answerable only after agentless discovery has run, which is itself a reason to enable it early.

Estate

  • How many Kubernetes clusters do we run?
    Including ones teams created.
  • Which are missing the Defender sensor?
    Deployment monitoring shows this.
  • Which registries do we pull from?
    ACR, ECR, GAR, GCR and external.
  • Do we run clusters outside Azure?
    Multicloud and on-premises are in scope.
  • When was the plan enabled?
    Alerts start from then.

Vulnerability

  • Are registry images being scanned?
    Daily re-scans, zero configuration.
  • Are running containers scanned too?
    Separate from registry scanning.
  • Do we have a vulnerability policy?
    Gating needs one.
  • Do we act on exploitability insights?
    They prioritise the list.
  • Are node vulnerabilities in scope?
    Supported nodes are covered.

Control

  • Is Azure Policy for Kubernetes installed?
    Needed for data plane hardening.
  • Do we block privileged containers?
    The documented example.
  • Is gated deployment auditing or blocking?
    Start with audit.
  • Have we defined drift policies?
    They shape alert quality.
  • Who investigates container alerts?
    Defender XDR is the surface.
Next step

Enable the plan and let agentless discovery run for a week.

Tell us about cloud platforms, clusters, registries, deployment pipelines and existing security operations. We will confirm the requirements and proposed scope with you.