TL; DR
- Per ottene una alta osservabilità di cuntenituri è microservizi, i logs è e metriche primarie ùn sò micca abbastanza.
- Per una ricuperazione più rapida è una resilienza aumentata, l'applicazioni anu da applicà u Principiu di l'Alta Osservabilità (HOP).
- À u livellu di l'applicazione, NOP richiede: logu propiu, monitoraghju strettu, cuntrolli di sanità, è traccia di rendiment / transizione.
- Aduprate cuntrolli cum'è un elementu di NOR Prontu Probe и prova di vita Kubernetes.
Chì ghjè un mudellu di cuntrollu di salute?
Quandu cuncepisce una applicazione critica di missione è assai dispunibile, hè assai impurtante per pensà à un aspettu cum'è a tolleranza di difetti. Una applicazione hè cunsiderata tollerante à i difetti s'ellu si recupera rapidamente da u fallimentu. Una tipica applicazione cloud usa una architettura di microservizi - induve ogni cumpunente hè piazzatu in un containeru separatu. È per assicurà chì l'applicazione nantu à k8s hè assai dispunibule quandu cuncepite un cluster, avete bisognu di seguità certi mudelli. Frà elli hè u Template di Cuntrolla di Salute. Definisce cumu l'applicazione comunica à k8s chì hè sana. Questa ùn hè micca solu infurmazione nantu à se u pod hè in esecuzione, ma ancu nantu à cumu riceve è risponde à e dumande. Quantu più Kubernetes sà di a salute di u pod, e decisioni più intelligenti chì piglia nantu à u routing di u trafficu è l'equilibriu di carica. Cusì, u Principiu di l'Alta Osservabilità permette à l'applicazione di risponde à e dumande in una manera puntuale.
Principiu di l'Alta Osservabilità (HOP)
U principiu di alta observabilità hè unu di
Una applicazione cloud ben cuncepita registra i so avvenimenti principali utilizendu i flussi I/O standard STDERR è STDOUT. Dopu vene un serviziu ausiliariu, per esempiu filebeat, logstash o fluentd, chì furnisce logs à un sistema di surviglianza centralizatu (per esempiu Prometheus) è un sistema di cullizzioni di log (suite di software ELK). U diagramma sottu mostra cumu funziona una applicazione in nuvola secondu u Pattern di Test di Salute è u Principiu d'Alta Observabilità.
Cumu applicà u mudellu di cuntrollu di salute in Kubernetes?
Fora di a scatula, k8s monitoreghja u statutu di i pods utilizendu unu di i cuntrolli (
In u nostru esempiu, k8s faci verificazione di funziunalità. In questu tipu di verificazione, u kubelet verifica continuamente u statu di u prucessu in u cuntinuu. Una volta capisce chì u prucessu hè firmatu, riavviarà. Se l'errore pò esse risoltu da solu riavvia l'applicazione, è u prugramma hè pensatu per chjude ogni errore, allora un cuntrollu di salute di u prucessu hè tuttu ciò chì avete bisognu di seguità u NOP è u Pattern di Test di Salute. L'unica pietà hè chì micca tutti l'errori sò eliminati da u riavviu. In questu casu, k8s offre 2 modi più profondi per identificà i prublemi cù u pod:
LivenessProbe
Duranti u prova di vita kubelet esegue 3 tipi di cuntrolli: ùn solu determina se u pod hè in esecuzione, ma ancu s'ellu hè prontu à riceve è risponde bè à e dumande:
- Configurate una dumanda HTTP à u pod. A risposta deve cuntene un codice di risposta HTTP in a gamma da 200 à 399. Cusì, i codici 5xx è 4xx signalanu chì u pod hè avè prublemi, ancu s'è u prucessu hè in esecuzione.
- Per pruvà pods cù servizii non-HTTP (per esempiu, u servitore di posta Postfix), avete bisognu di stabilisce una cunnessione TCP.
- Eseguite un cumandamentu arbitrariu per un pod (internu). A verificazione hè cunsiderata successu se u codice di cumpiimentu di u cumandamentu hè 0.
Un esempiu di cumu si travaglia. A prossima definizione di pod cuntene una applicazione NodeJS chì tira un errore 500 nantu à e dumande HTTP. Per assicurà chì u cuntinuu hè riavviatu quandu riceve un tali errore, usemu u paràmetru livenessProbe:
apiVersion: v1
kind: Pod
metadata:
name: node500
spec:
containers:
- image: magalix/node500
name: node500
ports:
- containerPort: 3000
protocol: TCP
livenessProbe:
httpGet:
path: /
port: 3000
initialDelaySeconds: 5
Questu ùn hè micca sfarente di qualsiasi altra definizione di pod, ma aghjustemu un oggettu .spec.containers.livenessProbe
. Parametru httpGet
accetta a strada à quale hè mandata a dumanda HTTP GET (in u nostru esempiu questu hè /
, ma in i scenarii di cummattimentu pò esse qualcosa cum'è /api/v1/status
). Un altru livenessProbe accetta un paràmetru initialDelaySeconds
, chì urdineghja l'operazione di verificazione per aspittà un numeru specificatu di seconde. U ritardu hè necessariu perchè u cuntinuu hà bisognu di tempu per inizià, è quandu riavviatu ùn serà micca dispunibule per qualchì tempu.
Per applicà sta paràmetra à un cluster, utilizate:
kubectl apply -f pod.yaml
Dopu qualchì seconde, pudete cuntrollà u cuntenutu di u pod cù u cumandimu seguitu:
kubectl describe pods node500
À a fine di l'output, truvate
Comu pudete vede, livenessProbe hà iniziatu una dumanda HTTP GET, u cuntinuu hà generatu un errore 500 (chì hè ciò chì era programatu per fà), è u kubelet hà riavviatu.
Sè vi dumandate cumu l'applicazione NideJS hè stata programata, eccu l'app.js è Dockerfile chì sò stati utilizati:
app.js
var http = require('http');
var server = http.createServer(function(req, res) {
res.writeHead(500, { "Content-type": "text/plain" });
res.end("We have run into an errorn");
});
server.listen(3000, function() {
console.log('Server is running at 3000')
})
dockerfile
FROM node
COPY app.js /
EXPOSE 3000
ENTRYPOINT [ "node","/app.js" ]
Hè impurtante di nutà questu: livenessProbe riavviarà u cuntinuu solu s'ellu falla. Se un riavviu ùn curreghja micca l'errore chì impedisce à u cuntinuu di correre, u kubelet ùn serà micca capaci di piglià l'azzione per corregge u prublema.
Prontu Probe
ReadinessProbe funziona in modu simile à livenessProbes (richieste GET, cumunicazioni TCP è esecuzione di cumandamenti), eccettu per l'azzioni di risoluzione di prublemi. U cuntinuu in u quale u fallimentu hè rilevatu ùn hè micca riavviatu, ma hè isolatu da u trafficu entrante. Imagine chì unu di i cuntenituri faci assai calculi o hè sottumessu à una carica pesante, facendu chì i tempi di risposta aumentanu. In u casu di livenessProbe, a verificazione di a dispunibilità di a risposta hè attivata (via u paràmetru di verificazione di timeoutSeconds), dopu chì u kubelet riavvia u cuntinuu. Quandu hà cuminciatu, u cuntinuu cumencia à eseguisce travaglii intensivi di risorse è hè riavviatu di novu. Questu pò esse criticu per l'applicazioni chì necessitanu rapidità di risposta. Per esempiu, una vittura mentre in a strada aspetta una risposta da u servitore, a risposta hè ritardata - è a vittura entra in un accidente.
Scrivemu una definizione di redinessProbe chì stabiliscerà u tempu di risposta di a dumanda GET à micca più di dui seconde, è l'applicazione risponde à a dumanda GET dopu à 5 seconde. U schedariu pod.yaml deve esse cusì:
apiVersion: v1
kind: Pod
metadata:
name: nodedelayed
spec:
containers:
- image: afakharany/node_delayed
name: nodedelayed
ports:
- containerPort: 3000
protocol: TCP
readinessProbe:
httpGet:
path: /
port: 3000
timeoutSeconds: 2
Implementemu un pod cù kubectl:
kubectl apply -f pod.yaml
Aspittemu un paru di sicondi è poi vede cumu u ReadinessProbe hà travagliatu:
kubectl describe pods nodedelayed
À a fine di l'output, pudete vede chì certi avvenimenti sò simili
Comu pudete vede, kubectl ùn hà micca riavviatu u pod quandu u tempu di cuntrollu superava 2 seconde. Invece, hà annullatu a dumanda. I cumunicazioni entranti sò rediretti à altri pods di travagliu.
Nota chì avà chì u pod hè scaricatu, kubectl indirizza e dumande à ellu di novu: e risposte à e dumande GET ùn sò più ritardate.
Per paragone, quì sottu hè u schedariu app.js mudificatu:
var http = require('http');
var server = http.createServer(function(req, res) {
const sleep = (milliseconds) => {
return new Promise(resolve => setTimeout(resolve, milliseconds))
}
sleep(5000).then(() => {
res.writeHead(200, { "Content-type": "text/plain" });
res.end("Hellon");
})
});
server.listen(3000, function() {
console.log('Server is running at 3000')
})
TL; DR
Prima di l'avventu di l'applicazioni in nuvola, i logs eranu i mezi primari di surviglianza è cuntrollà a salute di l'applicazioni. Tuttavia, ùn ci era micca mezzu per piglià alcuna azzione currettiva. I logs sò sempre utili oghje; anu da esse recullati è mandati à un sistema di cullizzioni di log per analizà e situazioni d'emergenza è piglià decisioni. [Tuttu chistu puderia esse fattu senza l'applicazioni in nuvola chì utilizanu monit, per esempiu, ma cù k8s hè diventatu assai più faciule :) - nota di l'editore. ]
Oghje, e currezzione devenu esse fatte quasi in tempu reale, cusì l'applicazioni ùn anu più esse scatuli neri. Innò, anu da mustrà i punti finali chì permettenu à i sistemi di monitoraghju di interrogà è raccoglie dati preziosi nantu à u statu di i prucessi in modu chì ponu risponde istantaneamente se necessariu. Questu hè chjamatu u Pattern di Disegnu di Test di Prestazione, chì seguita u Principiu di High Observability (HOP).
Kubernetes offre 2 tipi di cuntrolli di salute per difettu: ReadinessProbe è LivenessProbe. Tramindui utilizanu i stessi tipi di cuntrolli (richieste HTTP GET, cumunicazioni TCP è esecuzione di cumandamenti). Differiscenu in e decisioni chì facenu in risposta à i prublemi in i baccelli. livenessProbe riavvia u cuntinuu in a speranza chì l'errore ùn succede micca, è ReadinessProbe isola u pod da u trafficu entrante finu à chì a causa di u prublema hè risolta.
U disignu propiu di l'applicazione deve include i dui tipi di cuntrolli è assicuratevi chì recullanu abbastanza dati, soprattuttu quandu una eccezzioni hè ghjittata. Deve ancu vede l'endpoints API necessarii chì furnisce u sistema di monitoraghju (Prometheus) cù metriche di salute impurtanti.
Source: www.habr.com