Container security and shared responsibility on Azure
A container shares its host machine's kernel. What employees do, what Azure covers, and what to report quickly.
On this page
In 30 seconds
- Where it happens
- Wherever applications run in containers, on internal servers as well as in the public cloud[2].
- What the attacker wants
- To get out of the container to reach the host machine, then the other containers it hosts[4].
- The reflex
- Deploy no image and no service without approval, never put a secret in an image, and report to the security team any unexpected access, unknown container or overly broad permission.
- If it's already done
- Tell the security team without waiting.
What it is
A container is a way of packaging an application and running it. NIST describes it as a form of operating system virtualization combined with software packaging, which makes execution portable, reusable and automatable[1]. Kubernetes is the open source engine that automates the deployment, scaling and management of these containerized applications[2].
When all of this runs on Azure, security is shared. In Microsoft's Azure documentation, the customer keeps responsibility for its data and its identities, whatever the type of deployment[3]. For an employee, this comes down to a few precise actions: deploy nothing without approval, leave no secret in an image, and report quickly anything out of the ordinary.
Straight answers
What is a container, concretely?
It is an image launched on a machine. The image is an immutable, self-contained package that holds everything the application needs: code, runtime, system libraries, configuration and tools. It moves from one machine to another, but it uses the kernel of the system of the machine that hosts it[2]. According to OWASP, Docker is the most widespread container technology[5].
What does Kubernetes add?
A Kubernetes deployment forms a cluster: worker machines, called nodes, run the applications, and a control plane manages those nodes and their pods[2]. It can be installed on physical servers, on premises or in the public cloud[2].
Is a container a sealed compartment?
No. In principle, containerized resources are meant to be isolated from the host[4]. But containers share the kernel of the host machine: if that kernel is vulnerable, the containers are too[5]. OWASP cites the Dirty COW exploit, which gives root access to a vulnerable host even when launched from a well-isolated container[5].
Who is responsible for what on Azure?
According to Microsoft, the customer always keeps its data (classification, protection, encryption, compliance), its endpoints, its accounts and access management. Microsoft takes on the physical security of the data centers, the physical network, the physical servers and the hypervisor[3]. Between the two, the split depends on the model: with IaaS, the customer manages the virtual machines, the operating systems and the applications; with PaaS, it deploys its applications without managing the machines[3].
What can an attacker do with a poorly configured container?
MITRE ATT&CK describes four things. The attacker can escape to the host to reach the other containers[4]. The attacker can deploy their own container, sometimes configured without network rules or user limits in order to bypass defenses[6]. The attacker can run commands in an existing container by abusing an administration service[7]. Finally, the attacker can map the available containers, pods and nodes to choose the next step[8].
Who should you report to, and when?
To the security team, as soon as behavior looks abnormal. The NIST SP 800-61 Rev. 3 guide helps organizations incorporate incident response recommendations into their cybersecurity risk management activities, as described by NIST's CSF 2.0[9].
How it works
OWASP's Kubernetes guide organizes security into three phases: build, deploy and runtime[2]. OWASP recommends storing approved images in a private registry, which reduces the number of candidate images to a fraction of those that are public[2].
The API server is the front end of the Kubernetes control plane; OWASP presents limiting and securing access to API requests as Kubernetes' first line of defense against attackers[2]. Each machine in the cluster also has a kubelet, whose endpoints give extensive control over the node and its containers. By default, they accept unauthenticated access[2]. Another sensitive component, etcd holds the cluster state and its secrets: write access is equivalent to becoming root on the whole cluster[2].
MITRE describes cases of escape to the host. In one case, the attacker creates a container that mounts the host's file system, which lets them drop code there or run utilities such as cron[4]. In another, the attacker abuses a privileged container to run commands or load a malicious kernel module on the host[4]. Once on the host, the attacker can establish lasting persistence, move around the environment or set up a command channel[4].
What you do
- Do not deploy an image or a service without approval. Only images that comply with the organization's policy should be able to run: launching images of unknown origin exposes the organization to vulnerable or even malicious containers[2].
- Put no secret in an image. Build arguments and environment variables remain in the final image, and a file added in one layer remains recoverable even if a later layer deletes it[5]. NIST also lists clear-text secrets embedded in images among the risks[5].
- Do not enable privileged mode. The
--privilegedoption adds all Linux kernel capabilities to the container[5]. Running the container with an unprivileged user is, according to OWASP, the best way to prevent privilege escalation[5]. - Do not share the Docker socket and do not open the Docker daemon on the network. Giving access to the socket amounts to giving unlimited root access to the host[5].
- Follow the principle of least privilege for access. MITRE recommends limiting access to the container dashboard to the people who need it and avoiding generic permissions[6].
- Report to the security team any unexpected access, any container nobody recognizes or any overly broad permission. MITRE describes as detection signals the creation of a container from an image outside the allowed list by a non-administrator account, or launched with risky attributes such as
--privileged[6]. It also cites abnormal use ofdocker execorkubectl exec[7], and unusual queries such asdocker psorkubectl get pods[8].
Pitfalls
Unverified images. OWASP considers it very dangerous to download and run images from unknown sources[2]. For Kubernetes, it recommends an admission controller that rejects images that are unapproved, not recently scanned, or from insecure registries[2].
Exposed administration consoles. The Kubernetes dashboard is a web application that makes it possible to drive the cluster. According to OWASP, many tutorials create a highly privileged service account for it, and Tesla, among others, was hacked through a poorly configured dashboard[2]. OWASP advises against exposing it to the public without additional authentication[2]. A Docker daemon opened on the network with -H tcp://0.0.0.0:XXX gives direct access, unencrypted and without authentication, which anyone on the Internet can use if the machine is connected to it[5].
Containers launched in privileged mode. MITRE cites several tools and groups: Doki configured its container to mount the host's root, and the TeamTNT group deployed privileged containers that mount the victim's file system[4]. TeamTNT also transferred cryptocurrency mining software to Kubernetes clusters discovered in local IP address ranges[6].
Secrets in Kubernetes. OWASP notes that secrets are stored there in clear text by default and suggests encrypting etcd or using third-party tools[5].
The firewall that does not protect everything. When a port is published with -p 8000:8000, Docker inserts its own network rules, which bypass the UFW firewall and can expose the service on the Internet[5].
Leaks through logs. Docker logs can reveal the environment's configuration, the available services and the cloud provider in use, which guides the rest of the attack[8].
Forgotten updates. The host kernel and the Docker engine must be kept up to date to protect against known escape vulnerabilities, such as Leaky Vessels, which generally give the attacker root access to the host[5].
Sources
- NIST, “Application Container Security Guide”, 25 September 2017. https://csrc.nist.gov/pubs/sp/800/190/final (accessed 10 November 2026)
- OWASP, “Kubernetes Security Cheat Sheet”. https://cheatsheetseries.owasp.org/cheatsheets/Kubernetes_Security_Cheat_Sheet.html (accessed 10 November 2026)
- Microsoft, “Shared responsibility in the cloud”. https://learn.microsoft.com/en-us/azure/security/fundamentals/shared-responsibility (accessed 10 November 2026)
- MITRE ATT&CK, “Escape to Host”. https://attack.mitre.org/techniques/T1611/ (accessed 10 November 2026)
- OWASP, “Docker Security Cheat Sheet”. https://cheatsheetseries.owasp.org/cheatsheets/Docker_Security_Cheat_Sheet.html (accessed 10 November 2026)
- MITRE ATT&CK, “Deploy Container”. https://attack.mitre.org/techniques/T1610/ (accessed 10 November 2026)
- MITRE ATT&CK, “Container Administration Command”. https://attack.mitre.org/techniques/T1609/ (accessed 10 November 2026)
- MITRE ATT&CK, “Container and Resource Discovery”. https://attack.mitre.org/techniques/T1613/ (accessed 10 November 2026)
- NIST, “Incident Response Recommendations and Considerations for Cybersecurity Risk Management: A CSF 2.0 Community Profile”, 3 April 2025. https://csrc.nist.gov/pubs/sp/800/61/r3/final (accessed 10 November 2026)
Cite this article
Brain, “Container security and shared responsibility on Azure”, Cyberpedia, 2026. https:/
BibTeX
@misc{brain_cp250_en_2026,
author = {Brain},
title = {Container security and shared responsibility on Azure},
year = {2026},
howpublished = {Cyberpedia},
url = {https://startbrain.io/cyberpedia/en/articles/container-security-docker-kubernetes-cloud/},
note = {CC BY 4.0}
}