{"id":3831,"date":"2018-10-03T17:15:19","date_gmt":"2018-10-03T14:15:19","guid":{"rendered":"https:\/\/www.systemcodegeeks.com\/?p=3831"},"modified":"2018-10-03T12:39:58","modified_gmt":"2018-10-03T09:39:58","slug":"cloud-native-container-design-principles","status":"publish","type":"post","link":"https:\/\/www.systemcodegeeks.com\/devops\/cloud-native-container-design-principles\/","title":{"rendered":"Cloud Native Container Design Principles"},"content":{"rendered":"

Software design principles<\/h3>\n

Principles exist in many areas of life, and they generally represent a fundamental truth or belief from which others are derived. In software, principles are rather abstract guidelines, which are supposed to be followed while designing software. There are fundamental principles for writing quality software such as KISS (Keep it simple, stupid), DRY (Don\u2019t repeat yourself), YAGNI (You aren\u2019t gonna need it), SoC (Separation of concerns), etc. Even if these principles do not specify concrete rules, they represent a language and common wisdom that many developers understand and refer to regularly.<\/p>\n

There are also SOLID principles that were introduced by\u00a0Robert C. Martin<\/a>, which represent guidelines for writing better object-oriented software. It is a framework consisting of complementary principles that are generic and open for interpretation but still give enough direction for creating better object-oriented designs. The SOLID principles use object-oriented primitives and concepts such as classes, interfaces, and inheritance for reasoning about object-oriented designs. In a similar way, there also principles for designing cloud native applications in which the main primitive is the container image rather than a class. Following these principles will ensure that the resulting containers behave like a good cloud native citizen, allowing them to be scheduled, scaled, and monitored in an automated fashion.<\/p>\n

SOLID principles for cloud native applications<\/h3>\n

Cloud native applications anticipate failure; they run and scale reliably even when their infrastructure experiences outages. To offer such capabilities, cloud native platforms like Kubernetes impose a set of contracts on applications. These contracts ensure that applications they run conform to certain constraints and allow the platform to automate application management. Nowadays, it is possible to put almost any application in a container and run it. But to create a containerized application that can be automated and orchestrated effectively by a cloud native platform such as Kubernetes requires additional efforts. The principles for creating containerized applications listed here use the container as the basic primitive and the container orchestration platforms as the target container runtime environment.<\/p>\n

\"Design<\/a>
Principles of container-based application design<\/figcaption><\/figure>\n

Below is a short description of what each principle implies. To read in more debth, download the freely available white paper from\u00a0here<\/a>.<\/p>\n

Build time<\/b>:<\/p>\n