Secure Your Containers: Best Practices for Image Scanning, Patch Management & More

Photo by CHUTTERSNAP on Unsplash

Secure Your Containers: Best Practices for Image Scanning, Patch Management & More


10 min read

As professionals in Security, DevOps, and development fields navigate the complexities of containerized environments, ensuring the security of container images is of utmost importance. To achieve this, the guide provides best practices for selecting the appropriate base images, using multi-stage builds, conducting thorough image scans, and implementing efficient patch management strategies.

Selecting the Right Base Image

Key Practices:

  1. Choose Trusted Sources: Prioritize base images from official repositories and verified publishers. This reduces the risk of vulnerabilities.

  2. Opt for Minimalism: Select the smallest possible base image that meets your requirements. This approach limits the attack surface by minimizing the number of packages and potential vulnerabilities.

Enhanced Guidance:

  • Examples of Trusted Sources: Look for images on Docker Hub with official badges or those provided by reputable cloud providers.

  • Minimal Base Image Examples: Consider using Alpine Linux for its small footprint and security profile.

Leveraging Multi-stage Builds


  • Optimization and Security: Multi-stage builds allow for the creation of lean images by separating build environments from production environments. This reduces the risk of including unnecessary artifacts that could be exploited.

Continuous Image Rebuilding

Best Practices:

  1. Immutable Containers: Ensure containers are disposable and easily replaceable without affecting functionality.

  2. Regular Updates: Rebuild images frequently to incorporate security patches and updates.

  3. No-cache Builds: Use --no-cache during builds to ensure the latest packages are used, avoiding outdated or vulnerable versions.

Practical Advice:

  • Rebuild Frequency: Establish a schedule based on your development cycle and vulnerability alerts.

  • Automate Rebuilds: Utilize CI/CD pipelines to automate the rebuild and deployment process.

Enhancing Dependency Security

Understanding Dependency Risks: Dependencies in containerized applications can introduce vulnerabilities, making it crucial to manage and secure them effectively. Dependency security involves ensuring that all external code your application relies on, from operating system packages to third-party libraries, is up to date and free from vulnerabilities.

Best Practices:

  1. Regularly Update Dependencies: Frequently update dependencies to their latest secure versions to mitigate known vulnerabilities.

  2. Use Dependable Sources: Only include libraries and packages from reputable sources with a good security track record.

  3. Automate Scanning: Implement automated tools to scan for vulnerabilities within dependencies. Tools like Snyk, Dependabot, and others can monitor your dependencies for known vulnerabilities and suggest updates or patches.

  4. Principle of Least Privilege: Minimize dependency usage to what is strictly necessary for the application to function, reducing the attack surface.

Securing the Software Supply Chain

The Challenge: The software supply chain encompasses all the steps involved in delivering software, from development to deployment. It includes code, dependencies, build tools, and infrastructure. Securing the supply chain means protecting each component against tampering and unauthorized access.

Strategies for Improvement:

  1. Secure Development Practices: Incorporate security best practices throughout the development lifecycle, including code reviews, security testing, and adherence to secure coding standards.

  2. Sign and Verify Artifacts: Implement digital signatures for software artifacts to ensure their integrity and authenticity from build to deployment.

  3. Use Trusted Base Images and Builders: Ensure that all base images and build environments are secured and scanned for vulnerabilities. Prefer minimal, official, or verified images to reduce risk.

  4. Implement a Software Bill of Materials (SBOM): Maintain and review an SBOM for your applications, detailing every component, dependency, and tool used in the build process. This transparency aids in vulnerability management and compliance.

  5. Continuous Monitoring: Continuously monitor and scan the supply chain components for vulnerabilities, unauthorized changes, and anomalies. Integrate security tools into the CI/CD pipeline to automate this process.

By addressing dependency security and securing the software supply chain, organizations can significantly mitigate the risk of vulnerabilities and attacks. Implementing these practices requires a combination of the right tools, processes, and a security-minded culture across development and operations teams. Together, these measures form a comprehensive approach to container security, protecting applications from the source to deployment.

Comprehensive Image Scanning


  1. Development and Production Scans: Integrate scanning into your CI/CD pipeline to catch vulnerabilities early and continuously.

  2. Automated Scans: Configure automated scans at key points, such as post-build and pre-deployment to production environments.

