Observability Interview Questions with Hands-On Proof
What you build: 15 observability interview answers, each proved with a real command on GKE with Prometheus: rate, p99, cardinality, SLOs, alerts. Every step tested.

✍️ Translate this blog into Hindi, Tamil or Telugu
Observability interviews love the same 15 questions: metrics, logs or traces? Counter or gauge? Why rate()? Why p99? What is cardinality? What is an SLO? Most people answer from memory. In this post every answer comes with proof: a command we ran on a real Kubernetes cluster with Prometheus, and the real output. Read the answer, run the command, and you can say "I have seen it" in your interview.
Who it is for: anyone preparing for DevOps, SRE or platform interviews. Time: about 1.5 hours to run everything. Cost: a small GKE cluster for about 20 minutes, covered by the free trial credit. Delete it at the end.
Every command below was run for real by the CareerByteCode Team, and every output is the real result we got. We typed the commands in a Cloud Shell-like Linux VM (Debian with gcloud, kubectl, helm and jq); Cloud Shell in your browser has the same tools.
The lab behind the answers
One small web app (podinfo, 2 replicas) publishes Prometheus metrics. A load pod calls it about 5 times a second, and a second container calls a page that takes 1 second (/delay/1) every 2 seconds, so there are fast and slow requests. Prometheus (from the kube-prometheus-stack Helm chart, with Grafana and Alertmanager switched off) scrapes it. To ask Prometheus questions from the shell, we use a 3-line helper, q.sh:
#!/bin/bash
# q.sh '<PromQL>' : ask Prometheus (port-forward on 9090) and print one line per result: labels = value (2 decimals)
curl -s http://localhost:9090/api/v1/query --data-urlencode "query=$1" | jq -r '.data.result[] | ((.metric | del(.__name__) | to_entries | map(.key + "=" + .value) | join(",")) as $l | (if $l == "" then "value" else $l end) + " = " + (.value[1] | tonumber | . * 100 | round / 100 | tostring))'
You need a Google Cloud project with billing linked and one small GKE cluster. We created it once for this batch of Kubernetes labs:
gcloud container clusters create lab-cluster \
--zone=us-east1-b --num-nodes=2 --machine-type=e2-standard-4 \
--disk-type=pd-standard --disk-size=50 --release-channel=regular \
--no-enable-autoupgrade --enable-dataplane-v2The app (app.yaml), the settings (values.yaml) and the ServiceMonitor:
# podinfo: a small web app that publishes Prometheus metrics on /metrics, plus a load pod that calls it all the time
apiVersion: apps/v1
kind: Deployment
metadata: {name: podinfo, labels: {app: podinfo}}
spec:
replicas: 2
selector: {matchLabels: {app: podinfo}}
template:
metadata: {labels: {app: podinfo}}
spec:
containers:
- name: podinfo
image: ghcr.io/stefanprodan/podinfo:6.7.1
ports: [{name: http, containerPort: 9898}]
resources: {requests: {cpu: 20m, memory: 32Mi}}
---
apiVersion: v1
kind: Service
metadata: {name: podinfo, labels: {app: podinfo}}
spec:
selector: {app: podinfo}
ports: [{name: http, port: 9898, targetPort: 9898}]
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: load}
spec:
replicas: 1
selector: {matchLabels: {app: load}}
template:
metadata: {labels: {app: load}}
spec:
containers:
- name: load
image: curlimages/curl:8.10.1
env: [{name: ERROR_PATH, value: ""}]
command: ["sh", "-c", "while true; do curl -s -o /dev/null http://podinfo:9898/; [ -n \"$ERROR_PATH\" ] && curl -s -o /dev/null http://podinfo:9898$ERROR_PATH; sleep 0.2; done"]
resources: {requests: {cpu: 10m, memory: 16Mi}}
- name: slow
image: curlimages/curl:8.10.1
command: ["sh", "-c", "while true; do curl -s -o /dev/null http://podinfo:9898/delay/1; sleep 2; done"]
resources: {requests: {cpu: 10m, memory: 16Mi}}# kube-prometheus-stack settings for this lab: Prometheus only, small, short retention
prometheus:
prometheusSpec:
serviceMonitorSelectorNilUsesHelmValues: false
ruleSelectorNilUsesHelmValues: false
retention: 6h
kubeControllerManager: {enabled: false}
kubeScheduler: {enabled: false}
kubeEtcd: {enabled: false}
kubeProxy: {enabled: false}
alertmanager: {enabled: false}
grafana: {enabled: false}apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata: {name: podinfo, namespace: shop}
spec:
selector: {matchLabels: {app: podinfo}}
endpoints: [{port: http, interval: 15s}]# The lab: a sample web app with load, and Prometheus (kube-prometheus-stack, Grafana and Alertmanager off)
gcloud container clusters get-credentials lab-cluster --zone=us-east1-b > /dev/null 2>&1
kubectl create namespace shop > /dev/null && kubectl apply -n shop -f app.yaml > /dev/null && kubectl -n shop rollout status deploy/podinfo deploy/load --timeout=180s | tail -1
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts > /dev/null; helm repo update > /dev/null
helm install monitoring prometheus-community/kube-prometheus-stack --version 66.3.1 -n monitoring --create-namespace -f values.yaml --wait --timeout 10m | grep -E "^(NAME|STATUS)"
kubectl apply -f servicemonitor.yaml; chmod +x q.sh
nohup kubectl -n monitoring port-forward svc/monitoring-kube-prometheus-prometheus 9090:9090 > pf-prom.log 2>&1 &
sleep 90; echo "Prometheus targets in shop: $(curl -s http://localhost:9090/api/v1/targets | jq '[.data.activeTargets[] | select(.labels.namespace=="shop" and .health=="up")] | length') up"deployment "load" successfully rolled out
NAME: monitoring
NAMESPACE: monitoring
STATUS: deployed
servicemonitor.monitoring.coreos.com/podinfo created
Prometheus targets in shop: 2 upQ1. Metrics, logs and traces: what is the difference?
Answer: a metric is a number over time, cheap to keep and great for alerts and graphs. A log is a line of text about one event, great for details. A trace follows one request through many services, great for "where is the time spent". You usually start from a metric (something is wrong), then use logs and traces to find out why.
Proof: the same app as a number and as a log line:
# Q1. Metrics, logs and traces: the same requests seen as a number (metric) and as lines (log)
./q.sh 'sum(rate(http_request_duration_seconds_count{namespace="shop"}[1m]))' | sed 's/^value/metric: requests per second/'
kubectl -n shop logs deploy/podinfo --tail=200 2>/dev/null | grep -m1 '"msg"' | cut -c1-160metric: requests per second = 5.18
{"level":"info","ts":"2026-11-19T07:02:44.544Z","caller":"podinfo/main.go:153","msg":"Starting podinfo","version":"6.7.1","revision":"6b7aab8a10d6ee8b895b0a5048We did not set up tracing in this lab, so there is no trace proof here.
Q2. Counter or gauge?
Answer: a counter only goes up (requests served, CPU seconds used) and resets to 0 when the process restarts. A gauge goes up and down (memory in use, queue length). Prometheus stores the type with the metric.
Proof: we ask Prometheus for the type of two metrics, then read each twice, 20 seconds apart. The request counter grew by 118. Memory rose by about 2 MiB here; as a gauge it can also go down when the app frees memory:
# Q2. Counter or gauge? Ask Prometheus for the TYPE of two metrics, then read each twice, 20 seconds apart
curl -s 'http://localhost:9090/api/v1/metadata?metric=process_cpu_seconds_total' | jq -r '.data | to_entries[] | .key + ": " + .value[0].type'
curl -s 'http://localhost:9090/api/v1/metadata?metric=process_resident_memory_bytes' | jq -r '.data | to_entries[] | .key + ": " + .value[0].type'
for t in 1 2; do echo "read $t: requests so far $(./q.sh 'sum(http_request_duration_seconds_count{namespace="shop"})' | cut -d' ' -f3), memory $(./q.sh 'sum(process_resident_memory_bytes{namespace="shop",job="podinfo"}) / 1048576' | cut -d' ' -f3) MiB"; if [ $t = 1 ]; then sleep 20; fi; doneprocess_cpu_seconds_total: counter
process_resident_memory_bytes: gauge
read 1: requests so far 764, memory 80.71 MiB
read 2: requests so far 882, memory 82.84 MiBQ3. Why rate() and not the raw counter?
Answer: the raw total depends on when each process started and drops when a pod restarts. rate() gives "per second over a window", which is what you want to graph and alert on.
Proof: we restart one podinfo pod. The raw total of the app fell by about 270, because the new pod starts at 0. The rate barely moved:
# Q3. Why rate() and not the raw counter? Restart one pod: its counter starts again from 0
P=$(kubectl -n shop get pod -l app=podinfo -o jsonpath='{.items[0].metadata.name}')
echo "before: raw total $(./q.sh 'sum(http_request_duration_seconds_count{namespace="shop"})' | cut -d' ' -f3), rate $(./q.sh 'sum(rate(http_request_duration_seconds_count{namespace="shop"}[2m]))' | cut -d' ' -f3) per second"
kubectl -n shop delete pod $P > /dev/null; kubectl -n shop rollout status deploy/podinfo --timeout=90s > /dev/null; sleep 45
echo "after: raw total $(./q.sh 'sum(http_request_duration_seconds_count{namespace="shop"})' | cut -d' ' -f3), rate $(./q.sh 'sum(rate(http_request_duration_seconds_count{namespace="shop"}[2m]))' | cut -d' ' -f3) per second"
echo "counter resets Prometheus saw: $(./q.sh 'sum(resets(http_request_duration_seconds_count{namespace="shop"}[5m]))' | cut -d' ' -f3)"before: raw total 955, rate 5.1 per second
after: raw total 684, rate 5.14 per second
counter resets Prometheus saw: 0resets() shows 0 here because the new pod is a new time series (its pod label is different), not a reset of the old one. A reset is counted when the same process's counter goes back to 0, for example after a container restart inside the same pod.
Q4 and Q5. Average or percentile? Why p99?
Answer: an average mixes many fast requests with a few slow ones and describes nobody. Percentiles describe real users: p95 = 95 of 100 requests were faster than this. Prometheus computes them from a histogram with histogram_quantile().
Proof:
# Q4 and Q5. Average or percentile? The app has fast requests and some that take 1 second
./q.sh 'sum(rate(http_request_duration_seconds_sum{namespace="shop"}[2m])) / sum(rate(http_request_duration_seconds_count{namespace="shop"}[2m]))' | sed 's/^value/average seconds/'
for q in 50 95 99; do ./q.sh "histogram_quantile(0.$q, sum by (le) (rate(http_request_duration_seconds_bucket{namespace=\"shop\"}[2m])))" | sed "s/^value/p$q seconds/"; doneaverage seconds = 0.06
p50 seconds = 0
p95 seconds = 1.28
p99 seconds = 2.26The average is 0.06 seconds, which looks great. But p95 is 1.28 seconds and p99 2.26 seconds: the slow page is invisible in the average. (p50 shows 0 because q.sh rounds to 2 decimals: the typical request takes a few milliseconds.)
Q6. What are RED and USE?
Answer: RED is for services: Rate, Errors, Duration. USE is for resources: Utilisation, Saturation, Errors. Every service dashboard should answer RED first.
Proof: one line for each letter, all from the same Prometheus:
# Q6. RED for services (Rate, Errors, Duration) and USE for resources (Utilisation, Saturation, Errors)
./q.sh 'sum(rate(http_request_duration_seconds_count{namespace="shop"}[2m]))' | sed 's/^value/R requests per second/'
./q.sh '100 * (sum(rate(http_request_duration_seconds_count{namespace="shop",status=~"5.."}[2m])) or vector(0)) / sum(rate(http_request_duration_seconds_count{namespace="shop"}[2m]))' | sed 's/^value/E error percent/'
./q.sh 'histogram_quantile(0.95, sum by (le) (rate(http_request_duration_seconds_bucket{namespace="shop"}[2m])))' | sed 's/^value/D p95 seconds/'
./q.sh '100 * sum(rate(container_cpu_usage_seconds_total{namespace="shop",container="podinfo"}[2m])) / sum(kube_pod_container_resource_requests{namespace="shop",container="podinfo",resource="cpu"})' | sed 's/^value/U cpu percent of request/'
./q.sh 'sum(rate(container_cpu_cfs_throttled_periods_total{namespace="shop",container="podinfo"}[2m]))' | sed 's/^value/S throttled periods per second/'
./q.sh 'sum(kube_pod_container_status_restarts_total{namespace="shop",container="podinfo"})' | sed 's/^value/E restarts/'R requests per second = 5.19
E error percent = 0
D p95 seconds = 1.3
U cpu percent of request = 13.81
E restarts = 0
Q7. What is cardinality, and why does it matter?
Answer: every unique set of label values is one time series, and every series costs memory. A label with endless values (user id, full URL) creates millions of series and can take Prometheus down.
Proof: how many series Prometheus holds now, which metric names have the most, and how many series one podinfo histogram creates (buckets x paths x status codes x pods):
# Q7. Cardinality: how many time series does Prometheus hold, and which metric names have the most?
curl -s http://localhost:9090/api/v1/status/tsdb | jq -r '"series in memory now: " + (.data.headStats.numSeries | tostring)'
curl -s http://localhost:9090/api/v1/status/tsdb | jq -r '.data.seriesCountByMetricName[:5][] | " " + .name + ": " + (.value | tostring)'
./q.sh 'count(http_request_duration_seconds_bucket{namespace="shop"})' | sed 's/^value/series for one podinfo histogram/'series in memory now: 112009
apiserver_request_sli_duration_seconds_bucket: 15180
etcd_request_duration_seconds_bucket: 12960
apiserver_request_duration_seconds_bucket: 10824
apiserver_request_body_size_bytes_bucket: 9760
apiserver_watch_list_duration_seconds_bucket: 3582
series for one podinfo histogram = 72Over 112,000 series on a small, quiet lab cluster, mostly from the Kubernetes API server's histograms. One histogram of our small app already makes 72.
Q8 and Q9. How does Prometheus find targets, and what is up?
Answer: Prometheus pulls: it scrapes each target's /metrics. On Kubernetes, a ServiceMonitor tells it which Services to scrape (service discovery). For every target Prometheus writes the series up: 1 if the last scrape worked, 0 if not.
Proof:
# Q8 and Q9. How does Prometheus find targets, and what does "up" mean? Each target: its labels, health and last scrape
curl -s http://localhost:9090/api/v1/targets | jq -r '.data.activeTargets[] | select(.labels.namespace=="shop") | .scrapePool + " pod " + .labels.pod + " " + .health + " scrape took " + (.lastScrapeDuration * 1000 | round | tostring) + " ms"'
./q.sh 'up{namespace="shop"}' | sed -E 's/,(container|endpoint|instance|service)=[^,= ]*//g'serviceMonitor/shop/podinfo/0 pod podinfo-68d7484f5-mwh99 up scrape took 5 ms
serviceMonitor/shop/podinfo/0 pod podinfo-68d7484f5-hrzrs up scrape took 5 ms
container=podinfo,job=podinfo,namespace=shop,pod=podinfo-68d7484f5-mwh99 = 1
container=podinfo,job=podinfo,namespace=shop,pod=podinfo-68d7484f5-hrzrs = 1Break it: a target that silently disappears
A ServiceMonitor that asks for port web, while the Service calls its port http. Nothing fails loudly:
# A ServiceMonitor with a typo: the port is called "web", but the Service calls it "http"
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata: {name: podinfo, namespace: shop}
spec:
selector: {matchLabels: {app: podinfo}}
endpoints: [{port: web, interval: 15s}]# Break it: a ServiceMonitor with the wrong port name. No error anywhere, the targets just vanish (watch for up to 5 minutes)
kubectl apply -f sm-broken.yaml
for i in $(seq 1 20); do sleep 15; N=$(curl -s http://localhost:9090/api/v1/targets | jq '[.data.activeTargets[] | select(.labels.namespace=="shop")] | length'); echo "after $((i*15))s: podinfo targets $N"; [ "$N" = 0 ] && break; doneservicemonitor.monitoring.coreos.com/podinfo configured
after 15s: podinfo targets 2
after 30s: podinfo targets 2
after 45s: podinfo targets 2
after 60s: podinfo targets 2
after 75s: podinfo targets 2
after 90s: podinfo targets 2
after 105s: podinfo targets 2
after 120s: podinfo targets 0For 105 seconds nothing changed, then both targets were gone. No error, no up = 0 (the target is not "down", it no longer exists). This is why teams also alert on "a job has no targets" (absent(up{job="podinfo"})).
Fix it
Compare the port name in the Service with the one in the ServiceMonitor, then apply the correct ServiceMonitor:
# Fix it: compare the port name in the Service with the one in the ServiceMonitor, then correct it
echo "Service port name: $(kubectl -n shop get svc podinfo -o jsonpath='{.spec.ports[0].name}'), ServiceMonitor asks for: $(kubectl -n shop get servicemonitor podinfo -o jsonpath='{.spec.endpoints[0].port}')"
kubectl apply -f servicemonitor.yaml
for i in $(seq 1 20); do sleep 15; N=$(curl -s http://localhost:9090/api/v1/targets | jq '[.data.activeTargets[] | select(.labels.namespace=="shop" and .health=="up")] | length'); echo "after $((i*15))s: podinfo targets up $N"; [ "$N" = 2 ] && break; doneService port name: http, ServiceMonitor asks for: web
servicemonitor.monitoring.coreos.com/podinfo configured
after 15s: podinfo targets up 0
after 30s: podinfo targets up 0
after 45s: podinfo targets up 0
after 60s: podinfo targets up 0
after 75s: podinfo targets up 0
after 90s: podinfo targets up 0
after 105s: podinfo targets up 0
after 120s: podinfo targets up 0
after 135s: podinfo targets up 0
after 150s: podinfo targets up 0
after 165s: podinfo targets up 2Both targets were back after about 165 seconds. Lesson for the interview: config changes in Prometheus are not instant; the Operator updates the config and Prometheus reloads it.

Q10 and Q11. SLI, SLO and error budget
Answer: the SLI is the measurement (share of good requests), the SLO is the goal (99 percent over 30 days), the error budget is what you may fail (1 percent). The burn rate says how fast you spend it: 1 means the budget lasts exactly the 30 days; 14.4 means it is gone in about 2 days.
Proof: the SLI over the last 10 minutes and the burn rate against a 99 percent SLO:
# Q10 and Q11. SLI, SLO and error budget: availability over the last 10 minutes against a 99 percent goal
./q.sh '100 * sum(rate(http_request_duration_seconds_count{namespace="shop",status!~"5.."}[10m])) / sum(rate(http_request_duration_seconds_count{namespace="shop"}[10m]))' | sed 's/^value/SLI: percent of good requests/'
./q.sh '(1 - sum(rate(http_request_duration_seconds_count{namespace="shop",status!~"5.."}[10m])) / sum(rate(http_request_duration_seconds_count{namespace="shop"}[10m]))) / 0.01' | sed 's/^value/burn rate (1 = budget used exactly on time)/'SLI: percent of good requests = 100
burn rate (1 = budget used exactly on time) = 0Q12 and Q13. How do you alert, and on what?
Answer: alert on symptoms users feel (errors, latency), not on causes (CPU is high). Use for: so a short spike does not page anyone. An alert goes inactive, then pending (condition true, waiting for for), then firing.
Proof: our rule fires when more than 5 percent of requests fail for 1 minute. Save it as rule.yaml:
# An alert on a symptom users feel: more than 5 percent of requests fail, for 1 minute
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata: {name: podinfo, namespace: shop}
spec:
groups:
- name: podinfo
rules:
- alert: PodinfoHighErrorRate
expr: 100 * (sum(rate(http_request_duration_seconds_count{namespace="shop",status=~"5.."}[1m])) or vector(0)) / sum(rate(http_request_duration_seconds_count{namespace="shop"}[1m])) > 5
for: 1m
labels: {severity: page}
annotations: {summary: "More than 5 percent of podinfo requests fail"}Then we make the load pod call a page that always fails:
# Q12 and Q13. An alert on a symptom, with "for: 1m". Make the app fail and watch inactive, pending, firing
kubectl apply -f rule.yaml; sleep 45
kubectl -n shop set env deploy/load -c load ERROR_PATH=/status/500 > /dev/null
for i in $(seq 1 20); do S=$(curl -s http://localhost:9090/api/v1/alerts | jq -r '[.data.alerts[] | select(.labels.alertname=="PodinfoHighErrorRate") | .state][0] // "inactive"'); echo "after $((i*15))s: $S"; [ "$S" = firing ] && break; sleep 15; done
kubectl -n shop set env deploy/load -c load ERROR_PATH- > /dev/null; echo "bad calls stopped"prometheusrule.monitoring.coreos.com/podinfo created
after 15s: inactive
after 30s: inactive
after 45s: inactive
after 60s: pending
after 75s: pending
after 90s: pending
after 105s: pending
after 120s: firing
bad calls stoppedQ14. Why structured logs?
Answer: logs as JSON have fields (level, msg, ts), so tools can filter and count by field instead of guessing with grep.
Proof: podinfo writes JSON; jq counts lines by level and picks fields:
# Q14. Structured logs: podinfo writes JSON lines, so a tool can filter by field instead of guessing with grep
kubectl -n shop logs deploy/podinfo --tail=500 | grep '^{' | jq -r 'select(.level != null) | .level' | sort | uniq -c
kubectl -n shop logs deploy/podinfo --tail=500 | grep '^{' | jq -c 'select(.level == "info") | {ts, level, msg}' | head -2 | cut -c1-140Found 2 pods, using pod/podinfo-68d7484f5-mwh99
2 info
Found 2 pods, using pod/podinfo-68d7484f5-mwh99
{"ts":"2026-11-19T07:02:44.544Z","level":"info","msg":"Starting podinfo"}
{"ts":"2026-11-19T07:02:44.546Z","level":"info","msg":"Starting HTTP Server."}podinfo logs very little (only its start-up lines), which is itself a lesson: decide what your app should log.
Q15. Where are metrics stored, and for how long?
Answer: Prometheus keeps samples on its local disk in its TSDB (time-series database) for its retention time, then deletes them. Long-term storage needs a remote store (Thanos, Mimir, or a managed service).
Proof:
# Q15. Where do the samples live and for how long? The TSDB settings and size
curl -s http://localhost:9090/api/v1/status/flags | jq -r '.data | "retention: " + ."storage.tsdb.retention.time" + ", data folder: " + ."storage.tsdb.path"'
curl -s http://localhost:9090/api/v1/status/runtimeinfo | jq -r '.data | "storage retention: " + .storageRetention'
curl -s http://localhost:9090/api/v1/status/tsdb | jq -r '"head block from " + (.data.headStats.minTime / 1000 | todate) + ", chunks " + (.data.headStats.chunkCount | tostring)'retention: 6h, data folder: /prometheus
storage retention: 6h
head block from 2026-11-19T07:03:21Z, chunks 116829
Clean up (delete everything)
# Clean up: Prometheus, the app and the Prometheus Operator types
pkill -f "[p]ort-forward svc/monitoring"
helm uninstall monitoring -n monitoring --wait 2>&1 | tail -1
kubectl delete namespace shop monitoring --wait=true 2>&1 | tail -2
kubectl get crd -o name | grep monitoring.coreos.com | xargs -r kubectl delete > /dev/null && echo "Prometheus Operator types removed"
echo "namespaces left from this lab: $(kubectl get ns shop monitoring --no-headers 2>/dev/null | wc -l)"release "monitoring" uninstalled
namespace "shop" deleted
namespace "monitoring" deleted
Prometheus Operator types removed
namespaces left from this lab: 0When you have finished all your Kubernetes labs, delete the cluster:
gcloud container clusters delete lab-cluster --zone=us-east1-b --quietQuick answers to remember
| Question | One-line answer | Proved in |
|---|---|---|
| Metrics, logs, traces | Numbers for alerts, lines for details, traces for the path of one request | Q1 |
| Counter or gauge | Counter only goes up; gauge goes both ways | Q2 |
| Why rate() | Raw totals jump on restarts; rate is per second | Q3 |
| Why p99 | The average hid 1-second requests | Q4 Q5 |
| RED and USE | Rate, Errors, Duration for services; Utilisation, Saturation, Errors for resources | Q6 |
| Cardinality | Each label combination is a series; endless values break Prometheus | Q7 |
| Discovery and up | ServiceMonitor picks targets; up is 1 or 0 per target | Q8 Q9 |
| SLO and budget | Goal, allowed failure, burn rate | Q10 Q11 |
| Alerting | Symptoms, with for, inactive to pending to firing | Q12 Q13 |
| Structured logs | Fields you can filter | Q14 |
| Storage | Local TSDB with retention; remote store for long term | Q15 |
What next
- Build the stack step by step: Prometheus and Grafana on Kubernetes from Scratch.
- See monitoring around a real deployment: MLOps for Beginners: From Notebook to Production.
- More hands-on posts: ByteBlog. Practice in ByteLabs and see the courses.
Prepared by the CareerByteCode Team from our tested lab, with AI help for the write-up.
⭐ Keep learning with CareerByteCode
Hand-picked to go deeper on this topicGet CareerByteCode Team's next blog by email
One email a week when they publish. Add the weekly Best of ByteBlog too. No spam, unsubscribe with one click.
We email you once to confirm. By subscribing you agree to the privacy policy.
Related blogs
CareerByteCode TeamAlertmanager: Route Alerts to Email, Slack and On-Call
What you build: Alertmanager on GKE with routing, grouping, silences and inhibition tested, a case typo that misroutes a page, and a hot-reload fix. Every step tested.
#google
CareerByteCode TeamGoogle Cloud Managed Prometheus: No Servers to Run
What you build: Prometheus metrics from a GKE app in Google Cloud Managed Service for Prometheus with one PodMonitoring, PromQL queries and a silent typo found. Every step tested.
#google-cloud
CareerByteCode TeamLogs to BigQuery: Analyse a Month of Logs with SQL
What you build: a log sink from Cloud Logging to BigQuery and four SQL reports on a month of web traffic, errors and slow pages, in your own Google Cloud account. Every step tested.
#google-cloud
CareerByteCode TeamOpenTelemetry for Beginners: Traces, Metrics and Logs
What you build: an instrumented app sending traces to Cloud Trace, in your own Google Cloud account. Every step, command and screenshot explained for intermediates.
💬 Comments (0)
Top · NewestSign in to comment