Study guide
11.1 Containers: AKS, ACR, ACI, Container Apps & Defender for Containers
Microsoft Certified: Cloud and AI Security Engineer Associate SC-500
Track your progress as you read
Finished sections get a check mark.
1 Introduction & Exam Overview
1.1 Current Exam Facts 1.2 Skills Measured & Weightings 1.3 Study Path, Prerequisites & Exam Strategy
2 Microsoft Entra ID Secure Access
2.1 Privileged Identity Management (PIM) 2.2 Conditional Access Policies 2.3 MFA and Passwordless Authentication 2.4 Application Identities, OAuth Consent & Managed Identities
3 Azure Key Vault Secrets and Keys
3.1 Deploy and Configure Key Vault 3.2 Access Control and Firewall for Key Vault 3.3 Keys, Secrets, Certificates & Defender for Key Vault
4 Governance, Policy & RBAC
4.1 Azure Policy for Security Controls 4.2 Defender for Cloud Compliance & Security Standards 4.3 Resource Locks and Azure RBAC 4.4 Custom Roles, Overprivileged Access, Backup & IaC Security
5 Secure Storage Accounts
5.1 Storage Account Security Fundamentals 5.2 Storage Firewalls and Access Policies 5.3 Defender for Storage
6 Secure Databases
6.1 Azure SQL Platform Security 6.2 Database Auditing 6.3 Defender for Databases
7 Network Security Groups & Virtual Network Manager
7.1 Network Security Groups and Application Security Groups 7.2 Azure Virtual Network Manager Security Admin Rules 7.3 Virtual WAN and VPN Security
8 Private Access, Private Link & Azure Firewall
8.1 Microsoft Entra Private Access 8.2 Private Endpoints and Private Link 8.3 Azure Firewall 8.4 Network Watcher Diagnostics and Effective Rules
9 Security for AI Workloads
9.1 Purview DSPM for AI and Data Overexposure 9.2 Copilot Studio Protection and Agent Management 9.3 Microsoft Entra Agent ID Security 9.4 Defender for AI, Foundry Guardrails & AI Gateway
10 Secure Servers and Virtual Machines
10.1 Disk Encryption 10.2 Azure Bastion and JIT VM Access 10.3 Azure Arc and Defender for Servers 10.4 Trusted Launch, VM Security Features & Machine Configuration
11 Application Platform Security
11.1 Containers: AKS, ACR, ACI, Container Apps & Defender for Containers 11.2 Azure Functions and Logic Apps Security 11.3 Azure App Service Security 11.4 Web Application Firewall and API Management Protection
12 Defender for Cloud Security Posture
12.1 Defender CSPM and Secure Score 12.2 Workload Protection Plans and Multicloud Connectors 12.3 Vulnerability Management and Defender EASM
13 Microsoft Sentinel Activity and Event Collection
13.1 Workspaces, Roles & Content Hub 13.2 Data Connectors, Syslog/CEF & Windows Event Collection 13.3 Custom Tables, Retention & Purview Audit 13.4 Automation Rules and Playbooks
14 Microsoft Security Copilot & Final Review
14.1 Microsoft Security Copilot Workspaces and Roles 14.2 Plugins and Security Agents 14.3 Final Review and Exam-Day Strategy
11.1 Containers: AKS, ACR, ACI, Container Apps & Defender for Containers
Key Takeaways Explain This Topic AI
Defender for Containers is the Defender for Cloud plan that finds container misconfigurations, scans registry images for vulnerabilities, and detects runtime threats on Kubernetes with sensor and agentless signals.
AKS security centers on private clusters, Microsoft Entra authentication with Azure RBAC for Kubernetes authorization, network policies, workload identity, and Azure Policy for Kubernetes admission control.
ACR hardening requires disabling the admin user, preferring managed identity with AcrPull/AcrPush, private endpoints or firewall rules, soft delete, and content trust/Notation signing for supply-chain integrity.
ACI and Azure Container Apps need VNet isolation, managed identity for ACR pulls and outbound Azure access, and least-privilege ingress (internal-only when possible).
SC-500 trap: image CVE scanning alone is not full container security—pair posture, registry controls, runtime detection, and admission policies.
Last updated: July 2026
11.1 Containers: AKS, ACR, ACI, Container Apps & Defender for Containers
Quick Answer: Under Secure compute → Implement security for application platform services , SC-500 expects you to detect misconfigurations and runtime risks with Defender for Containers , then harden AKS , Azure Container Registry (ACR) , Azure Container Instances (ACI) , and Azure Container Apps . Prefer private control planes , Entra + Azure RBAC , managed identity pulls , network isolation , and admission policies —not long-lived registry passwords.
Containers concentrate risk: one vulnerable image can run at scale; a public API server exposes the control plane; a privileged pod can escape toward the node. SC-500 measures both Defender for Containers and the native security knobs on each Azure container tier.
Where containers run on Azure
Platform Role Security emphasis on SC-500
Azure Kubernetes Service (AKS) Managed Kubernetes Control plane (public vs private), Entra auth, Azure RBAC for Kubernetes, network policies, Policy admission, Defender sensor
Azure Container Registry (ACR) Image store / supply chain Admin user off, RBAC + managed identity, private endpoint/firewall, soft delete, signing/trust, Defender image scanning
Azure Container Instances (ACI) Fast single/group containers without full Kubernetes VNet-deployed groups, managed identity, confidential containers where needed
Azure Container Apps Serverless containers / microservices Environment VNet integration, internal ingress, managed identity, secrets/Key Vault patterns
All of them commonly pull images from ACR . Compromising the registry or using weak pull credentials undermines every runtime.
Defender for Containers: misconfigurations and runtime risks
Microsoft Defender for Containers is a Defender for Cloud workload protection plan . Microsoft documents five core domains:
Security posture management — continuous discovery of clusters, workloads, and misconfigurations; recommendations with remediation guidance; Security Explorer hunting.
Vulnerability assessment — agentless scanning of registry images , running containers (where supported), and cluster nodes against Microsoft Defender Vulnerability Management findings.
Run-time threat protection — Kubernetes-aware detections (cluster, node, workload) mapped to MITRE ATT&CK for Containers , with investigation paths into Microsoft Defender XDR .
Software supply chain protection — associate findings with images; support gated deployment so clusters can audit/block noncompliant images.
Deployment and monitoring — detect missing sensors; frictionless scale-out of monitoring components.
Posture vs runtime (exam distinction)
Capability What it answers Typical signals
Posture / misconfiguration “Is the cluster/image configured insecurely?” Public API server without authorized IPs, privileged pods allowed, missing network policies, weak RBAC
Vulnerability assessment “Does this image/node package have known CVEs?” Critical OS or language package CVEs in ACR tags
Runtime threat detection “Is something bad happening now ?” Suspicious process in container, sensitive hostPath mounts, high-privilege role creation, exposed dashboards/services
Agentless capabilities use cloud and Kubernetes APIs without a node agent. Sensor-based capabilities (Defender sensor on AKS) add deeper runtime visibility—for example antimalware signals, DNS anomaly detection, binary drift detection/blocking for unauthorized processes, and richer workload telemetry.
Azure Policy for Kubernetes (Gatekeeper under the hood) is the admission-control companion: enforce “no privileged containers,” allowed registries, required labels, and related data-plane hardening before objects persist. Defender surfaces recommendations; Policy can prevent bad future workloads.
Exam trap: Enabling Defender for Containers does not automatically make AKS private or disable the ACR admin user. Defender detects and recommends ; you still implement native controls.
- AKS security controls
- Network and control plane
Private AKS cluster — Kubernetes API server is not public; access is over private networking (private endpoint patterns). Prefer private clusters for production and regulated workloads.
Authorized IP ranges — if the API remains public, restrict source IPs (weaker than private, better than open).
Network policies — use Azure Network Policy, Calico, or Cilium (depending on cluster networking) so pods are not flat-open within the cluster. Default-deny between namespaces is a common design goal.
Ingress — terminate TLS thoughtfully; place Application Gateway / Front Door WAF in front of internet-facing services (covered in 11.4).
Authentication and authorization
- Pattern What it does SC-500 preference
- Local Kubernetes certs / basic local accounts Cluster-local identities Avoid for enterprise
- Microsoft Entra integration Users/groups authenticate to the API with Entra Required baseline
Entra + Azure RBAC for Kubernetes Authorization Azure RBAC roles (Reader, Writer, Admin, Cluster Admin, etc.) authorize Kubernetes actions Modern default for SC-500
Native Kubernetes RoleBindings only Classic K8s RBAC Still valid, but know Azure RBAC for Kubernetes is the integrated model
Pair cluster-admin access with PIM (from identity chapters)—standing cluster-admin is an overprivilege anti-pattern.
Workload identity and secrets
Prefer Azure Workload Identity (Kubernetes service account federated to a user-assigned managed identity) so pods obtain Entra tokens without secrets in the cluster. Avoid embedding ACR passwords or storage keys in pod env vars. Pull from ACR with managed identity / AcrPull rather than long-lived imagePullSecrets passwords when the platform supports it.
Pod and data-plane hardening
Pod Security Admission / restricted policies — reduce privilege escalation and host access.
Azure Policy for Kubernetes — continuous admission enforcement aligned with CIS/MCSB-style controls.
Confidential containers — for high-sensitivity processing, know AKS can host confidential node pools (memory encryption / attestation themes) as an advanced control, not a substitute for RBAC and network policy.
Scenario: public API server + Defender alert
Contoso enables Defender for Containers and sees recommendations: API server publicly reachable, privileged containers allowed, images with critical CVEs. Correct layered response:
Move to private cluster or at least authorized IP ranges.
Enforce Azure Policy denying privileged pods.
Remediate image CVEs in ACR; block deployment of unapproved tags.
Confirm Defender sensor profile is enabled for runtime coverage.
Switch admin access to Entra + Azure RBAC with least privilege.
ACR security
ACR is the supply-chain chokepoint.
Control Exam-ready guidance
Admin user Disable . Admin is a shared username/password that bypasses Entra and is hard to scope.
Identity Entra RBAC: AcrPull , AcrPush , AcrDelete , etc. Compute uses managed identity .
Repository-scoped tokens Narrow CI/CD scopes when needed—still better than global admin.
Network Private endpoint for VNet-only; or firewall with selected networks; avoid open public pull/push for production.
Soft delete / retention Protect against accidental or malicious image deletion/overwrite recovery scenarios (Premium features where applicable).
Content trust / Notation Sign images; verify signatures at admission time.
CMK encryption Customer-managed keys when compliance requires control of encryption keys.
Defender scanning Continuous CVE findings on images; feed gated deployment.
Exam trap: “Enable ACR admin for simplicity” is almost always the wrong answer. Use managed identity + AcrPull .
- ACI and Azure Container Apps
- Azure Container Instances
Deploy container groups into a delegated subnet for private network placement.
Use managed identity for ACR pulls and outbound access to Key Vault, Storage, and other PaaS.
Prefer no public IP when only internal callers should reach the workload.
Confidential container options exist for memory-isolated workloads on supported hardware.
Azure Container Apps
Use a Container Apps environment with VNet integration (workload profiles environments) for private networking.
Set ingress to internal when only VNet/private callers should hit the app; use external ingress only when intentional.
Apply managed identity for ACR and Azure resources; avoid baking secrets into images.
Use platform secrets or Key Vault references carefully; managed identity to Key Vault remains the cleaner pattern.
Layer IP restrictions / authentication at ingress when external.
Defender for Containers still contributes image vulnerability and posture value even when runtime sensor depth differs from full AKS.
Control mapping cheat sheet
- Requirement Primary control
- Find privileged pod misconfigs Defender posture + Azure Policy for Kubernetes
- Detect suspicious process in pod Defender for Containers runtime (sensor)
- Stop public kubectl from internet Private AKS cluster
- Stop shared registry password Disable ACR admin; managed identity
- Only signed images run Notation/content trust + admission policy
- Isolate serverless containers Container Apps internal ingress + VNet
- ACI talks privately to VNet resources ACI in subnet + managed identity
- SC-500 traps
Defender for Containers = only ACR scanning — Also posture and runtime.
Kubernetes NetworkPolicy replaces NSG/Firewall — Different layers; cluster microsegmentation does not replace hub perimeter controls.
Public AKS + strong passwords is “secure enough” — Control plane exposure is still critical risk.
imagePullSecrets with admin credentials “for automation” — Prefer managed identity.
Confusing Container Apps with AKS — Different control surfaces; do not invent kubectl-only answers for Container Apps.
Engineer checklist
Enable Defender for Containers on the subscription; remediate high-severity recommendations.
Prefer private AKS ; enforce Entra + Azure RBAC for Kubernetes .
Deploy network policies and Azure Policy for Kubernetes admission rules.
Harden ACR : admin off, private network, soft delete/signing as required, RBAC least privilege.
Standardize workload identity and managed identity pulls.
For ACI/Container Apps: VNet + internal ingress + managed identity .
Route internet-facing HTTP through WAF (section 11.4) and monitor runtime alerts in Defender XDR .
Bottom line: SC-500 container security is a chain —secure the image , lock the registry , privatize and authorize the control plane , constrain the pod network , and let Defender for Containers catch what configuration misses at runtime.