Tools and Services:



  • Open-Source: Clair is an open-source project under the CoreOS umbrella, making it accessible for integration with various CI/CD pipelines without licensing costs.

  • Layered Analysis: It performs static analysis of container images and inspects each layer for known vulnerabilities, providing detailed insights into where vulnerabilities are introduced.

  • Database Support: Clair utilizes various vulnerability databases (like the National Vulnerability Database) to compare and detect vulnerabilities, ensuring comprehensive coverage.

Use Cases:

  • Ideal for organizations looking for an open-source solution that can be customized and integrated into existing workflows.

  • Suitable for environments where detailed analysis of image layers and their individual vulnerabilities are required for in-depth security reviews.


  • Strengths:

    • Simplicity and Speed: Trivy is known for its simplicity and quick scanning capabilities, offering high-speed scans without the need for extensive configuration.

    • Comprehensive Detection: It can detect vulnerabilities in OS packages (Alpine, Red Hat, etc.) and application dependencies (Bundler, Composer, npm, yarn, etc.), making it versatile.

    • CI/CD Integration: Trivy easily integrates with CI/CD pipelines, providing a straightforward way to include security scanning in the build process.

Use Cases:

  • Excellent for development teams needing fast, comprehensive scans during the development and CI/CD processes.

  • Appropriate for projects that require scanning both OS packages and application dependencies without deploying separate tools.

Cloud Provider Scanning Services

Amazon ECR (Elastic Container Registry):

  • Automated Scanning: Amazon ECR automatically scans images on push and provides notifications for any found vulnerabilities, integrating seamlessly with AWS services.

  • Integration with AWS: Offers deep integration with AWS security tools and services, facilitating end-to-end container security within the AWS ecosystem.

Azure Container Registry:

  • Vulnerability Scanning: Powered by Qualys, Azure Container Registry provides scanning capabilities as part of the registry service, highlighting vulnerabilities in container images.

  • Actionable Insights: Offers actionable insights and recommendations for mitigating identified vulnerabilities, directly integrating with Azure DevOps.

Google Container Registry (GCR):

  • Vulnerability Scanning: GCR integrates with Google's Container Analysis and Binary Authorization, providing vulnerability scanning and policy enforcement capabilities.

  • Continuous Analysis: Automatically scans images stored in the registry and provides continuous analysis and vulnerability tracking over time.


  • Seamless Integration: Cloud-native tools offer seamless integration within their respective ecosystems, providing a smooth workflow from image registry to deployment.

  • Automated Workflows: These services often include automated scanning and notifications, reducing the manual effort required for vulnerability management.

Use Cases:

  • Ideal for organizations heavily invested in a particular cloud ecosystem, seeking to leverage integrated security features for convenience and efficiency.

  • Suitable for teams that require automated, continuous security analysis and prefer a managed service approach to container scanning.

In summary, the choice of a container image scanning tool depends on specific project requirements, including the need for speed, depth of analysis, integration capabilities, and the cloud ecosystem in use. Clair and Trivy offer open-source flexibility and comprehensive analysis options, while cloud provider scanning services deliver tightly integrated, automated solutions for users within their platforms.

Running Containers as Non-Root Users

The default approach of running containers with the root user presents security vulnerabilities. By executing processes with minimal privileges, organizations can reduce the attack surface and minimize potential damage from exploits. Here are best practices for achieving this:

1. Leverage Non-Root User Images:

  • Official Repositories: Opt for images on Docker Hub or cloud provider registries that ship with pre-configured non-root users. Look for "slim" or "alpine" variants known for their minimal footprints.

  • Custom Images: Create Dockerfiles that set a dedicated non-root user (e.g., USER 1000) and set appropriate permissions for directories and files accessed by the application.

2. Utilize the --user Flag:

  • When launching containers, employ the --user flag to specify a non-root user for the container's processes. This overrides the default root user.

3. Implement Capabilities:

  • For specific situations where specific root privileges are necessary, utilize capabilities to grant granular permissions instead of full root access. This minimizes the attack surface while enabling required functionality.

4. Manage Privileged Containers Cautiously:

  • If certain containers require root privileges (e.g., for network configuration), isolate them in separate networks and minimize their exposure to other containers and the host system.

5. Leverage Security Context Kubelet Option (Kubernetes):

  • In Kubernetes deployments, configure the runAsUser and runAsGroup options in the Pod Security Policy (PSP) to enforce non-root execution for containers within the cluster.

