Cloud Native Applications - Part 2: Security
Tags: aws, cloudnative, kubernetes, cicd
Published: 2023-01-28 15:54:32

In [chapter 1](https://dev.to/aws-builders/cloud-native-applications-part-1-introduction-chg) of this series about cloud-native applications, we have introduced the key characteristics of cloud-native applications.  
In this chapter, we will review how to secure cloud-native applications.  
## Securing the CI/CD pipeline
Due to the dynamic nature of the cloud-native application, we need to begin securing our application stack from the initial steps of the CI/CD pipeline.  
Since I have already written posts on how to secure DevOps processes, automation, and supply chain, I will highlight the following:  
* Run code analysis using automated tools (SAST – Static application security tools, DAST – Dynamic application security tools)  
* Run SCA (Software composition analysis) tool to detect known vulnerabilities in open-source binaries and libraries  
* Sign your software package before storing them in a repository  
* Store all your sources (code, container images, libraries) in a private repository, protected by strong authorization mechanisms  
* Invest in security training for developers, DevOps, and IT personnel  
* Make sure no human access is allowed to production environments (use Break Glass accounts for emergency purposes)  

### Additional references:
* [Integrate security aspects in a DevOps process](https://security-24-7.com/integrate-security-aspects-in-a-devops-process/)  
* [Securing the Software Supply Chain in the Cloud](https://dev.to/aws-builders/securing-the-software-supply-chain-in-the-cloud-3p1h)  
* [Cloud Native Security Map](https://cnsmap.netlify.app/)  

## Securing infrastructure build process
As I have mentioned in the previous chapter of this series, one of the characteristics of cloud-native applications is the fact that it is built using Infrastructure as Code.  
Each cloud provider has its own IaC scripting language, and naturally, there is cloud agnostic (or multi-cloud…) – HashiCorp Terraform.  
Since this is code, we need to store the code in a private repository and scan the code for security vulnerabilities, but we need an additional layer of protection for Infrastructure as Code.  
This is referred to as Policy as Code, where we can define a set of controls, from enforcing encryption at transit and rest, enabling resource provisioning on specific regions, or prohibiting the creation of instances with public IP.  
The next thing in terms of the policy as code is called OPA – Open Policy Agent. It supports all major cloud providers and has built-in integration with Terraform, Kubernetes, and more.  
OPA has its declarative language called Rego and it can integrate inside an existing CI/CD pipeline.  
### Additional references:
* [Introduction to Policy as Code](https://dev.to/aws-builders/introduction-to-policy-as-code-5bma)  
* [Automation as key to cloud adoption success](https://dev.to/aws-builders/automation-as-key-to-cloud-adoption-success-5ef9)  
* [Open Policy Agent](https://www.openpolicyagent.org/)  
* [Terraform OPA policies examples](https://github.com/Scalr/sample-tf-opa-policies)  


## Securing Containers / Kubernetes
Containers are one of the most common ways to package and deploy modern applications, and as a result, we need to secure the containerized environment.  
It begins with a minimum number of binaries and libraries inside a container image.  
We must make sure we scan our container images for vulnerable binaries or open-source libraries, and eventually, we need to store our container images inside a private container registry.  
In most cases, when using Kubernetes as an orchestrator, we should choose a managed Kubernetes service (offered by each of the major cloud providers).  
Using a Kubernetes control plane based on a managed service shifts the responsibility for securing and maintaining the Kubernetes control plane on the cloud provider.  
One thing to keep in mind – we should always create private clusters, and make sure the control plane is never accessible outside our private subnets, to reduce the attack surface on our Kubernetes cluster.  
In terms of authorization, we should follow the principle of least privilege and use RBAC (Role-based access control), to allow our application to function and our developers or support team the minimum number of required permissions to do their job.  
In terms of network connectivity to and between pods, we should use one of the service mesh solutions (such as Istio), and set network policies that clearly define which pod can communicate with which pod, and who can access the API server.  
In terms of secrets management that the containers need access to, we need to make sure all sensitive data (secrets, credentials, API keys, etc.) are stored in a secured location (such as [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) or [HashiCorp Vault](https://developer.hashicorp.com/vault/docs)), where all requests to pull a secret are authorized and audited, and secrets can automatically rotate.  

### Additional references:
* [Kubernetes security](https://kubernetes.io/docs/concepts/security/)  
* [Overview of Cloud Native Security](https://kubernetes.io/docs/concepts/security/overview/)  
* [OWASP - Kubernetes Security Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Kubernetes_Security_Cheat_Sheet.html)  
* [CIS Benchmark for Kubernetes](https://www.cisecurity.org/benchmark/kubernetes)  
* [The Istio service mesh](https://istio.io/latest/about/service-mesh/)  

## Securing APIs
As we have mentioned in the previous chapter, communication between containers is done using APIs. Also, when communicating with applications deployed inside pods as part of the Kubernetes cluster, all communication is done through the Kubernetes API server.  
Not to mention that modern applications, websites and naturally mobile applications are exposing APIs to customers from the public internet (unless your application is meant for private use only…).  
Below are the main best practices for securing APIs:  
* Authentication – make sure all your APIs require authentication. Regardless if your API is supposed to share public stock exchange data, a retail book catalog, or weather statistics, all requests to pull data from an exposed API must be authenticated.  
* Authorization – make sure you set strict access control on each API request, whether it is read data from a database, update records, or privileged actions such as deleting data. Keep in mind the principle of least privilege.  
* Encryption – all traffic to an exposed API must be encrypted at transit using the most up-to-date encryption protocol (for example TLS 1.2 or above). Encryption keeps the data confidential and proves the identity of your API (or server) to your customers.  
* Auditing – make sure all actions done on your APIs are auditing and all logs are sent to a central logging system (or SIEM) for further archive and analysis (to find out if someone is trying to take actions they are not supposed to).  
* Input validation – make sure all input coming to your APIs is been validated, before storing it in a backend database. It will allow you to limit the chance of injection attacks.  
* DDoS and web-related attacks – make sure all your exposed APIs are protected behind anti-DDoS and behind a web application firewall. If it will not block 100% of the attacks, at least you will be able to block the well-known and signature-based attacks and decrease the amount of unwanted traffic against your APIs.  
* Code review – API is a piece of code. Before pushing new changes to any API, make sure you run static and dynamic code analysis, to locate security vulnerabilities embed in your code.  
* Throttling – make sure you enforce a throttling mechanism, in case someone tries to access your API multiple times from the same source, to avoid a situation where your API is unavailable for all your customers.  

### Additional reference:
* [OWASP API Security Project](https://owasp.org/www-project-api-security/)  

## Authorization
Authorization in a cloud-native application can be challenging.  
On legacy applications all components were built as part of a single monolith, users had to log in from a single-entry point, and once we have authenticated and authorized them, they were to access data and with proper permissions to make changes to data as well.  
Since modern applications are built upon micro-service architecture, we need to think not just about end users communicating with our application, but also about how each component in our architecture is going to communicate with other components (such as pod-to-pod communication required authorization).  
If every component in our entire application is developed by a separate team, we need to think about a central authorization mechanism.  
But central authorization mechanism is not enough.  
We need to integrate our authorization mechanism with a central IAM (Identity and Access Management) system.  
I would not recommend to re-invent the wheel – try to use the IAM service from your cloud provider of choice. Cloud-native IAM systems have built-in integration with the cloud eco-system, including auditing capabilities – this way you will be able to consume the service, without maintaining the underlining infrastructure.  
Checking the end-users' privileges at login time might not be sufficient. We need to think about fine-grain permissions – is a generic "Reader user" enough? Do the user needs read access to all data stored in our data store? Perhaps he only needs read access to a specific line of business customers database and nothing more. Always keep in mind the principle of least privilege.  
Our authorization mechanism needs to be dynamic according to each request and data the user is trying to access, be verified constantly and allow us to easily revoke permissions in case of suspicious activity, when permissions are no longer needed or if data confidentially has changed over time.  
We need to make sure our authorization mechanism can be easily integrated and consumed by each of the various development groups, as a standard authorization mechanism.  
### Additional references:
* [OPAL - Open-Policy Administration Layer](https://www.opal.ac/)  
* [Netflix’s permissions design in a talk at KubeCon](https://youtu.be/R6tUNpRpdnY?t=915)  


## Summary
In this post, we have reviewed various topics we need to take into consideration when talking about how to secure cloud-native applications.  
We have reviewed the highlights of securing the build process, the infrastructure provisioning, Kubernetes (as an orchestrator engine to run our applications), and not forgetting topics that are part of the secure development lifecycle (securing APIs and authorization mechanism).  
Naturally, we have just covered some of the highlights of security in cloud-native applications.  
I strongly recommend you to deep dive into each topic, read the references and search for additional information that will allow any developer, DevOps, DevSecOps, architect, or security professional, to better secure cloud-native applications.  

### Additional References:
* [OWASP Cloud-Native Application Security Top 10](https://owasp.org/www-project-cloud-native-application-security-top-10/)  
* [Cloud Native Security Whitepaper](https://github.com/cncf/tag-security/blob/main/security-whitepaper/v2/cloud-native-security-whitepaper.md)  

### About the Author
Eyal Estrin is a cloud and information security architect, the owner of the blog [Security & Cloud 24/7](https://security-24-7.com/) and the author of the book [Cloud Security Handbook](https://amzn.to/3xMI4Ak), with more than 20 years in the IT industry.  
Eyal is an [AWS Community Builder](https://aws.amazon.com/developer/community/community-builders/) since 2020.  
You can connect with him on [Twitter](https://twitter.com/eyalestrin) and [LinkedIn](https://www.linkedin.com/in/eyalestrin/).