Observability
Three signals answer three different questions
Metrics say something is wrong, logs say what, traces say where.
Observability means being able to explain what a system is doing from the data it gives off. There are three kinds of data. Metrics are numbers over time. Here, errors per minute, and you can see the moment they jump. A metric tells you something is wrong. Logs are the lines a program writes. They tell you what happened: a database timeout. A trace follows one request through every service. This request took four hundred milliseconds, and nearly all of it was the database.
Observability · Going deeper
The observability tools
Prometheus, Grafana, Fluentd, Jaeger and OpenTelemetry.
Prometheus
Prometheus pulls metrics from every target
Prometheus scrapes /metrics. Grafana draws it. Alertmanager sends the alerts.
The metrics tool to know is Prometheus. Each application serves its numbers on a small web page, slash metrics. Prometheus visits every target on a schedule and collects them. That is the pull model: the applications never send anything. Grafana queries Prometheus to draw dashboards. The query language is called Prom Q L. And when a rule is broken, Alertmanager groups the alerts and notifies whoever is on call.
Prometheus · Going deeper
SLI, SLO, SLA and the roles
An SLI is measured, an SLO is the target, an SLA is the promise.
Check yourself
What is this, and what does it tell you?
Autoscaling
More pods, bigger pods, or more nodes
HPA adds pods, VPA resizes them, the Cluster Autoscaler adds nodes.
A cloud native system changes its own size. There are three autoscalers, and each changes a different thing. The horizontal pod autoscaler adds pods when load rises, and removes them when it falls. Two pods become four. The vertical pod autoscaler keeps one pod, but gives it more C P U or memory. The cluster autoscaler works on the machines. When pods are pending because no node has room, it adds a node.
Autoscaling · Going deeper
Autoscalers compared
KEDA scales on events and Knative on requests, both from zero.
The CNCF
Projects climb from Sandbox to Graduated
Sandbox, Incubating, Graduated: the TOC votes on each step.
Most of the projects in this course live in one foundation, the Cloud Native Computing Foundation. It sorts them by maturity. A project starts in the sandbox. It is early and experimental. With real production users and a healthy flow of contributors, it becomes incubating. When it is proven, has passed a security audit and is widely adopted, it graduates. Kubernetes was the first. Each step up is a vote by the technical oversight committee.
The CNCF · Going deeper
Who is who in the community
The TOC, TAGs, Kubernetes SIGs and KEPs.
Check yourself
Which maturity level fits this project?
Serverless
Serverless follows the load, down to zero
Run only while there is work, then scale to zero. Knative and KEDA do it on Kubernetes.
One last idea: serverless. Here are twelve minutes of load. The numbers underneath are requests per second. A fixed fleet runs three instances the whole time, busy or idle. That is thirty six instance minutes. A serverless platform starts instances only when requests arrive, and stops them afterwards, all the way down to zero. The same load takes eleven instance minutes. You stop paying for waiting. The cost is a short delay when the first request arrives.
Serverless · Going deeper · 1 of 2
What "cloud native" means, and open standards
Resilient, manageable, observable, and built on open standards.
Serverless · Going deeper · 2 of 2
Clue words for cloud native architecture
Prometheus, OpenTelemetry, the autoscalers and the CNCF levels.
Check yourself
Which autoscaler solves this?
Lesson complete
You finished “Cloud native architecture”
Answer the questions along the way to see your score here.