Benefits of Running Containers as Non-Root Users:

  • Reduced Attack Surface: Minimizes potential entry points for attackers by limiting available privileges.

  • Enhanced Containment: Breaches within a container are less likely to escalate to the host system, improving overall security posture.

  • Compliance: Aligns with security best practices and industry regulations that often mandate non-root container execution.

Adopting these practices for running containers as non-root users strengthens your container security posture. By combining these strategies with the existing guide's recommendations, you can create a comprehensive approach to safeguarding your containerized applications and data.

Data Persistence and Security


  1. Use Volumes for Production: Avoid storing data within containers. Utilize volumes for persistent data to improve performance and security.

  2. Bind Mounts for Development: Temporarily use bind mounts during development for convenience without compromising production security.

Volume Management:

  • Offer insights on securely managing volumes, especially when using orchestrators like Kubernetes, to ensure data integrity and access control.

Secret Management


  • Utilize dedicated secret management tools like AWS Secrets Manager or HashiCorp Vault to securely inject secrets into containers at runtime.

  • Detection of Accidental Exposure: Employ tools that scan for and alert on secrets accidentally committed to version control or included in Docker images.

Patch Management Framework

Structured Approach:

  1. Initial and Ongoing Scanning: Regularly scan images for vulnerabilities upon creation and after any significant changes.

  2. Impact Analysis: Assess the relevance of detected vulnerabilities to your environment and prioritize patches accordingly.

  3. Validation: Post-patch, rescan images to confirm vulnerabilities are resolved.

Automating Patch Management:

  • Integrate patch management into your CI/CD workflow for seamless updates and minimal downtime.

Understanding CVSS Scores

Example 1: E-Commerce Platform Vulnerability Management

Scenario: An e-commerce company utilizes containers to host its online shopping platform. During a routine scan, a vulnerability is detected in the container image used for the payment processing service. The vulnerability is associated with a third-party library and has a CVSS v3.0 score of 9.1, classified as "Critical."

Interpretation: Given the critical nature of the payment processing service and the high CVSS score, this vulnerability poses a significant risk to the integrity and confidentiality of customer transactions. A high score indicates that the vulnerability is easily exploitable, may lead to data breaches, and can potentially disrupt business operations.

Action: The DevOps team prioritizes this vulnerability for immediate remediation. They explore the following steps:

  • Assess whether the vulnerable library is actively used by their service or if it can be removed.

  • Apply a patch from the library's maintainers if available or update to a newer, secure version of the library.

  • If no immediate fix is available, consider implementing compensatory controls such as additional monitoring around the payment processing service or temporarily disabling certain features until a patch is released.

  • Rescan the image after remediation to ensure the vulnerability has been addressed.

Example 2: Healthcare Application Compliance and Security

Scenario: A healthcare application uses containers to manage patient data processing and analysis. A vulnerability scan on an image used for data analytics reveals a flaw with a CVSS v3.0 score of 4.3, rated as "Medium."

Interpretation: While the vulnerability is not classified as high or critical, it still represents a potential risk, especially considering the sensitive nature of healthcare data and stringent compliance requirements (e.g., HIPAA). The medium score suggests that the vulnerability may be more difficult to exploit or may not lead to severe impacts, but it cannot be ignored.

Action: The security team assesses the vulnerability in the context of their specific environment, considering factors such as exposure, potential data at risk, and existing security controls. They decide to:

  • Schedule a patch during the next maintenance window, as it does not require immediate action but should not be postponed indefinitely.

  • Review and strengthen access controls and encryption measures for data in transit and at rest as additional safeguards.

  • Monitor the affected component more closely until the patch is applied.

  • Communicate with stakeholders about the vulnerability and planned mitigation strategies, ensuring transparency and maintaining trust.

In both examples, the CVSS score serves as a critical input for prioritizing vulnerabilities and determining the urgency of remediation efforts. However, the final decision also considers the specific application's context, operational requirements, and potential impact on business operations and data security. This approach ensures that resources are allocated efficiently to maintain security while minimizing disruptions.

By adopting these enhanced practices, DevOps teams can significantly improve the security posture of their containerized environments. Through diligent base image selection, efficient multi-stage builds, rigorous scanning, and proactive patch management, organizations can mitigate risks and foster a culture of security and resilience.