TL; DR
- แแแแขแแแแแ แแแแกแ แแ แแแแ แแกแแ แแแกแแแแก แแแฆแแแ แแแแแแ แแแแแแแแแก แแแกแแฆแฌแแแแ, แแแ แแแ แแ แแแ แแแแแแ แแแขแ แแแ แกแแแแแ แแกแ แแ แแ แแก.
- แฃแคแ แ แกแฌแ แแคแ แแฆแแแแแแกแ แแ แแแแ แแแแ แแแแซแแแแแแกแแแแก, แแแแแแแชแแแแแ แฃแแแ แแแแแแงแแแแ แแแฆแแแ แแแแแแ แแแแแแแแแก แแ แแแชแแแ (HOP).
- แแแแแชแฎแแแแก แแแแแแ, NOP แแแแแฎแแแก: แกแแแแแแแ แฎแ-แขแงแแก แแฆแ แแชแฎแแแก, แแญแแแ แ แแแแแขแแ แแแแก, แกแแฆแ แแแ แแแแแแแก แจแแแแฌแแแแแก แแ แจแแกแ แฃแแแแแก/แขแ แแแแแชแแแก แแแแแแแแแก.
- แแแแแแงแแแแ แฉแแแแแ NOR-แแก แแแแแแแขแแ แแแแแงแแคแแแก แแแแแ ะธ livenessProbe แแฃแแแ แแแขแแแ.
แ แ แแ แแก แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แจแแแแแแ?
แแแกแแแกแแแแก แแ แแขแแแฃแแ แแ แซแแแแแ แฎแแแแแกแแฌแแแแแ แแแแแแแชแแแก แจแแแฃแจแแแแแแกแแก, แซแแแแแ แแแแจแแแแแแแแแแ แแแคแแฅแ แแ แแกแแ แแกแแแฅแขแแ, แ แแแแ แแชแแ แจแแชแแแแแก แขแแแแ แแแขแแแ. แแแแแชแฎแแแ แแแแแแแ แจแแชแแแแแก แขแแแแ แแแขแแ, แแฃ แแก แกแฌแ แแคแแ แแฆแแแแแ แแแ แชแฎแแกแแแ. แขแแแแฃแ แ แฆแ แฃแแแแแแแ แแแแแแแชแแ แแงแแแแแก แแแแ แแกแแ แแแกแแแแก แแ แฅแแขแแฅแขแฃแ แแก - แกแแแแช แแแแแแฃแแ แแแแแแแแแขแ แแแแแแกแแแฃแแแ แชแแแแ แแแแขแแแแแ แจแ. แแ แแแแกแแแแแก, แ แแ แแแ แฌแแฃแแแแ, แ แแ k8s-แแ แแแแแแแชแแ แซแแแแแ แฎแแแแแกแแฌแแแแแแ แแแแกแขแแ แแก แแแแแแแแก แแ แแก, แแฅแแแ แฃแแแ แแแแชแแแก แแแ แแแแฃแแ แจแแแแแแแแ. แแแ แจแแ แแก แแ แแก แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แจแแแแแแ. แแก แแแแกแแแฆแแ แแแก, แแฃ แ แแแแ แแชแแแแแแก แแแแแแแชแแ k8-แก, แ แแ แแก แฏแแแแ แแแแแ. แแก แแ แแก แแ แ แแฎแแแแ แแแคแแ แแแชแแ แแแแก แจแแกแแฎแแ, แแฃแจแแแแก แแฃ แแ แ แแแแ, แแ แแแแ แแแแแ, แแฃ แ แแแแ แแฆแแแก แแ แแแกแฃแฎแแแก แแฎแแแแแแก. แ แแช แฃแคแ แ แแแขแ แแชแแก Kubernetes-แแ แแแแแก แฏแแแแ แแแแแแแก แจแแกแแฎแแ, แแแ แฃแคแ แ แญแแแแแแฃแ แแแแแฌแงแแแขแแแแแแแก แแฆแแแก แแก แขแ แแคแแแแก แแแ แจแ แฃแขแแแแชแแแกแ แแ แแแขแแแ แแแแก แแแแแแแแกแแแแก แจแแกแแฎแแ. แแแ แแแแ, แแแฆแแแ แแแแแแ แแแแแแแแแก แแ แแแชแแแ แกแแจแฃแแแแแแก แแซแแแแก แแแแแแแชแแแก แแ แแฃแแแ แฃแแแกแฃแฎแแก แแแแฎแแแแแแก.
แแแฆแแแ แแแแแแ แแแแแแแแแก แแ แแแชแแแ (HOP)
แแแฆแแแ แแแแแแ แแแแแแแแแก แแ แแแชแแแ แแ แ-แแ แแแ
แแแ แแแ แจแแแฃแจแแแแแฃแแ แฆแ แฃแแแแแแแ แแแแแแแชแแ แแฆแ แแชแฎแแแก แแแแแก แซแแ แแแแ แแแแแแแแแก แกแขแแแแแ แขแฃแแ I/O แแแแแแแแแก STDERR แแ STDOUT แแแแแงแแแแแแ. แจแแแแแ แแแแแก แแแแฎแแแ แ แกแแ แแแกแ, แแแแแแแแแ filebeat, logstash แแ fluentd, แ แแแแแแช แแฌแแแแก แแฃแ แแแแแแก แชแแแขแ แแแแแแแฃแ แแแแแขแแ แแแแแก แกแแกแขแแแแก (แแแแแแแแแ, แแ แแแแแ) แแ แแฃแ แแแแแแแก แจแแแ แแแแแแก แกแแกแขแแแแก (ELK แแ แแแ แแแฃแแ แแแแแแแฅแขแ). แฅแแแแแ แแแชแแแฃแแ แแแแแ แแแ แแแแฉแแแแแแก, แแฃ แ แแแแ แแฃแจแแแแก แฆแ แฃแแแแแแแ แแแแแแแชแแ แฏแแแแ แแแแแแแก แขแแกแขแแก แแแแฃแจแแกแ แแ แแแฆแแแ แแแแแแ แแแแแแแแแก แแ แแแชแแแแก แแแฎแแแแแ.
แ แแแแ แแแแแแแงแแแแ แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แแแแฃแจแ Kubernetes-แจแ?
แงแฃแแแแแ, k8s แแแแแขแ แแแแแก แแแแแแแก แกแขแแขแฃแกแก แแ แ-แแ แแ แแแแขแ แแแแ แแก แแแแแงแแแแแแ (
แฉแแแแก แแแแแแแแจแ, k8s แแแแแแแก แคแฃแแฅแชแแแแแ แแแแก แจแแแแฌแแแแ. แแ แขแแแแก แแแแแแแฌแแแแแกแแก, แแฃแแแแแขแ แแฃแแแแแแ แแแแฌแแแแก แแ แแชแแกแแก แแแแแแแ แแแแแก แแแแขแแแแแ แจแ. แ แแแแ แช แแ แแแแแแแก, แ แแ แแ แแชแแกแ แจแแฉแแ แแแฃแแแ, แแแแแแฎแแแแก แแแก. แแฃ แจแแชแแแแแก แแแแแแ แแแ แจแแกแแซแแแแแแแ แแแแแแแชแแแก แฃแแ แแแแ แแแแแขแแแ แแแแ, แแ แแ แแแ แแแ แจแแฅแแแแแแ แแแแแกแแแแ แ แจแแชแแแแแก แแแแแ แแแแกแแแแก, แแแจแแ แแ แแชแแกแแก แฏแแแแ แแแแแแแก แจแแแแฌแแแแ แแ แแก แงแแแแแคแแ แ, แ แแช แแญแแ แแแแแ NOP-แแก แแ แฏแแแแ แแแแแแแก แขแแกแขแแก แแแแฃแจแแก แจแแกแแแแแแกแแ. แแ แแแแแ แแ แกแแแฌแฃแฎแแ แแ, แ แแ แงแแแแ แจแแชแแแแ แแ แแฆแแแแคแฎแแ แแแ แแแแแขแแแ แแแแ. แแ แจแแแแฎแแแแแจแ, k8s แแแแแแแแแ 2 แฃแคแ แ แฆแ แแ แแแแก แแแแแแ แแแแแแจแแ แแแฃแแ แแ แแแแแแแแแก แแแกแแแแแแแ:
LivenessProbe
แแ แแก livenessProbe kubelet แแฎแแ แชแแแแแแก 3 แขแแแแก แจแแแแฌแแแแแก: แแ แ แแฎแแแแ แแแแกแแแฆแแ แแแก, แแฃแจแแแแก แแฃ แแ แ แแแแ, แแ แแแแ แแ แแก แแฃ แแ แ แแก แแแแ, แแแแฆแแก แแ แแแแแแแขแฃแ แแ แฃแแแกแฃแฎแแก แแแแฎแแแแแแก:
- แแแแงแแแแ HTTP แแแแฎแแแแ แแแแแ. แแแกแฃแฎแ แฃแแแ แจแแแชแแแแแก HTTP แกแแแแกแฃแฎแ แแแแก 200-แแแ 399-แแแ แแแแแแแแแจแ. แแแ แแแแ, แแแแแแ 5xx แแ 4xx แแแฃแแแแแแแ, แ แแ แแแแก แแฅแแก แแ แแแแแแแแ, แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแ แแชแแกแ แแแแแแแแ แแแแก.
- แแแแแแแก แจแแกแแแแฌแแแแแแ แแ แแกแแแแแแ แแแ HTTP แกแแ แแแกแแแแ (แแแแแแแแแ, Postfix แคแแกแขแแก แกแแ แแแ แ), แแฅแแแ แฃแแแ แแแแแงแแ แแ TCP แแแแจแแ แ.
- แจแแแกแ แฃแแแ แแแแแแแแฃแ แ แแ แซแแแแแ แแแแแกแแแแก (แจแแแแแแแแ). แจแแแแฌแแแแ แฌแแ แแแขแแแฃแแแ แแแแแแแ, แแฃ แแ แซแแแแแแก แแแกแ แฃแแแแแก แแแแ แแ แแก 0.
แแแแแแแแ แแแแกแ, แแฃ แ แแแแ แแฃแจแแแแก แแก. แจแแแแแแ pod แแแแแแ แขแแแ แจแแแชแแแก NodeJS แแแแแแแชแแแก, แ แแแแแแช แฃแจแแแแก 500 แจแแชแแแแแก HTTP แแแแฎแแแแแแแ. แแแแกแแแแแก, แ แแ แแแแ แฌแแฃแแแแ, แ แแ แแแแขแแแแแ แ แแแแแขแแแ แแฃแแแ แแกแแแ แจแแชแแแแแก แแแฆแแแแกแแก, แแแงแแแแแ 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
แแก แแ แแคแ แแ แแแแกแฎแแแแแแแ แแแแแกแแแแ แ แกแฎแแ pod แแแแแแ แขแแแแกแแแ, แแแแ แแ แฉแแแ แแแแแขแแแ แแแแแฅแขแก .spec.containers.livenessProbe
... แฒแแ แแแแขแ แ httpGet
แแฆแแแก แแแแก, แ แแแแแแแช แแแแแแแแแ HTTP GET แแแแฎแแแแ (แฉแแแแก แแแแแแแแจแ แแก แแ แแก /
, แแแแ แแ แกแแแ แซแแแ แกแชแแแแ แแแจแ แจแแแซแแแแ แแงแแก แ แแฆแแช แแกแแแแกแ /api/v1/status
). แแแแแ แแ แแ livenessProbe แแฆแแแก แแแ แแแแขแ แก initialDelaySeconds
, แ แแแแแแช แแแแแแแก แแแแแแแฌแแแแแก แแแแ แแชแแแก แแแแแแแแก แฌแแแแแแก แแแแกแแแฆแแ แฃแ แ แแแแแแแแแก. แแแแแแแแแแ แกแแญแแ แแ, แ แแแแแ แแแแขแแแแแ แก แแ แ แกแญแแ แแแแ แแแกแแฌแงแแแแ แแ แฎแแแแฎแแ แฉแแขแแแ แแแแกแแก แแก แแแ แแแแฃแแ แแ แแแ แแแฃแฌแแแแแแแ แแฅแแแแ.
แแ แแแ แแแแขแ แแก แแแแกแขแแ แแ แแแแแกแแงแแแแแแแ แแแแแแงแแแแ:
kubectl apply -f pod.yaml
แ แแแแแแแแ แฌแแแแก แจแแแแแ แจแแแแซแแแแ แจแแแแแฌแแแ แแแแแก แจแแแแแ แกแ แจแแแแแแ แแ แซแแแแแแก แแแแแงแแแแแแ:
kubectl describe pods node500
แแแแแกแแแแแก แแแกแแกแ แฃแแก แแแแแแแ
แ แแแแ แช แฎแแแแแ, livenessProbe-แแ แฌแแแแแฌแงแ HTTP GET แแแแฎแแแแ, แแแแขแแแแแ แแ แแแแแฃแจแแ แจแแชแแแแ 500 (แ แแช แแแแ แแแ แแแแแฃแแ แแงแ) แแ kubelet-แแ แแแแแขแแแ แแ แแแ.
แแฃ แแแแแขแแ แแกแแแ, แ แแแแ แแแแ แแแ แแแแ NideJS แแแแแแแชแแ, แแฅ แแ แแก app.js แแ Dockerfile, แ แแแแแแแช แแแแแแงแแแแก:
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" ]
แแแแจแแแแแแแแแแ แแฆแแแแจแแแก แแก: livenessProbe แแแแแขแแแ แแแแก แแแแขแแแแแ แก แแฎแแแแ แแ แจแแแแฎแแแแแจแ, แแฃ แแก แแแ แแแฎแแ แฎแแแแ. แแฃ แแแแแขแแแ แแแ แแ แแแแแแกแฌแแ แแแก แจแแชแแแแแก, แ แแแแแแช แฎแแแก แฃแจแแแก แแแแขแแแแแ แแก แแแจแแแแแก, แแฃแแแแแขแ แแแ แจแแซแแแแก แแ แแแแแแแก แแแแแกแแกแฌแแ แแแแแ แแแฅแแแแแแแก.
แแแแแงแแคแแแก แแแแแ
ReadinessProbe แแฃแจแแแแก แแกแแแ, แ แแแแ แช livenessProbes (GET แแแแฎแแแแแแ, TCP แแแแฃแแแแแชแแแแ แแ แแ แซแแแแแแแแก แจแแกแ แฃแแแแ), แแแ แแ แแ แแแแแแแแแก แแฆแแแคแฎแแ แแก แแแฅแแแแแแแแแกแ. แแแแขแแแแแ แ, แ แแแแแจแแช แแฆแแแฉแแแแแแ แฃแแแแ แแกแแแ, แแ แแแแแฎแแแแแ, แแแแ แแ แแแแแแ แแแฃแแแ แจแแแแแแแแแ แขแ แแคแแแแกแแแ. แฌแแ แแแแแแแแแ, แ แแ แแ แ-แแ แแ แแแแขแแแแแ แ แแฎแแ แชแแแแแแก แแแแ แแแแแแแแแก แแ แแซแแแ แแแขแแแ แแแแก แฅแแแจ แแแงแแคแแแ, แ แแช แแฌแแแแก แ แแแแแ แแแแก แแ แแแก แแ แแแก. livenessProbe-แแก แจแแแแฎแแแแแจแ, แแแกแฃแฎแแก แฎแแแแแกแแฌแแแแแแแแก แจแแแแฌแแแแ แแแแฅแแแแแแแ (timeoutSeconds แจแแแแฌแแแแแก แแแ แแแแขแ แแก แแแจแแแแแแ), แ แแก แจแแแแแแแช kubelet แแแแแขแแแ แแแแก แแแแขแแแแแ แก. แ แแแแกแแช แแแแฌแงแแแ, แแแแขแแแแแ แ แแฌแงแแแก แ แแกแฃแ แกแแ แแแขแแแกแแฃแ แ แแแแชแแแแแแก แจแแกแ แฃแแแแแก แแ แฎแแแแฎแแ แแขแแแ แแแแ. แแก แจแแแซแแแแ แแงแแก แแ แแขแแแฃแแ แแ แแแแแแแชแแแแแกแแแแก, แ แแแแแแกแแช แ แแแแแ แแแแก แกแแฉแฅแแ แ แกแญแแ แแแแแ. แแแแแแแแแ, แแแแฅแแแ แแแแแ แแแแแแแ แกแแ แแแ แแก แแแกแฃแฎแก, แแแกแฃแฎแ แแแแแแแแแก - แแ แแแแฅแแแ แแแแ แแแจแ แแแงแแแแ.
แแแแแ แแแแฌแแ แแ redinessProbe แแแแแแ แขแแแ, แ แแแแแแช แแแแงแแแแแก GET แแแแฎแแแแแก แแแกแฃแฎแแก แแ แแก แแ แแฃแแแขแแก แแ แ แฌแแแแกแ, แฎแแแ แแแแแแแชแแ แฃแแแกแฃแฎแแแก GET แแแแฎแแแแแก 5 แฌแแแแก แจแแแแแ. pod.yaml แคแแแแ แแกแ แฃแแแ แแแแแแงแฃแ แแแแแแก:
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
แแแแแ แแแแแแแแแกแแ pod kubectl-แแ:
kubectl apply -f pod.yaml
แแแแแ แแแแแแแแแ แ แแแแแแแแ แฌแแแก แแ แจแแแแแ แแแแฎแแ, แ แแแแ แแฃแจแแแแแ ReadinessProbe:
kubectl describe pods nodedelayed
แแแแแกแแแแก แแแแแก แฎแแแแแ, แ แแ แแแแแแ แแ แแแแแแแ แแกแแแแกแแ
แ แแแแ แช แฎแแแแแ, kubectl-แแ แแ แแแแแขแแแ แแ แแแแ, แ แแแแกแแช แจแแแแฌแแแแแก แแ แ 2 แฌแแแก แแแแแแญแแ แแ. แแแแก แแแชแแแแ, แแแ แแแแฃแฅแแ แแแแฎแแแแ. แจแแแแแแแแแ แแแแฃแแแแแชแแแแ แแแแแแแกแแแแ แแแแฃแแแ แกแฎแแ, แกแแแฃแจแแ แแแแแแแ.
แแแแแแแแแกแฌแแแแ, แ แแ แแฎแแ, แ แแแแกแแช pod แฉแแแแขแแแ แแฃแแแ, kubectl แแแ แจแ แฃแขแแแก แแแแแ แแแฎแแแก แแแก: GET แแแแฎแแแแแแแ แแแกแฃแฎแแแ แแฆแแ แแ แแก แแแแแแแแแแฃแแ.
แจแแแแ แแแแกแแแแก, แฅแแแแแ แแแชแแแฃแแแ แจแแชแแแแแ app.js แคแแแแ:
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
แฆแ แฃแแแแแแแ แแแแแแแชแแแแแก แแแแแฉแแแแแแ แแฃแ แแแแแแ แแงแ แแแแแแแชแแแก แฏแแแแ แแแแแแแก แแแแแขแแ แแแแแกแ แแ แจแแแแฌแแแแแก แซแแ แแแแแ แกแแจแฃแแแแแ. แแฃแแชแ, แแ แแ แกแแแแแแ แ แแแแ แแแแแ แแฅแขแแ แแแแแ แแแฅแแแแแแแก แแแขแแ แแแแก แกแแจแฃแแแแแ. แแฃแ แแแแแแ แแฆแแกแแช แแแแแกแแแแแแ; แแกแแแ แฃแแแ แจแแแ แแแแแก แแ แแแแแแแแแแก แแฃแ แแแแแแแก แจแแแ แแแแแแก แกแแกแขแแแแจแ แกแแแแแแแแ แกแแขแฃแแชแแแแแก แแแกแแแแแแแแแแแแ แแ แแแแแฌแงแแแขแแแแแแก แแแกแแฆแแแแ. [แแก แงแแแแแคแแ แ แจแแแซแแแแ แแแแแแแแก แฆแ แฃแแแแแแแ แแแแแแแชแแแแแก แแแ แแจแ, แแแแแแแแแ, แแแแแขแแก แแแแแงแแแแแแ, แแแแ แแ k8-แแ แแก แแแแ แแ แฃแคแ แ แแแแแแ แแแฎแแ :) - แ แแแแฅแขแแ แแก แจแแแแจแแแ. ]
แแฆแแก แจแแกแฌแแ แแแแแ แแแแฅแแแก แ แแแแฃแ แแ แแจแ แฃแแแ แแแแฎแแ แชแแแแแแก, แแแแขแแ แแแแแแแชแแแแ แแฆแแ แฃแแแ แแงแแก แจแแแ แงแฃแแแแ. แแ แ, แแแ แฃแแแ แแฉแแแแแ แกแแแแแแ แฌแแ แขแแแแแ, แ แแแแแแแช แกแแจแฃแแแแแแก แแซแแแแก แแแแแขแแ แแแแแก แกแแกแขแแแแแก แแแแแฎแแแแ แแ แจแแแแ แแแแ แฆแแ แแแฃแแ แแแแแชแแแแแ แแ แแชแแกแแแแก แแแแแแแ แแแแแก แจแแกแแฎแแ, แ แแแ แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ แแงแแกแแแ แแ แฃแแแกแฃแฎแแ. แแแแก แแฌแแแแแ แจแแกแ แฃแแแแแก แขแแกแขแแก แแแแแแแแก แแแแฃแจแ, แ แแแแแแช แแแฐแงแแแแ แแแฆแแแ แแแแแแ แแแแแแแแแก แแ แแแชแแแก (HOP).
Kubernetes แกแขแแแแแ แขแฃแแแ แแแแแแแแแ แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก 2 แขแแแก: ReadinessProbe แแ livenessProbe. แแ แแแ แแงแแแแแก แแแแแ แขแแแแก แจแแแแฌแแแแแแก (HTTP GET แแแแฎแแแแแแ, TCP แแแแฃแแแแแชแแแแ แแ แแ แซแแแแแแแแก แจแแกแ แฃแแแแ). แแกแแแ แแแแกแฎแแแแแแแแแ แแแแ, แแฃ แ แ แแแแแฌแงแแแขแแแแแแแก แแฆแแแแ แฆแ แซแแแแแแก แแ แแแแแแแแแก แกแแแแกแฃแฎแแ. livenessProbe แแแแแขแแแ แแแแก แแแแขแแแแแ แก แแ แแแแแแ, แ แแ แจแแชแแแแ แแฆแแ แแแแแแแ แแแแ แแ ReadinessProbe แแแแแแ แแแก แแแแก แจแแแแแแแแแ แขแ แแคแแแแกแแแ, แกแแแแ แแ แแแแแแแก แแแแแแ แแ แแแแแแ แแแแ.
แแแแแชแฎแแแแก แกแฌแแ แ แแแแแแแ แฃแแแ แแแแชแแแแแก แแ แแแ แขแแแแก แจแแแแฌแแแแแก แแ แฃแแ แฃแแแแแงแแก, แ แแ แแกแแแ แแแ แแแแแแ แกแแแแแ แแก แแแแแชแแแแแก, แแแแกแแแฃแแ แแแแ แแแจแแ, แ แแแแกแแช แฎแแแแ แแแแแแแแแแกแ. แแแ แแกแแแ แฃแแแ แแฉแแแแแก แแฃแชแแแแแแแ API แกแแแแแแ แฌแแ แขแแแแแ, แ แแแแแแแช แฃแแ แฃแแแแแงแแคแแ แแแแแขแแ แแแแแก แกแแกแขแแแแก (แแ แแแแแ) แฏแแแแ แแแแแแแก แแแแจแแแแแแแแแ แแแขแ แแแแแแ.
แฌแงแแ แ: www.habr.com