Cloud Native Security and Kubernetes [page]deterministic

Kubernetes is based on a cloud native architecture and draws on advice from the [CNCF](#gloss:cncf) about good practices for cloud native information security.

Read on for an overview of how Kubernetes is designed to help you deploy a secure cloud native platform.

## Cloud native information security

There are localized versions available of this whitepaper; if you can link to one of those when localizing, that's even better.

The CNCF [white paper](https://github.com/cncf/tag-security/blob/main/community/resources/security-whitepaper/v2/CNCF_cloud-native-security-whitepaper-May2022-v2.pdf) on cloud native security defines security controls and practices that are appropriate to different _lifecycle phases_.

## _Develop_ lifecycle phase {#lifecycle-phase-develop}

• Ensure the integrity of development environments.
• Design applications following good practices for information security, appropriate for your context.
• Consider end user security as part of solution design.

To achieve this, you can:

1. Adopt an architecture, such as [zero trust](https://glossary.cncf.io/zero-trust-architecture/), that minimizes attack surfaces, even for internal threats. 1. Define a code review process that considers security concerns. 1. Build a _threat model_ of your system or application that identifies trust boundaries. Use that threat model to identify risks and determine how to treat them. 1. Incorporate advanced security automation, such as _fuzzing_ and [security chaos engineering](https://glossary.cncf.io/security-chaos-engineering/), where it's justified.

## _Distribute_ lifecycle phase {#lifecycle-phase-distribute}

• Ensure the security of the supply chain for container images you execute.
• Ensure the security of the supply chain for the cluster and other components that execute your application. For example, this might include an external database that your cloud native application uses for persistence.

To achieve this, you can:

1. Scan container images and other artifacts for known vulnerabilities. 1. Ensure that software distribution uses encryption in transit, with a chain of trust for the software source. 1. Adopt and follow processes to update dependencies when updates are available, especially in response to security announcements. 1. Use validation mechanisms such as digital certificates for supply chain assurance. 1. Subscribe to feeds and other mechanisms to alert you to security risks. 1. Restrict access to artifacts. Place container images in a [private registry](/docs/concepts/containers/images/#using-a-private-registry) that only allows authorized clients to pull images.

## _Deploy_ lifecycle phase {#lifecycle-phase-deploy}

Ensure appropriate restrictions on what can be deployed, who can deploy it, and where it can be deployed. You can enforce measures from the _distribute_ phase, such as verifying the cryptographic identity of container image artifacts.

You can deploy different applications and cluster components into different [namespaces](#gloss:namespace). Containers and namespaces both provide isolation mechanisms that are relevant to information security.

When you deploy Kubernetes, you also set the foundation for your applications' runtime environment: a Kubernetes cluster (or multiple clusters). That infrastructure must provide the security guarantees that higher layers expect.

## _Runtime_ lifecycle phase {#lifecycle-phase-runtime}

The Runtime phase comprises three critical areas: [access](#protection-runtime-access), [compute](#protection-runtime-compute), and [storage](#protection-runtime-storage).

### Runtime protection: access {#protection-runtime-access}

The Kubernetes API is what makes your cluster work. Protecting this API is key to providing effective cluster security.

Other pages in the Kubernetes documentation have more detail about how to set up specific aspects of access control. The [security checklist](/docs/concepts/security/security-chec …(trimmed)