Pregunta-li avui a la Marta com sap que la botiga d'AlpinaShop funciona. La resposta honesta és: perquè ningú no s'ha queixat. I si alguna cosa va malament, se n'assabenta d'una d'aquestes tres maneres: un client escriu a atenció al client, en Dani obre el web per casualitat i el nota lent, o la Lucía veu l'endemà que les vendes d'ahir van ser estranyes.
Les tres tenen el mateix defecte: la detecció la fa una persona, tard i per casualitat. I el cost d'aquella manera d'assabentar-se és alt i silenciós. Un incident de vint minuts en plena campanya de tardor pot passar completament desapercebut i endur-se per davant centenars de comandes.
Aquesta lliçó canvia això. En acabar, AlpinaShop tindrà un tauler que mostra l'estat de la botiga d'un cop d'ull, comprovacions que la vigilen des de quatre continents, alertes que arriben al mòbil de la Marta abans que cap client escrigui, i un agrupador automàtic d'excepcions que avisa quan un desplegament introdueix un error nou.
Una nota prèvia sobre el nom. Stackdriver va ser una empresa que Google va adquirir el 2014 i el producte de la qual va donar origen a tota la suite d'operacions. El nom es va retirar el 2020 i avui els serveis es diuen Cloud Monitoring, Cloud Logging, Cloud Trace, Cloud Profiler i Error Reporting. Veuràs "Stackdriver" en documentació antiga, en noms de biblioteques heretades i en converses de gent amb certa veterania; convé reconèixer-lo, però és un nom històric.
Contingut
- Observabilitat i els seus tres pilars
- El model de dades de mètriques
- L'espai de mètriques: veure els tres projectes alhora
- Mètriques de plataforma que ja tens gratis
- Explorar: alineadors, agregacions i per què la mitjana menteix
- El tauler de la campanya de tardor
- El tauler com a JSON versionable
- MQL i PromQL per a consultes avançades
- Alertes: anatomia d'una política
- Canals de notificació i les tres alertes d'AlpinaShop
- Fatiga d'alertes: la conversa incòmoda
- Mètriques personalitzades des de l'aplicació
- Comprovacions de disponibilitat
- Error Reporting: excepcions agrupades
- L'agent d'operacions a les VM del MIG
- Cost de l'observabilitat
- Observabilitat i els seus tres pilars
Monitoratge és comprovar si les coses que sabies que podien fallar estan fallant. Observabilitat és la propietat d'un sistema que permet entendre què li està passant per dins a partir del que emet cap a fora, incloses les fallades que no vas anticipar.
La diferència no és acadèmica. Un tauler amb la CPU de les VM és monitoratge: respon a "està alta la CPU?". Poder respondre a "per què els clients de Canàries tenen el checkout lent des de dimarts?" sense desplegar res nou és observabilitat.
Es recolza en tres pilars:
| Pilar | Què respon | Naturalesa | Servei | Lliçó |
|---|---|---|---|---|
| Mètriques | Quant? Quants? Quina tendència? | Nombres agregats en el temps | Cloud Monitoring | Aquesta |
| Registres | Què va passar exactament en aquest cas? | Esdeveniments discrets amb detall | Cloud Logging | 06-06 |
| Traces | On se'n va anar el temps en aquesta petició? | Recorregut entre components | Cloud Trace | 06-06 |
Cadascun té un perfil diferent de cost i d'utilitat, i per això conviuen:
- Les mètriques són barates d'emmagatzemar i consultar perquè són agregats, permeten veure mesos d'història i són la base natural de les alertes. Però no et diuen què li va passar a un client concret: et diuen que el p95 va pujar.
- Els registres tenen tot el detall de cada esdeveniment, i per això són cars i cal ser selectiu. Responen preguntes concretes sobre casos concrets.
- Les traces mostren com es reparteix el temps d'una petició entre serveis, i són l'única cosa que respon a "qui està trigant?" en un sistema amb diverses peces.
El recorregut típic d'un incident els utilitza tots tres en ordre: una alerta sobre una mètrica avisa que passa alguna cosa, el tauler de mètriques acota què i on, els registres diuen què està fallant exactament, i la traça explica per què. Aquell recorregut complet es fa de principi a fi a 06-06.
Un avís d'abast: aquí es construeixen mètriques, taulers i alertes. Els objectius de nivell de servei (SLO) i els pressupostos d'error —definir formalment què significa "funcionar bé" i quanta fallada és tolerable— arriben a 07-06. Aquí s'instal·len els instruments; allà es decideix quins nombres són acceptables.
- El model de dades de mètriques
Gairebé tots els problemes que la gent té amb Cloud Monitoring vénen de no tenir clar aquest model. Mereix cinc minuts.
Una sèrie temporal és la unitat fonamental, i s'identifica per la combinació de tres coses:
| Component | Què és | Exemple |
|---|---|---|
| Tipus de mètrica | Què es mesura | loadbalancing.googleapis.com/https/request_count |
| Recurs monitorat | Quin objecte l'emet | https_lb_rule amb el seu projecte i el seu nom |
| Etiquetes | Dimensions per filtrar i agrupar | response_code_class="500", matched_url_path_rule="/catalogo" |
| Punts | Parells (instant, valor) | (2026-08-05T10:00:00Z, 142) |
Aquell disseny explica una cosa que sorprèn al principi: el nombre de sèries temporals es multiplica amb les etiquetes. Si una mètrica té 3 classes de codi de resposta, 5 rutes i 2 regions, són 30 sèries. Si algú afegeix una etiqueta amb l'identificador de client, i hi ha 50.000 clients, són 1.500.000 sèries. Això s'anomena explosió de cardinalitat, es paga i pot arribar a fer inutilitzable la mètrica. Hi tornarem a l'apartat 12, que és on es comet l'error.
Els tres tipus de mètrica
Distingir-los és imprescindible perquè cadascun es consulta de manera diferent:
| Tipus | Què representa | Exemple | Com es consulta |
|---|---|---|---|
| Mesurador (gauge) | Un valor instantani que puja i baixa | CPU al 42 %, 87 connexions obertes | Es llegeix directament |
| Comptador acumulat (cumulative) | Un total que només creix des d'un origen | Peticions totals servides | Cal derivar-lo: taxa per segon |
| Distribució (distribution) | Un histograma de valors en un interval | Latències de totes les peticions | S'extreuen percentils |
El comptador és el que més confusió causa. request_count del balancejador és acumulat: el seu valor creix indefinidament. Si el pintes tal qual, veus una rampa ascendent que no diu res. El que vols és la taxa: quantes peticions per segon. Per això als comptadors se'ls aplica sempre un alineador rate o delta.
La distribució és la més valuosa i la més desaprofitada. Una mètrica de latència com a distribució no guarda un nombre per interval: guarda un histograma complet. Això permet preguntar el percentil 50, el 95 i el 99 a posteriori, sense haver decidit per endavant quin t'interessava. Si en el seu lloc guardessis només la latència mitjana, hauries perdut la informació per sempre, i la mitjana és precisament l'estadístic menys útil aquí, com veurem a l'apartat 5.
- L'espai de mètriques: veure els tres projectes alhora
AlpinaShop té els seus recursos repartits en tres projectes: la botiga a alpinashop-prod, les proves a alpinashop-dev i l'analítica a alpinashop-datos. Per defecte, cada projecte té la seva pròpia vista de mètriques, cosa que obliga a saltar entre tres consoles per entendre un incident. Insostenible.
Un espai de mètriques (metrics scope) resol això: un projecte actua de projecte d'àmbit i agrega les mètriques de diversos projectes monitorats.
flowchart TD
A[alpinashop-prod<br/>PROJECTE D'ÀMBIT] --> D[Espai de mètriques únic:<br/>taulers i alertes dels tres]
B[alpinashop-dev] --> D
C[alpinashop-datos] --> D
# Afegir els altres dos projectes a l'espai de mètriques d'alpinashop-prod
gcloud beta monitoring metrics-scopes create \
--monitored-project=alpinashop-dev \
--project=alpinashop-prod
gcloud beta monitoring metrics-scopes create \
--monitored-project=alpinashop-datos \
--project=alpinashop-prodUn detall de disseny que convé pensar abans d'executar: quin ha de ser el projecte d'àmbit? Utilitzar alpinashop-prod és el més habitual i el més simple. L'alternativa —crear un projecte dedicat, per exemple alpinashop-observabilidad— és més neta conceptualment perquè separa "operar la plataforma" de "ser la plataforma", i permet donar accés de lectura a les mètriques sense donar cap accés a producció. Per a AlpinaShop, amb tres projectes i tres persones, alpinashop-prod és suficient; en una organització amb vint projectes, el projecte dedicat guanya clarament.
I un advertiment important: l'espai de mètriques unifica la vista, no els permisos. Qui consulta un tauler que mostra mètriques d'alpinashop-datos necessita permisos de lectura de monitoratge sobre aquell projecte. És coherent amb 03-04, i evita que agregar la vista es converteixi en una via indirecta d'exposar informació.
- Mètriques de plataforma que ja tens gratis
Aquí hi ha una bona notícia que molta gent desconeix: GCP ja està recollint centenars de mètriques dels teus recursos, sense que hagis fet res i sense cost afegit. Tota la infraestructura dels mòduls 2, 3 i 4 porta mesos emetent dades que ningú no ha mirat.
Les que importen per a AlpinaShop:
| Recurs | Mètrica | Què indica |
|---|---|---|
| Balancejador | https/request_count |
Peticions per segon, amb classe de codi |
| Balancejador | https/total_latencies |
Latència extrem a extrem (distribució) |
| Balancejador | https/backend_latencies |
Latència només del backend |
| Balancejador | https/backend_request_count |
Peticions que arriben al backend (davant de CDN) |
| Compute Engine / MIG | instance/cpu/utilization |
Saturació de CPU |
| Compute Engine | instance/disk/read_ops_count |
Pressió de disc |
| Cloud SQL | database/cpu/utilization |
CPU d'alpinashop-pedidos |
| Cloud SQL | database/network/connections |
Connexions obertes |
| Cloud SQL | database/disk/utilization |
Espai ocupat |
| Cloud SQL | database/replication/replica_lag |
Retard de la rèplica |
| Pub/Sub | subscription/num_undelivered_messages |
Missatges sense confirmar |
| Pub/Sub | subscription/oldest_unacked_message_age |
Antiguitat del més vell |
| BigQuery | query/scanned_bytes |
Bytes processats: cost directe |
| GKE | container/cpu/limit_utilization |
Ús davant del límit |
| Cloud Functions | function/execution_count |
Invocacions (recorda 06-03) |
| Cloud Functions | function/execution_times |
Durada (distribució) |
| Cloud Run | request_count, request_latencies |
Igual que el balancejador |
| Cloud CDN | https/request_count filtrat per cache_result |
Ràtio d'encerts |
La taula que de debò s'utilitza en un incident és la inversa: del símptoma a la mètrica.
| Símptoma observat | Mètrica que cal mirar | Què significa si està malament |
|---|---|---|
| "El web va lent" | https/total_latencies p95 i p99 |
Confirma o desmenteix la percepció |
| "Va lent" i el backend està bé | Comparar total_latencies amb backend_latencies |
Si difereixen molt, el problema és de xarxa o de client |
| Errors 500 | https/request_count filtrat response_code_class=500 |
Quants i des de quan |
| Lentitud + CPU alta al MIG | instance/cpu/utilization |
Falta capacitat: revisar l'autoescalat |
| Lentitud + CPU baixa a tot arreu | database/network/connections |
Probable esgotament del pool de connexions |
| Errors després d'un desplegament | request_count 5xx + Error Reporting |
Regressió introduïda pel desplegament |
| Dades analítiques desactualitzades | num_undelivered_messages |
El consumidor no dona l'abast o està caigut |
| Factura de BigQuery alta | query/scanned_bytes per usuari |
Algú fa SELECT * sobre l'històric |
| Factura de xarxa alta | https/request_count per cache_result |
La ràtio d'encerts de CDN ha caigut |
Aquella última fila connecta directament amb 03-03: si la ràtio d'encerts de Cloud CDN cau, el trànsit va al backend, la factura de sortida puja i la latència empitjora. És una fallada silenciosa perfecta —res no es trenca, tot es degrada— i només es detecta mirant la mètrica.
- Explorar: alineadors, agregacions i per què la mitjana menteix
L'explorador de mètriques és l'eina de consulta interactiva. El seu model té quatre passos i convé entendre'ls perquè són els mateixos que després apareixen a taulers i alertes.
flowchart LR
A[1. Seleccionar<br/>mètrica i recurs] --> B[2. Filtrar<br/>per etiquetes]
B --> C[3. ALINEAR<br/>dins de cada sèrie]
C --> D[4. AGREGAR<br/>entre sèries]
D --> E[Gràfic]
Alinear converteix els punts crus de cada sèrie en punts regulars d'un interval fix. Agregar combina diverses sèries en menys sèries o en una de sola. L'ordre importa i confondre'ls produeix nombres sense sentit.
| Alineador | Què fa | Per a quin tipus | Exemple |
|---|---|---|---|
rate |
Variació per segon | Comptadors | Peticions per segon |
delta |
Diferència a l'interval | Comptadors | Peticions en 60 s |
mean |
Mitjana de l'interval | Mesuradors | CPU mitjana per minut |
max / min |
Extrems de l'interval | Mesuradors | Pic de connexions |
percentile_95 |
Percentil dins de l'interval | Distribucions | Latència p95 |
| Agregació | Què fa | Exemple |
|---|---|---|
sum |
Suma entre sèries | Total de peticions de totes les instàncies |
mean |
Mitjana entre sèries | CPU mitjana del MIG |
max |
Màxim entre sèries | La instància més carregada |
count |
Quantes sèries hi ha | Nombre d'instàncies vives |
| Agrupar per etiqueta | Una sèrie per valor | Latència per ruta |
Per què la mitjana menteix
Aquest és el concepte més important de l'apartat, i probablement el que més vegades s'explica malament al sector.
Imagina 1.000 peticions al catàleg en un minut. 950 triguen 100 ms i 50 triguen 8 segons. La mitjana és:
Un tauler amb la mitjana mostra 495 ms. Sembla acceptable. I tanmateix 50 clients per minut estan esperant vuit segons, que és temps de sobres per anar-se'n a un altre web. La mitjana ha ocultat exactament el problema que buscaves.
Els percentils expliquen una altra història:
| Estadístic | Valor | Què significa de debò |
|---|---|---|
| Mitjana | 495 ms | Un nombre que no li passa a ningú |
| p50 (mediana) | 100 ms | La meitat dels clients veuen això |
| p95 | ~100 ms | El 95 % està bé |
| p99 | 8.000 ms | L'1 % pitjor pateix 8 segons |
Tres regles pràctiques que convé adoptar sense excepcions:
- Per a latència, sempre percentils, mai mitjana. El p50 diu com és l'experiència típica; el p95 i el p99 diuen com de malament està el dolent.
- No promitgis mai percentils entre sèries. La mitjana dels p95 de deu instàncies no és el p95 del conjunt: és un nombre sense significat estadístic. Cloud Monitoring calcula el percentil sobre la distribució combinada si li demanes
percentile_95com a alineador isumcom a agregació de distribucions; fer-ho al revés produeix escombraries. - El p99 importa més del que el seu nom suggereix. Amb un milió de peticions al dia, el p99 són 10.000 peticions. I no toquen a l'atzar a 10.000 clients diferents: solen concentrar-se en els que tenen cistelles grans o històrics llargs, és a dir, els millors clients.
- El tauler de la campanya de tardor
La campanya de tardor és el pic comercial d'AlpinaShop. La Marta vol una pantalla que respongui d'un cop d'ull a "està bé la botiga?".
El principi de disseny, importat de la pràctica d'SRE: un tauler ha d'explicar una història de dalt a baix, començant pel que percep el client i acabant per les causes tècniques. Si en mirar-lo cal pensar, el tauler està malament.
| Fila | Gràfic | Mètrica | Per què hi és |
|---|---|---|---|
| 1. Arriba trànsit? | Peticions/s | https/request_count amb rate i sum |
Un enfonsament és tan greu com un pic |
| 1 | Taxa d'error 5xx | request_count filtrat / total |
L'indicador més directe de dolor |
| 2. És ràpid? | Latència p50/p95/p99 | https/total_latencies |
Tres línies al mateix gràfic |
| 2 | Latència per ruta | Igual, agrupat per matched_url_path_rule |
Aïlla quina part va lenta |
| 3. Aguanta? | CPU del MIG | instance/cpu/utilization, mean i max |
La mitjana oculta la instància calenta |
| 3 | Instàncies actives | count de sèries del MIG |
Està escalant? |
| 4. I la BD? | Connexions a Cloud SQL | database/network/connections |
Causa habitual de lentitud sense CPU |
| 4 | CPU de Cloud SQL | database/cpu/utilization |
Consultes pesades |
| 5. I la CDN? | Ràtio d'encerts | request_count per cache_result |
Cost i latència |
| 5 | Bytes servits | https/response_bytes_count |
Detecta canvis de patró |
Dues decisions de disseny que mereixen explicació.
La CPU del MIG es mostra dues vegades, mean i max. Si deu instàncies estan al 20 % i una al 98 %, la mitjana diu 27 % —aparentment sa— mentre aquella instància està saturada i servint peticions lentíssimes. És el mateix error conceptual que promitjar latències, aplicat a la capacitat. La mitjana oculta els desequilibris; el màxim els delata.
Latència i errors són a dalt, la infraestructura a baix. L'ordre reflecteix la pregunta que es fa de debò en un incident: primer "pateixen els clients?" i només després "per què?". Un tauler que comença per la CPU convida a mirar mètriques d'infraestructura que poden estar perfectes mentre la botiga està caiguda.
- El tauler com a JSON versionable
Un tauler construït a clics a la consola és un actiu fràgil: ningú no sap qui el va canviar, no es pot replicar en un altre projecte i desapareix si algú l'esborra. Tot tauler de Cloud Monitoring té una representació en JSON que es pot exportar, versionar a Git —seguint 06-02— i recrear.
# Exportar un tauler existent
gcloud monitoring dashboards list --project=alpinashop-prod --format=json
gcloud monitoring dashboards describe DASHBOARD_ID \
--project=alpinashop-prod --format=json > paneles/campana-otono.json
# Crear o actualitzar des del fitxer
gcloud monitoring dashboards create --config-from-file=paneles/campana-otono.json \
--project=alpinashop-prodUn fragment amb els dos gràfics de la fila 1, que mostra l'estructura sense aclaparar:
{
"displayName": "AlpinaShop - Campanya de tardor",
"mosaicLayout": {
"columns": 12,
"tiles": [
{
"width": 6, "height": 4, "xPos": 0, "yPos": 0,
"widget": {
"title": "Peticions per segon",
"xyChart": {
"dataSets": [{
"timeSeriesQuery": {
"timeSeriesFilter": {
"filter": "metric.type=\"loadbalancing.googleapis.com/https/request_count\" resource.type=\"https_lb_rule\" resource.label.\"url_map_name\"=\"alpinashop-url-map\"",
"aggregation": {
"alignmentPeriod": "60s",
"perSeriesAligner": "ALIGN_RATE",
"crossSeriesReducer": "REDUCE_SUM"
}
}
},
"plotType": "LINE"
}]
}
}
},
{
"width": 6, "height": 4, "xPos": 6, "yPos": 0,
"widget": {
"title": "Latència p50 / p95 / p99 (ms)",
"xyChart": {
"dataSets": [
{
"legendTemplate": "p50",
"timeSeriesQuery": {
"timeSeriesFilter": {
"filter": "metric.type=\"loadbalancing.googleapis.com/https/total_latencies\" resource.type=\"https_lb_rule\"",
"aggregation": {
"alignmentPeriod": "60s",
"perSeriesAligner": "ALIGN_PERCENTILE_50",
"crossSeriesReducer": "REDUCE_MEAN"
}
}
},
"plotType": "LINE"
},
{
"legendTemplate": "p99",
"timeSeriesQuery": {
"timeSeriesFilter": {
"filter": "metric.type=\"loadbalancing.googleapis.com/https/total_latencies\" resource.type=\"https_lb_rule\"",
"aggregation": {
"alignmentPeriod": "60s",
"perSeriesAligner": "ALIGN_PERCENTILE_99",
"crossSeriesReducer": "REDUCE_MEAN"
}
}
},
"plotType": "LINE"
}
]
}
}
}
]
}
}Fixa't en la correspondència amb l'apartat 5: perSeriesAligner és l'alineador —ALIGN_RATE per al comptador, ALIGN_PERCENTILE_99 per a la distribució— i crossSeriesReducer és l'agregació. El JSON no és més que la forma escrita del que vas fer a l'explorador.
La manera pràctica de treballar és construir el tauler a la consola fins que quedi bé, exportar-lo, guardar-lo a alpinashop-infra/paneles/ i a partir d'aquí gestionar-lo com a codi. I quan arribi Terraform a 06-07, el recurs google_monitoring_dashboard consumeix exactament aquest JSON, de manera que el tauler passa a crear-se al costat de la infraestructura que monitora.
- MQL i PromQL per a consultes avançades
La interfície de filtres i agregacions cobreix la majoria dels casos, però hi ha preguntes que no expressa: proporcions entre dues mètriques, unions, càlculs derivats. Per a això hi ha dos llenguatges.
MQL (Monitoring Query Language) és el llenguatge propi de Cloud Monitoring, amb sintaxi de canonada:
fetch https_lb_rule | metric 'loadbalancing.googleapis.com/https/request_count' | filter resource.url_map_name == 'alpinashop-url-map' | align rate(1m) | every 1m | group_by [metric.response_code_class], [valor: sum(value.request_count)]
I el cas on MQL es torna imprescindible, la taxa d'error com a proporció:
{
fetch https_lb_rule :: loadbalancing.googleapis.com/https/request_count
| filter metric.response_code_class == '500'
| align rate(1m) | every 1m | group_by [], [errors: sum(value.request_count)]
;
fetch https_lb_rule :: loadbalancing.googleapis.com/https/request_count
| align rate(1m) | every 1m | group_by [], [total: sum(value.request_count)]
}
| join
| value [taxa_error: errors / total * 100]Això —dividir dues sèries diferents— no es pot expressar amb filtres i agregacions. I és just el que vols per alertar: el 2 % d'errors és el rellevant, no "200 errors", perquè 200 errors sobre 100.000 peticions és soroll i sobre 500 és una catàstrofe.
PromQL és el llenguatge de Prometheus, suportat a Cloud Monitoring a través de Managed Service for Prometheus. La mateixa consulta:
sum(rate(loadbalancer_googleapis_com:https_request_count{response_code_class="500"}[1m]))
/
sum(rate(loadbalancer_googleapis_com:https_request_count[1m])) * 100| Criteri | MQL | PromQL |
|---|---|---|
| Abast | Només GCP | Estàndard del sector |
| Portabilitat | Cap | Alta: Prometheus, Grafana, altres núvols |
| Mètriques de GKE | Funciona | Natural: és el que emeten les aplicacions |
| Comunitat i exemples | Limitada | Enorme |
| Recomanació 2026 | Per a casos puntuals a GCP | Preferible si véns de Kubernetes |
Per a AlpinaShop, que té la botiga a GKE i aspira a no lligar-se en excés a un proveïdor, PromQL és l'aposta més assenyada a mitjà termini. MQL continua sent útil per a consultes puntuals sobre mètriques de plataforma que no tenen equivalent Prometheus.
- Alertes: anatomia d'una política
Un tauler només serveix si algú el mira. Una alerta treballa per tu.
Una política d'alerta té quatre peces, i cadascuna respon a una pregunta diferent:
flowchart LR
A[CONDICIÓ<br/>què mesurar i quin llindar] --> B[DURADA<br/>quant temps malament]
B --> C[AGREGACIÓ<br/>sobre quin conjunt]
C --> D[NOTIFICACIÓ<br/>a qui i com]
D --> E[DOCUMENTACIÓ<br/>què fer en rebre-la]
La durada és la peça més infravalorada. Sense ella, qualsevol pic instantani dispara una alerta. Un pic de latència de 15 segons perquè l'autoescalador va arrencar una instància no és un incident: és el sistema funcionant. Una alerta que salta per això ensenya l'equip a ignorar-la, que és el pitjor que li pot passar a una alerta.
El criteri per triar la durada és honest i senzill: quant temps ha d'estar malament això perquè mereixi despertar algú? Si la resposta és "cinc minuts", posa cinc minuts.
Una política completa en JSON, la de la taxa d'error d'AlpinaShop:
{
"displayName": "AlpinaShop - Taxa d'error 5xx elevada",
"combiner": "OR",
"conditions": [
{
"displayName": "Errors 5xx per damunt del 2% durant 5 minuts",
"conditionMonitoringQueryLanguage": {
"query": "{ fetch https_lb_rule :: loadbalancing.googleapis.com/https/request_count | filter metric.response_code_class == '500' | align rate(1m) | every 1m | group_by [], [e: sum(value.request_count)] ; fetch https_lb_rule :: loadbalancing.googleapis.com/https/request_count | align rate(1m) | every 1m | group_by [], [t: sum(value.request_count)] } | join | value [taxa: e / t * 100] | condition taxa > 2 '%'",
"duration": "300s",
"trigger": { "count": 1 }
}
}
],
"alertStrategy": {
"autoClose": "1800s"
},
"notificationChannels": [
"projects/alpinashop-prod/notificationChannels/CANAL_SLACK_ALERTAS",
"projects/alpinashop-prod/notificationChannels/CANAL_CORREO_INFRA"
],
"documentation": {
"mimeType": "text/markdown",
"content": "## Taxa d'error 5xx elevada\n\n**Què significa:** més del 2 % de les peticions a la botiga retornen error de servidor.\n\n**Impacte:** els clients veuen pàgines d'error. S'estan perdent comandes.\n\n**Primers passos:**\n1. Tauler *Campanya de tardor*: la latència també ha pujat?\n2. Hi va haver un desplegament en els últims 30 minuts? Revisar Cloud Build.\n3. Explorador de registres: `severity=ERROR` en els últims 15 minuts (06-06).\n4. Comprovar connexions de Cloud SQL: causa freqüent.\n\n**Reversió:** promocionar la imatge anterior amb el pipeline de 06-01.\n\n**Escalat:** si en 15 minuts no hi ha diagnòstic, avisar la Marta."
}
}gcloud alpha monitoring policies create \
--policy-from-file=alertas/tasa-error-5xx.json \
--project=alpinashop-prodEl camp documentation és el que separa una alerta útil d'una alerta que genera ansietat. Arriba al mòbil d'algú a les onze de la nit; sense instruccions, aquella persona comença des de zero, amb son i amb pressa. Amb les quatre primeres comprovacions escrites, sap què mirar. I l'autoClose de 30 minuts evita que un incident ja resolt deixi un incident obert per sempre.
- Canals de notificació i les tres alertes d'AlpinaShop
Un canal defineix com arriba l'alerta:
| Canal | Latència | Interromp | Ús a AlpinaShop |
|---|---|---|---|
| Correu | Minuts | No | Avisos informatius, resums |
| Slack | Segons | Poc | Canal #alpinashop-alertas, el principal |
| SMS | Segons | Sí | Només per al que és crític |
| PagerDuty / Opsgenie | Segons | Sí, amb escalat | Quan hi hagi guàrdies formals (07-06) |
| Webhook | Segons | Depèn | Automatitzacions pròpies |
| Pub/Sub | Segons | No | Reaccionar amb una funció (06-03) |
gcloud beta monitoring channels create \
--display-name="Slack alertes AlpinaShop" \
--type=slack \
--channel-labels=channel_name="#alpinashop-alertas" \
--project=alpinashop-prodEl canal de Pub/Sub mereix una menció pel que habilita: una alerta pot publicar en un topic i una Cloud Function de 06-03 pot reaccionar automàticament —crear una incidència, executar un diagnòstic, o fins i tot una acció correctora acotada—. És la porta a la resposta automàtica, amb la precaució evident que una automatització que actua sobre producció ha d'estar molt ben acotada.
Les tres alertes amb què arrenca AlpinaShop
Deliberadament tres. No trenta.
Alerta 1 — Taxa d'error 5xx > 2 % durant 5 minuts. Canal: Slack + SMS a la Marta.
Raonament del llindar: la taxa d'error normal de la botiga és del 0,1-0,3 %, dominada per peticions a URL que ja no existeixen. El 2 % és un ordre de magnitud per damunt del soroll: no salta per variació natural, i a aquell nivell hi ha clients veient errors. És proporció, no valor absolut, pel que s'ha dit a l'apartat 8. Cinc minuts filtren els pics d'un desplegament.
Alerta 2 — Latència p95 > 2 segons durant 10 minuts. Canal: Slack.
Raonament: el p95 habitual de la botiga ronda els 400 ms. Dos segons és el punt on la percepció canvia de "va bé" a "va lent" i l'abandonament de cistella comença a pujar. Es tria p95 i no p99 perquè el p99 és més volàtil i generaria més soroll; i es tria una durada llarga, 10 minuts, perquè la lentitud transitòria és habitual i no requereix acció immediata. Sense SMS: és un problema que s'atén en horari laboral.
Alerta 3 — Missatges sense confirmar a pedidos-nuevos > 1.000 durant 15 minuts. Canal: Slack + correu.
Raonament: en operació normal la cua està pràcticament buida perquè els consumidors van al dia. Mil missatges acumulats quinze minuts significa que el consumidor està caigut o no dona l'abast, i això vol dir que hi ha comandes que no s'estan processant. És l'exemple d'alerta que detecta una fallada invisible des de fora: el web funciona, els clients compren, tot sembla bé, i les comandes s'estan apilant sense processar.
| Alerta | Llindar | Durada | Canals | Què protegeix |
|---|---|---|---|---|
| Errors 5xx | > 2 % | 5 min | Slack + SMS | Clients veient errors |
| Latència p95 | > 2 s | 10 min | Slack | Experiència degradada |
| Cua de comandes | > 1.000 msg | 15 min | Slack + correu | Fallada invisible des de fora |
Fixa't en el patró: cada alerta detecta un tipus diferent de fallada —error visible, degradació visible i fallada invisible—. Deu alertes més sobre CPU no haurien afegit res, perquè la CPU alta ja es manifesta en la latència.
- Fatiga d'alertes: la conversa incòmoda
Això mereix un apartat propi perquè és el problema real de l'observabilitat, i gairebé mai no es diu amb claredat.
La fatiga d'alertes és l'estat en què un equip rep tantes alertes que deixa de reaccionar-hi. No és una falta de disciplina: és una resposta racional. Si de vint alertes diàries dinou són soroll, ignorar-les totes és una estratègia amb un 95 % d'encert i un cost enorme quan falla.
Com s'hi arriba, gairebé sempre pel mateix camí:
- Algú munta una alerta per cada mètrica disponible, "per si de cas".
- Els llindars es posen a ull, sense mirar els valors històrics.
- No hi ha durada, així que qualsevol pic dispara.
- Totes van al mateix canal amb la mateixa urgència.
- Ningú no revisa ni retira les que no aporten.
Els cinc antídots, en ordre d'importància:
| Antídot | Regla concreta |
|---|---|
| Alertar sobre símptomes, no sobre causes | Alerta si els clients pateixen, no si la CPU és al 80 % |
| Llindars partint de dades històriques | Mira el valor real de les últimes 4 setmanes abans de decidir |
| Durada sempre | Cap alerta sense finestra de temps |
| Nivells d'urgència | Això justifica despertar algú? Si no, correu o Slack |
| Revisió periòdica | Cada trimestre: va saltar? va ser útil? Si no, es retira |
La primera és la més important i la més contraintuïtiva. Una CPU al 90 % no és un problema si els clients no ho noten: pot ser el sistema aprofitant bé els seus recursos. Alertar de la CPU produeix falsos positius —CPU alta sense impacte— i falsos negatius —clients patint amb CPU baixa, per exemple per un bloqueig a la base de dades—. Les causes s'investiguen amb el tauler després que un símptoma hagi avisat.
I una pregunta de control que val més que qualsevol llista, per a cada alerta que es vagi a crear:
Si aquesta alerta salta a les 3 de la matinada, hi ha alguna cosa que algú hagi de fer immediatament?
Si la resposta és no, no és una alerta: és un gràfic en un tauler. La Marta i en Dani només tenen tres alertes configurades, i aquell és deliberadament el senyal d'un sistema d'alertes sa.
- Mètriques personalitzades des de l'aplicació
Les mètriques de plataforma expliquen què fa la infraestructura. No expliquen què fa el negoci. Cap mètrica de GCP no sap quantes comandes per minut entren a AlpinaShop, i aquella és probablement la mètrica més important de totes: si les comandes cauen a zero, alguna cosa va malament encara que tots els indicadors tècnics estiguin verds.
# catalogo/metricas.py
from google.cloud import monitoring_v3
import time, os
client = monitoring_v3.MetricServiceClient()
PROJECTE = f"projects/{os.environ['GOOGLE_CLOUD_PROJECT']}"
def registrar_comanda(import_euros: float, canal: str) -> None:
"""Escriu un punt a la mètrica personalitzada de comandes."""
serie = monitoring_v3.TimeSeries()
serie.metric.type = "custom.googleapis.com/tienda/pedidos"
# ETIQUETES: poques i de BAIXA cardinalitat. Vegeu l'advertiment de sota.
serie.metric.labels["canal"] = canal # web | movil | telefono
serie.metric.labels["entorno"] = os.environ.get("ENTORNO", "prod")
serie.resource.type = "generic_task"
serie.resource.labels.update({
"project_id": os.environ["GOOGLE_CLOUD_PROJECT"],
"location": "europe-west1",
"namespace": "tienda",
"job": "catalogo-web",
"task_id": os.environ.get("HOSTNAME", "desconegut"),
})
ara = time.time()
punt = monitoring_v3.Point({
"interval": {"end_time": {"seconds": int(ara)}},
"value": {"double_value": 1.0},
})
serie.points = [punt]
client.create_time_series(name=PROJECTE, time_series=[serie])L'advertiment sobre les etiquetes és la part crítica d'aquest apartat. És temptador afegir serie.metric.labels["id_cliente"] = cliente_id. No ho facis. Amb 50.000 clients actius crearies 50.000 sèries temporals per cada combinació de la resta d'etiquetes, i això és l'explosió de cardinalitat de l'apartat 2: cost alt, consultes lentes i una mètrica inservible.
| Etiqueta | Valors possibles | Acceptable? |
|---|---|---|
canal |
3 | Sí |
entorno |
2-3 | Sí |
categoria_producto |
~20 | Sí |
codigo_postal |
~11.000 | No |
id_cliente |
50.000+ | Mai |
id_pedido |
Il·limitat | Mai |
La regla: una etiqueta de mètrica ha de tenir desenes de valors possibles, no milers. El que és d'alta cardinalitat —l'identificador de client, el de comanda— va als registres, que estan dissenyats per a això, i es consulta des d'allà. És una de les raons per les quals els tres pilars són tres i no un.
Hi ha un camí alternatiu que el 2026 sol ser millor si ja vius a Kubernetes: exposar un endpoint /metrics en format Prometheus i deixar que Managed Service for Prometheus el reculli. Evita una crida a l'API per esdeveniment, és l'estàndard del sector i encaixa amb PromQL. Per al catàleg a GKE, és l'opció que recomanaria.
També existeixen les mètriques basades en registres: comptar entrades de registre que compleixen un filtre i convertir-les en mètrica, sense tocar el codi de l'aplicació. És una tècnica molt potent per instrumentar ràpid el que ja s'està registrant, i es desenvolupa a 06-06.
- Comprovacions de disponibilitat
Tot l'anterior mesura el sistema des de dins. Les comprovacions de disponibilitat (uptime checks) el mesuren des de fora: Google llança peticions des de diverses regions del món i comprova que la botiga respon.
Aquella diferència de punt de vista detecta classes senceres de fallades que cap mètrica interna no veu: un certificat TLS caducat, un registre DNS mal propagat, una regla de Cloud Armor massa agressiva que bloqueja clients legítims, un balancejador mal configurat o una caiguda completa de la regió.
gcloud monitoring uptime create tienda-alpinashop \
--resource-type=uptime-url \
--resource-labels=host=www.alpinashop.example,project_id=alpinashop-prod \
--path=/salud \
--port=443 \
--protocol=https \
--period=1 \
--timeout=10 \
--regions=EUROPE,USA_OREGON,ASIA_PACIFIC,SOUTH_AMERICA \
--content-matchers-content='"estado":"ok"' \
--project=alpinashop-prodQuatre decisions que convé entendre:
- La ruta
/saludés el mateix endpoint que la comprovació d'estathc-catalogodel balancejador de 03-02. Reutilitzar-lo té sentit, però amb un matís important: la comprovació del balancejador decideix si una instància rep trànsit i ha de ser ràpida i superficial; la de disponibilitat mesura si el servei està sa de debò. Un/saludque només retorna200 OKsense comprovar res donarà verd amb la base de dades caiguda. L'endpoint hauria de verificar almenys la connectivitat amb Cloud SQL, amb un timeout curt per no convertir-se ell mateix en un problema. --content-matchers-contentcomprova que la resposta conté el que s'espera, no només que el codi és 200. Un servidor que retorna una pàgina d'error amb codi 200 —més comú del que sembla— es detecta així.- Quatre regions repartides distingeixen un problema global d'un de regional. Si només falla la comprovació des d'Àsia, el problema és de xarxa o de DNS, no de l'aplicació.
- Període d'1 minut és l'equilibri raonable entre detecció ràpida i cost.
I l'alerta associada, amb un detall deliberat:
gcloud alpha monitoring policies create \
--notification-channels=CANAL_SMS_MARTA \
--display-name="AlpinaShop - La botiga no respon" \
--condition-display-name="Uptime check fallant en 2+ regions" \
--condition-filter='metric.type="monitoring.googleapis.com/uptime_check/check_passed" resource.type="uptime_url"' \
--duration=180s \
--project=alpinashop-prodLa condició exigeix fallada des de dues regions o més. Una fallada des d'una sola regió sol ser un problema de la xarxa intermèdia, no de la botiga, i alertar-ne genera exactament el soroll de l'apartat 11. Exigir dues regions converteix aquesta en l'alerta més fiable de tot el sistema: si la botiga no respon des de dos continents, la botiga està caiguda. És l'única alerta d'AlpinaShop que va directa a SMS sense passar per Slack.
- Error Reporting: excepcions agrupades
Quan el catàleg Flask llança una excepció no capturada, el rastreig de pila acaba als registres. Amb milers de peticions al dia, trobar als registres que hi ha un error nou és buscar una agulla en un paller.
Error Reporting resol exactament això: recull les excepcions, les agrupa per la seva signatura —el tipus d'excepció i la pila, no el missatge literal— i presenta una llista de problemes diferents amb la seva freqüència, la seva primera aparició i la seva última.
La diferència pràctica: en lloc de 4.000 línies de registre, veus "KeyError: 'talla' a catalogo/carrito.py:87, 340 ocurrències, primera vegada fa 2 hores, afecta 89 usuaris". I aquell "primera vegada fa 2 hores" és or pur, perquè sol coincidir amb un desplegament.
Instrumentar Flask és senzill:
# catalogo/app.py
import google.cloud.logging
from google.cloud.error_reporting import Client as ErrorClient
client_logging = google.cloud.logging.Client()
client_logging.setup_logging() # els registres de Python van a Cloud Logging
client_errors = ErrorClient(service="catalogo-web", version=os.environ["VERSIO_IMATGE"])
@app.errorhandler(Exception)
def gestionar_error(e):
# report_exception captura el traceback complet del context actual
client_errors.report_exception()
app.logger.exception("Error no controlat servint %s", request.path)
return render_template("error.html"), 500El paràmetre version és més important del que sembla: en passar el SHA de la imatge desplegada, Error Reporting sap en quina versió va aparèixer cada error. Això connecta directament amb 06-01 i converteix una pregunta difícil —"aquest error és nou?"— en una dada. Amb aquella informació, Error Reporting notifica les regressions: avisa quan apareix un tipus d'error que no existia, i quan reapareix un que s'havia marcat com a resolt.
| Capacitat | Què aporta |
|---|---|
| Agrupació per signatura | 4.000 línies de registre → 12 problemes diferents |
| Recompte i tendència | Està empitjorant? |
| Primera i última aparició | Correlació amb desplegaments |
| Usuaris afectats | Prioritza per impacte real, no per volum |
| Notificació d'errors nous | Detecta regressions automàticament |
| Enllaç al codi font | Salta a la línia exacta (integració de 06-02) |
Un consell important sobre el disseny de les excepcions: Error Reporting agrupa per la signatura de la pila, així que un error genèric repetit en vint llocs diferents s'agrupa malament. Excepcions específiques i missatges amb context —però sense dades personals— fan que l'agrupació sigui útil.
- L'agent d'operacions a les VM del MIG
Hi ha una llacuna a les mètriques de plataforma que sorprèn tothom la primera vegada: Google no pot veure dins de les teves màquines virtuals. Sap la CPU, la xarxa i les operacions de disc, perquè això ho mesura l'hipervisor. No sap la memòria utilitzada, l'espai lliure al disc ni els processos que corren, perquè això només es veu des de dins del sistema operatiu.
L'agent d'operacions (Ops Agent) és un únic agent que recull mètriques del sistema i envia registres des de les VM. Substitueix els antics agents separats de Stackdriver de monitoratge i de logging.
Instal·lar-lo a les plantilles del MIG alpinashop-web-mig, mitjançant l'startup script de 02-01:
#!/bin/bash
# Fragment de l'startup script de la plantilla d'instància
curl -sSO https://dl.google.com/cloudagents/add-google-cloud-ops-agent-repo.sh
sudo bash add-google-cloud-ops-agent-repo.sh --also-installI la seva configuració, a /etc/google-cloud-ops-agent/config.yaml:
logging:
receivers:
catalogo_app:
type: files
include_paths: [/var/log/alpinashop/catalogo.log]
service:
pipelines:
catalogo:
receivers: [catalogo_app]
metrics:
receivers:
hostmetrics:
type: hostmetrics
collection_interval: 60s
service:
pipelines:
predeterminada:
receivers: [hostmetrics]El que apareix a Cloud Monitoring un cop instal·lat:
| Mètrica | Per què és important |
|---|---|
agent.googleapis.com/memory/percent_used |
La causa més comuna de reinicis inexplicables |
agent.googleapis.com/disk/percent_used |
Un disc ple tomba l'aplicació en silenci |
agent.googleapis.com/processes/count_by_state |
Processos zombis, fuites de processos |
agent.googleapis.com/swap/percent_used |
Si hi ha swap actiu, falta memòria |
La memòria mereix èmfasi: una fuita de memòria a l'aplicació acaba amb el sistema matant el procés. Des de fora es veu com a reinicis aleatoris i peticions perdudes, sense cap mètrica que ho expliqui. Sense l'agent, aquell diagnòstic és pràcticament impossible.
I una nota de futur: quan AlpinaShop mogui el catàleg a Cloud Run (DA-001, 07-02), l'agent deixa de caldre perquè la plataforma exposa aquelles mètriques per si mateixa. És un avantatge real dels serveis gestionats que rarament s'esmenta.
- Cost de l'observabilitat
És fàcil que la factura d'observabilitat creixi sense que ningú se n'adoni. Convé conèixer el model —sempre amb els preus vigents de la documentació oficial—:
| Component | Es paga per | Nivell gratuït | Risc |
|---|---|---|---|
| Mètriques de plataforma | Res | Totes | Cap |
| Mètriques personalitzades | Sèrie temporal ingerida | Un volum inicial | Alt: cardinalitat |
| Registres | GB ingerits | Volum mensual generós | El més gran de tots (06-06) |
| Traces | Spans ingerits | Volum mensual | Mitjà: es controla amb mostreig |
| Comprovacions de disponibilitat | Execucions | Ampli | Baix |
| Taulers i alertes | Res | — | Cap |
Que els taulers, les alertes i les mètriques de plataforma siguin gratuïts és la millor notícia d'aquesta lliçó: tot el que s'ha construït als apartats 4 a 11 no afegeix cost. El que es paga és el que tu ingereixes: mètriques personalitzades i, sobretot, registres.
Els cinc consells perquè no es dispari:
- Vigila la cardinalitat de les mètriques personalitzades. És el parany número u: un identificador de client com a etiqueta multiplica el cost per milers.
- No inventis mètriques que ja existeixen. Abans d'instrumentar, comprova si GCP ja l'emet. Moltes mètriques personalitzades dupliquen mètriques gratuïtes.
- Exclou el soroll dels registres. Els sondejos de salut i els assets estàtics generen un volum enorme sense valor de diagnòstic. Els filtres d'exclusió són el tema de 06-06.
- Ajusta la retenció. No tots els registres necessiten guardar-se 30 dies; alguns, amb 7 n'hi ha prou, i el que cal conservar molt de temps surt més barat exportat a Cloud Storage.
- Posa una alerta de pressupost sobre el propi cost d'observabilitat, amb el que s'ha après a 01-04. És irònic i és exactament el correcte.
I la perspectiva que cal mantenir: l'observabilitat és cara comparada amb res i barata comparada amb un incident. Vint minuts de botiga caiguda en campanya costen més que un mes de registres. La decisió no és "quant gastar en observabilitat", sinó "què necessito veure per no estar cec, i què estic pagant per veure que ningú no mira mai".
Errors Habituals i Consells
Utilitzar la mitjana per a la latència. L'error conceptual més estès. La mitjana oculta exactament el problema que busques. Percentils sempre: p50 per al que és típic, p95 i p99 per al que és dolent.
Promitjar percentils entre instàncies. La mitjana dels p95 no és el p95 del conjunt. És un nombre sense significat. Configura l'alineador i l'agregació correctament.
Alertar sobre causes en lloc de símptomes. Una alerta de CPU al 80 % produeix falsos positius i falsos negatius. Alerta quan els clients pateixen; investiga la causa després amb el tauler.
Alertes sense durada. Qualsevol pic dispara, l'equip aprèn a ignorar-les i el sistema d'alertes mor. Cap alerta sense finestra de temps.
Llindars absoluts en lloc de proporcions. "200 errors" no significa res sense saber quantes peticions hi va haver. Alerta sobre percentatges.
Etiquetes d'alta cardinalitat en mètriques personalitzades. Identificador de client o de comanda com a etiqueta: cost disparat i mètrica inútil. Això va als registres.
Crear trenta alertes el primer dia. La fatiga apareix ràpid i és difícil de revertir. Comença amb tres, viu-hi un mes, i afegeix només quan un incident real demostri que en faltava una.
Alertes sense documentació. Arriba al mòbil a les onze de la nit i qui la rep no sap què mirar. El camp documentation amb els quatre primers passos és obligatori.
Oblidar l'agent d'operacions a les VM. Sense ell no hi ha mètriques de memòria ni de disc, i aquelles són les causes de les fallades més difícils de diagnosticar.
Un endpoint /salud que no comprova res. Retornar 200 OK sense verificar dependències fa que la comprovació sigui verda amb la base de dades caiguda. Que comprovi l'essencial, amb timeout curt.
Taulers construïts a clics i mai exportats. Es perden, no es repliquen i ningú no sap qui els va canviar. Exporta el JSON a Git.
Consell final: el millor moment per muntar l'observabilitat és abans de l'incident. Durant un incident, amb la botiga caiguda i el telèfon sonant, ningú no té temps de construir un tauler. I l'observabilitat no es jutja per com de bonica és en un dia normal, sinó per com de ràpid et porta a la causa el pitjor dia de l'any.
Exercicis
Exercici 1: dissenyar una alerta partint de dades històriques
AlpinaShop vol alertar sobre les connexions a alpinashop-pedidos. Les dades històriques de les últimes 4 setmanes: mediana 45 connexions, p95 120, màxim observat 180 durant una campanya de cap de setmana que va funcionar correctament, i el límit configurat de la instància és 250. Dissenya la política d'alerta completa —mètrica, llindar, durada, canal i documentació— justificant cada nombre, i explica què passaria amb un llindar de 100 i amb un de 240.
Exercici 2: triar què mesurar per a un problema que ningú no veu
La Lucía observa que l'informe de vendes de l'última setmana mostra 40 comandes menys de l'esperat els dimarts al matí, de manera consistent. Cap alerta no ha saltat, el tauler és verd i la comprovació de disponibilitat no ha fallat mai. Proposa quines mètriques miraries, en quin ordre, i quina instrumentació nova afegiries perquè aquest tipus de problema es detecti automàticament en el futur.
Exercici 3: redissenyar un sistema d'alertes amb fatiga
Una empresa semblant a AlpinaShop té 34 alertes configurades. L'últim mes van saltar 280 vegades; d'aquelles, 11 van correspondre a incidents reals. L'equip ha silenciat el canal de Slack i revisa les alertes "quan pot". Diagnostica el problema, proposa un mètode concret per reduir el nombre d'alertes i defineix el conjunt mínim amb què arrencaries de nou, explicant quin tipus de fallada detecta cadascuna.
Solucions
Solució 1
La política:
| Element | Valor | Justificació |
|---|---|---|
| Mètrica | cloudsql.googleapis.com/database/network/connections |
La directa |
| Alineador | ALIGN_MAX sobre 60 s |
El pic importa, no la mitjana del minut |
| Llindar | 200 connexions | 80 % del límit de 250 |
| Durada | 5 minuts | Filtra pics legítims |
| Canal | Slack + correu a la Marta | Seriós, però no de matinada |
| Gravetat | Advertiment | És un avís previ, no una caiguda |
Per què 200. És el 80 % del límit dur de 250. Deixa marge per actuar abans que la instància comenci a rebutjar connexions, i està molt per damunt del màxim històric observat en operació normal (180), així que no salta per l'ús legítim més extrem conegut. La regla general: alertar en un percentatge del límit, no en un múltiple de la mediana, perquè el que fa mal és esgotar el recurs.
Amb un llindar de 100: saltaria constantment. El p95 històric és 120, és a dir, el 5 % del temps se superen 120 connexions en operació completament normal. Una alerta a 100 saltaria diverses vegades al dia sense que res estigui malament. És el camí directe a la fatiga de l'apartat 11 i que se silenciï el canal.
Amb un llindar de 240: arribaria massa tard. A 240 de 250 queden deu connexions de marge; amb la velocitat a què creix aquest comptador durant un pic, el temps entre l'alerta i l'esgotament es mesura en segons. La Marta rebria la notificació alhora que els primers errors de connexió dels clients, i l'alerta hauria deixat de ser preventiva per ser un avís que ja és tard.
Documentació associada, que és la meitat del valor:
## Connexions a Cloud SQL elevades
**Què significa:** alpinashop-pedidos supera 200 de les seves 250 connexions màximes.
**Impacte si arriba a 250:** l'aplicació comença a rebre errors de connexió
i la botiga retorna 500. Encara no ha passat.
**Primers passos:**
1. Hi ha un pic de trànsit legítim? Tauler Campanya de tardor, peticions/s.
2. Si NO hi ha pic de trànsit: probable fuita de connexions després d'un desplegament.
Revisar Cloud Build: hi va haver desplegament en les últimes 2 hores?
3. Comprovar el nombre d'instàncies del MIG i de pods: ha escalat molt?
4. Comprovar Cloud Functions amb --max-instances alt connectades a la BD (06-03).
**Mitigació immediata:** reduir --max-instances de les funcions connectades.
**Mitigació de fons:** revisar el pool de connexions de l'aplicació.I una recomanació addicional que millora bastant el disseny: afegir una segona condició sobre la tendència, no només el nivell. Un salt de 45 a 190 connexions en cinc minuts és un senyal de fuita moltíssim més fiable que el valor absolut, i avisaria abans. La majoria de les fuites de connexions es manifesten com una rampa que puja i mai no baixa, i això és detectable molt abans d'arribar al 80 % del límit.
Solució 2
El primer és reconèixer quin tipus de problema és: una fallada parcial i silenciosa. No hi ha caiguda, no hi ha errors massius, no hi ha lentitud generalitzada. Alguna cosa falla per a un subconjunt d'usuaris o d'operacions, i tots els indicadors agregats ho dilueixen. Són les fallades més cares perquè duren setmanes.
Mètriques a mirar, en aquest ordre:
| Pas | Què mirar | Què busques |
|---|---|---|
| 1 | https/request_count dimarts al matí davant d'altres dies |
Cau el trànsit o només les comandes? |
| 2 | Taxa d'error 5xx agrupada per matched_url_path_rule |
Un error localitzat en una ruta concreta |
| 3 | Latència p95 per ruta, especialment /carrito i /pago |
Lentitud localitzada |
| 4 | request_count agrupat per user_agent o país |
Afecta un segment? |
| 5 | Error Reporting filtrat per franja horària | Excepcions noves o que augmenten |
| 6 | Mètriques de treballs programats dels dimarts | La hipòtesi més probable |
La hipòtesi principal, i per què. La regularitat —dimarts al matí, sistemàticament— apunta amb força a alguna cosa programada que s'executa els dimarts: una còpia de seguretat, un procés de reindexació, un informe pesat sobre alpinashop_analitica, una tasca de manteniment. Aquell procés competeix per recursos amb la botiga: satura la CPU de Cloud SQL, ocupa connexions o bloqueja taules, i durant aquella estona una fracció dels intents de compra falla o s'abandona per lentitud.
El pas 1 és especialment informatiu i mereix detallar-se: si el trànsit és normal però les comandes cauen, el problema és a l'embut de compra; si el trànsit també cau, el problema és d'accés —DNS, CDN, una campanya de màrqueting que no va sortir—. Són diagnòstics completament diferents i aquella única comparació els separa.
Instrumentació nova a afegir, que és l'objectiu real de l'exercici:
| Instrumentació | Què detecta | Prioritat |
|---|---|---|
Mètrica de negoci tienda/pedidos (apartat 12) |
La caiguda de comandes, directament | Alta |
| Mètrica de l'embut per etapa: vistes → cistella → pagament → confirmat | En quin pas es perd la gent | Alta |
| Alerta sobre comandes/hora comparades amb la mateixa hora de la setmana anterior | Anomalies, no llindars fixos | Alta |
| Latència p95 per ruta al tauler | Lentitud localitzada | Mitjana |
| Mètrica de durada dels treballs programats | Correlació amb la finestra de degradació | Mitjana |
La mètrica d'embut és la clau de l'exercici. Amb comptadors per etapa, la pregunta "on es perden les comandes?" té resposta immediata: si les vistes de producte són normals, les cistelles són normals i els pagaments confirmats cauen, el problema és a la passarel·la o al pas final. Sense ella, cal reconstruir-ho a mà des dels registres cada vegada.
I l'alerta correcta no és de llindar fix, sinó comparativa. "Menys de X comandes per hora" és inservible perquè el volum varia enormement entre les 4 de la matinada i les 8 del vespre, i entre un dimarts de juliol i un dissabte de campanya. El que funciona és comparar amb la mateixa franja horària de la setmana anterior i alertar davant d'una desviació superior al 30 %. Aquella comparació absorbeix l'estacionalitat diària i setmanal.
I la lliçó de fons: tots els indicadors tècnics estaven verds mentre es perdien 40 comandes setmanals. L'observabilitat tècnica no substitueix l'observabilitat de negoci. La mètrica més important d'una botiga és quantes comandes entren, i cap mètrica de plataforma no la coneix. Aquest cas és el millor argument possible a favor de les mètriques personalitzades de l'apartat 12.
Solució 3
Diagnòstic numèric, que és demolidor. 280 alertes per a 11 incidents reals significa una precisió del 3,9 %: 96 de cada 100 alertes són soroll. Amb aquella proporció, silenciar el canal és la decisió racional, i l'equip no ha fet res retretable. El sistema d'alertes està trencat, no les persones.
El cost real no són les 280 interrupcions: és que els 11 incidents reals van quedar enterrats. Un sistema amb aquella precisió no només és inútil, és pitjor que no tenir alertes, perquè genera la il·lusió d'estar vigilat.
Les causes gairebé segures, deduïbles del patró:
| Causa | Símptoma | Correcció |
|---|---|---|
| Alertes sobre causes i no símptomes | Moltes de CPU, memòria, disc | Retirar-les: són gràfics, no alertes |
| Llindars posats a ull | Salten en operació normal | Recalcular amb 4 setmanes d'històric |
| Sense durada | Salten amb qualsevol pic | Mínim 5 minuts a totes |
| Llindars absoluts | "N errors" sense context | Convertir a proporcions |
| Tot al mateix canal | L'urgent i l'informatiu barrejats | Separar per nivell |
| Mai no es revisen | 34 alertes acumulades | Revisió trimestral obligatòria |
Mètode concret de reducció, en cinc passos:
Pas 1, mesurar cada alerta. Per a cadascuna de les 34: quantes vegades va saltar, quantes van correspondre a un incident real i quina acció va provocar. És un exercici d'una tarda amb les dades de Cloud Monitoring.
Pas 2, aplicar la pregunta de les 3 de la matinada. Per a cada alerta: si això salta de matinada, hi ha alguna cosa que algú hagi de fer immediatament? Totes les que responguin "no" es retiren. La meva aposta: de 34 en cauen unes 20.
Pas 3, classificar les supervivents.
| Classe | Criteri | Destinació |
|---|---|---|
| Precisió alta i acció clara | Va saltar poques vegades i sempre va ser real | Es conserva |
| Concepte correcte, llindar dolent | Detecta l'adequat però salta massa | Es recalibra |
| Duplicada | Una altra alerta detecta el mateix abans | Es retira |
| Mai no va saltar | Zero dispars en un mes | Es revisa si continua tenint sentit |
Pas 4, recalibrar amb dades. Per a cada supervivent, mirar el valor real de les últimes quatre setmanes i posar el llindar per damunt del p99 històric o en un percentatge del límit dur, amb durada mínima de 5 minuts.
Pas 5, començar de zero amb el conjunt mínim. I aquí ve la part que costa acceptar: és preferible desactivar les 34 i arrencar amb 4 que intentar arreglar les 34. Un sistema d'alertes ja desacreditat no recupera la confiança retocant-lo; cal refundar-lo.
El conjunt mínim amb què arrencar, cadascuna detectant una classe diferent de fallada:
| Alerta | Llindar | Durada | Fallada que detecta | Canal |
|---|---|---|---|---|
| Disponibilitat des de 2+ regions | Fallada | 3 min | Caiguda total | SMS |
| Taxa d'error 5xx | > 2 % | 5 min | Fallada funcional visible | Slack + SMS |
| Latència p95 | > 2 s | 10 min | Degradació visible | Slack |
| Comandes/hora davant de la setmana anterior | −30 % | 30 min | Fallada silenciosa de negoci | Slack |
Quatre alertes. I el criteri per afegir la cinquena és estricte i molt útil: només s'afegeix una alerta quan un incident real ha ocorregut i cap de les existents no l'ha detectat. Cada alerta nova s'ha de justificar amb un incident concret, no amb un "per si de cas". Així el sistema creix guiat per la realitat, i cada alerta que existeix té una història que la sosté.
Tancament de l'exercici, amb la lliçó que se n'endú un: un sistema d'alertes es jutja per la seva precisió, no per la seva cobertura. Quatre alertes amb un 80 % de precisió valen infinitament més que trenta-quatre amb un 4 %, perquè les primeres s'atenen i les segones se silencien. I una alerta silenciada no protegeix res.
Conclusió
AlpinaShop ja no s'assabenta dels seus problemes per correu electrònic d'un client.
Saps què és l'observabilitat —entendre què li passa per dins a un sistema des del que emet cap a fora, incloses les fallades que no vas anticipar— i els seus tres pilars, amb el seu perfil diferent: mètriques barates i agregades per a tendències i alertes, registres amb detall per a casos concrets, traces per saber on se'n va anar el temps. I saps que Stackdriver és només un nom històric.
Domines el model de dades: una sèrie temporal és tipus de mètrica + recurs monitorat + etiquetes, amb la conseqüència que les etiquetes multipliquen sèries i produeixen explosió de cardinalitat. Distingeixes mesurador, comptador i distribució, amb les implicacions pràctiques: un comptador cal derivar-lo amb rate o no significa res, i una distribució conserva l'histograma complet per poder demanar percentils a posteriori.
Tens els tres projectes en un sol espai de mètriques, amb l'advertiment que unifica la vista però no els permisos. Coneixes les mètriques de plataforma gratuïtes que porten mesos acumulant-se sense que ningú les miri, i la taula que de debò s'utilitza en un incident: del símptoma a la mètrica.
Saps explorar amb alineadors i agregacions en l'ordre correcte, i sobretot per què la mitjana menteix: 495 ms de mitjana mentre 50 clients per minut esperen vuit segons. Percentils sempre, mai promitjar percentils entre sèries, i el p99 importa més del que el seu nom suggereix perquè sol tocar als millors clients.
Tens el tauler de la campanya de tardor construït per explicar una història de dalt a baix —primer si pateixen els clients, després per què— amb la CPU del MIG mostrada en mitjana i màxim perquè la mitjana oculta la instància calenta. I el tens com a JSON versionable a Git, llest per passar a Terraform a 06-07. Coneixes MQL per al que els filtres no expressen —la taxa d'error com a proporció— i PromQL com a aposta més portable si vius a Kubernetes.
Saps muntar una política d'alerta amb les seves quatre peces, amb la durada com a peça infravalorada i el camp documentation com el que separa una alerta útil d'una que genera ansietat. Tens les tres alertes d'AlpinaShop, cadascuna amb el seu llindar raonat i cadascuna detectant un tipus diferent de fallada: error visible, degradació visible i fallada invisible des de fora. I has tingut la conversa incòmoda sobre la fatiga d'alertes, amb la pregunta de control que val per tot l'apartat: si això salta a les 3 de la matinada, hi ha alguna cosa a fer immediatament? Si no, és un gràfic, no una alerta.
Saps emetre mètriques personalitzades de negoci —les comandes per minut que cap mètrica de GCP no coneix— amb la regla d'or sobre les etiquetes: desenes de valors, mai milers, i el que és d'alta cardinalitat va als registres. Tens comprovacions de disponibilitat des de quatre continents que detecten el que cap mètrica interna no veu, amb la condició de dues regions que les converteix en l'alerta més fiable del sistema. Tens Error Reporting agrupant excepcions de Flask per signatura i notificant regressions, amb el version que enllaça cada error amb el desplegament que el va introduir. I tens l'agent d'operacions a les VM del MIG, sense el qual no hi ha mètriques de memòria ni de disc i els reinicis inexplicables es queden inexplicables.
I coneixes el cost: taulers, alertes i mètriques de plataforma són gratuïts; el que es paga és el que tu ingereixes, amb la cardinalitat i el volum de registres com els dos paranys. Amb la perspectiva correcta: l'observabilitat és cara comparada amb res i barata comparada amb vint minuts de botiga caiguda en campanya.
Però fixa't en el que les mètriques no poden fer. Quan l'alerta d'errors 5xx salta a les onze de la nit, et diu que el 4 % de les peticions fallen. No et diu què falla. No et diu a quin client li va passar, ni amb quin producte, ni en quina línia de codi. I quan la latència p99 es dispara, la mètrica et diu que alguna cosa triga tres segons, però no qui triga: l'aplicació, la base de dades, la crida a la Vision API, la xarxa?
Per a això calen els altres dos pilars. A 06-06 arriben Cloud Logging i Cloud Trace: els registres que responen què va passar exactament en aquest cas, i les traces que responen on se'n va anar el temps. I amb ells, el recorregut complet d'un incident d'AlpinaShop des de l'alerta fins a la línia de codi.
Abans, però, hi ha un deute pendent que ja no es pot ajornar. Tota aquesta infraestructura —la VPC, el balancejador, el clúster, les alertes que acabes de crear— continua existint únicament perquè algú va executar les comandes correctes en l'ordre correcte, i aquell algú va ser la Marta, i el registre del que va fer és a l'historial del seu terminal. A 06-05 s'ataca aquell problema de front.
Curs de Google Cloud Platform (GCP)
Mòdul 1: Introducció a Google Cloud Platform
- Què és Google Cloud Platform?
- Configuració del teu compte de GCP
- Descripció general de la consola de GCP
- Projectes, jerarquia de recursos i facturació
- Regions, zones i model de responsabilitat compartida
- Cloud Shell i la CLI de gcloud
Mòdul 2: Serveis principals de GCP
- Compute Engine: màquines virtuals a Google Cloud
- Cloud Storage: emmagatzematge d'objectes
- Cloud SQL: bases de dades relacionals gestionades
- App Engine: plataforma com a servei
- Google Kubernetes Engine (GKE)
- Bases de dades NoSQL: Firestore, Bigtable i Spanner
- Com triar el servei de còmput adequat
Mòdul 3: Xarxes i seguretat
- Xarxes VPC
- Balanceig de càrrega al núvol
- Cloud CDN
- Gestió d'identitat i accés (IAM)
- Cloud Armor
- Secrets i xifratge: Secret Manager i Cloud KMS
- Cloud DNS, certificats TLS i publicació segura de serveis
Mòdul 4: Dades i anàlisi
- BigQuery: el magatzem de dades analític
- Cloud Dataflow: processament de dades per lots i en temps real
- Cloud Dataproc: Spark i Hadoop gestionats
- Cloud Pub/Sub: missatgeria asíncrona
- Cloud Data Fusion: integració de dades sense codi
- Orquestració de pipelines amb Cloud Composer i Workflows
- Govern de les dades i taulers amb Dataplex i Looker Studio
Mòdul 5: Aprenentatge automàtic i IA
- Vertex AI: la plataforma d'aprenentatge automàtic de GCP
- AutoML: models a mida sense escriure codi
- TensorFlow a GCP: entrenament i servei de models
- API de llenguatge natural
- API de visió
- IA generativa a Vertex AI: models Gemini i incrustacions
- MLOps: del model al producte amb Vertex AI Pipelines
Mòdul 6: DevOps i monitoratge
- Cloud Build: integració contínua a GCP
- Cloud Source Repositories i gestió del codi font
- Cloud Functions: funcions sense servidor
- Cloud Monitoring (abans Stackdriver): mètriques, taulers i alertes
- Cloud Deployment Manager i infraestructura com a codi nativa
- Cloud Logging i Cloud Trace: registres, traces i diagnòstic
- Terraform a GCP: infraestructura com a codi a la pràctica
Mòdul 7: Temes avançats de GCP
- Híbrid i multinúvol amb Anthos
- Computació sense servidor amb Cloud Run
- Xarxes avançades: VPC compartida, aparellament i connectivitat híbrida
- Bones pràctiques de seguretat
- Gestió i optimització de costos
- Fiabilitat: SLO, alta disponibilitat i recuperació de desastres
- Govern a escala: organització, polítiques i auditoria
