Orchestration
An orchestrator is a system or platform that deploys applications and dynamically responds to changes.
For example, Kubernetes can:
- Deploy applications
- Scale them up and down based on demand
- Self-heal them when things break
- Perform zero-downtime rolling updates and rollbacks
- Etc
The best part is that it does all of this without you having to get involved. You need to configure a few things in the first place, but once you’ve done that, you sit back and let Kubernetes work its magic.
Containerization
Containerization is the process of packaging an application and dependencies as an image and then running it as a container.
Info
It can be useful to think of containers as the next generation of virtual machines (VM). Both are ways of packaging and running applications, but containers are smaller, faster, and more portable.
Despite these advantages, containers haven’t replaced VMs, and it’s common for them to run side-by-side in most cloud-native environments.
👉 01. Containerization and Virtualization
Cloud Native
Cloud-native applications possess cloud-like features such as auto-scaling, self-healing, automated updates, rollbacks and more.
Simply running a regular application in the public cloud does not make it cloud-native.
Summary
cloud-native apps are resilient, automatically scale, and can be updated without downtime.
👉 0400 - Cloud Native Development
Microservices
Microservices applications are built from many small, specialized, independent parts that work together to form a useful application.
Microservices are loosely coupled by design, and each one exposes an API that others use to consume it. These are fundamental to the ability to change one without affecting others.
Explanation
Consider an e-commerce app with the following six features:
- Web front-end
- Catalog
- Shopping cart
- Authentication
- Logging
- Store
To make this a microservices app, you design, develop, deploy, and manage each feature as its own small application. We call each of these small apps a microservice, meaning this app will have six microservices.
This design brings huge flexibility by allowing all six microservices to have their own small development teams and their own release cycles. It also lets you scale and update each one independently.
The most common pattern is to deploy each microservice as its own container. This means one or more web front-end containers, one or more catalog containers, one or more shopping cart containers, etc. Scaling any part of the app is as simple as adding or removing containers.
