Cloud Native Concepts
Cloud native technologies empower organizations to build and run scalable applications in modern, dynamic environments such as public, private, and hybrid clouds. Containers, service meshes, microservices, immutable infrastructure, and declarative APIs exemplify this approach.
1. The Core Philosophy
Cloud native is not just about running on the cloud (AWS/Azure). It is about how applications are built and deployed. It focuses on exploiting the advantages of the cloud computing delivery model.
- Goal: To deliver features faster, with higher quality and reliability, at scale.
2. The Four Pillars
Cloud native architecture typically relies on four key pillars:
1. Microservices
Breaking applications into loosely coupled services.
- Benefit: Independent development, deployment, and scaling.
2. Containers
Packaging code and dependencies together.
- Benefit: Consistency across environments (Dev, Test, Prod). "Write once, run anywhere."
3. Continuous Delivery (CI/CD)
Automating the release process.
- Benefit: Frequent, reliable, and low-risk releases.
4. DevOps
Collaboration between development and operations.
- Benefit: Shared ownership and faster feedback loops.
3. Cloud Native vs. Cloud Enabled
- Cloud Enabled (Lift and Shift): Taking a legacy monolithic application and running it on a cloud VM (EC2) instead of an on-premise server. It doesn't fully leverage cloud elasticity.
- Cloud Native: Designed from the ground up for the cloud. It uses managed services, scales automatically, and handles failure gracefully.
4. Immutable Infrastructure
In a cloud native world, servers are immutable. You never log in to a server to patch it or update config.
- Update: You build a new container image, deploy it, and destroy the old one.
- Cattle vs. Pets: Servers are cattle (replaceable), not pets (nursed back to health).
5. The CNCF (Cloud Native Computing Foundation)
The CNCF hosts critical projects like Kubernetes, Prometheus, and Envoy. It fosters the ecosystem of vendor-neutral, open-source projects.
6. Declarative APIs
In cloud native systems, you declare the desired state of the system, and the system works to achieve that state.
- Imperative (How): You give specific commands (e.g., "Start server", "Add IP"). If a command fails, the system is in an unknown state.
- Declarative (What): You describe the end goal (e.g., "I want 3 replicas of this app"). The system (like Kubernetes) constantly monitors the current state and reconciles it with the desired state.
- Benefit: Self-healing. If a server crashes, the system notices the discrepancy (2 replicas instead of 3) and automatically starts a new one.
programming/microservices-architecture programming/docker-and-containers programming/kubernetes-basics programming/devops programming/twelve-factor-app