แแแแแ แฏแแแ, แฐแแแ ! แแ แแแ แแ แขแแ แแแ แแแแจแแแ, แกแแกแขแแแแก แแแแแแแกแขแ แแชแแแก แแฃแแแแก แฎแแแแซแฆแแแแแแ . แฉแแแ แแแฅแแแแ แแ แแแแแ แแฎแแแ แแ แแแฃแฅแขแแก แแแจแแแแ แแแกแฃแแ แฌแแแก แแแแแแแแแแแจแ. แฉแแแ แแแแแแแแ แแแแแแ แฌแแฃแแแแแแ, แ แแ API แกแแ แแแกแแแ แแงแ แแแแแแแ แแแกแจแขแแแแ แแแแแ, แจแแชแแแแแก แขแแแแ แแแขแฃแแ แแ แแแแ แแงแ แแแแฎแแแ แแแแแก แแแขแแแ แแแแก แกแฌแ แแคแ แแ แแแกแแแแก. แฉแแแแ แแแแขแคแแ แแ แแแแแ แแแแแ OpenStack-แแ แแ แแแแแ แแแแฎแ แแ, แ แ แแแแแแแแแขแแแแก แฎแแ แแแแแแแก แขแแแแ แแแขแแแแก แแ แแแแแแแแ แแแฅแแแแ แแแแแญแ แ, แ แแ แแแแแฆแแ แจแแชแแแแแก แขแแแแ แแแขแฃแแ แกแแกแขแแแ. แแคแแฅแ แแ, แแก แกแแแแขแแ แแกแ แแฅแแแแ แแแแแแแก, แแแแช แแกแแแ แแแแแแ แแแก แแ แแแฃแฅแขแแแก OpenStack-แแ.
แแแแขแคแแ แแแก แกแแแ แแ แจแแคแแ แฎแแแแก แขแแแแ แแแขแแแ แจแแแแแแ แแแกแ แแแแแแแแแขแแแแก แแแแกแขแแฃแ แแแแกแแแ. แแแแขแแ แแขแแแแแ แแแแ แแแแแแแแ แงแแแแ แแ แแแแแก, แกแแแแช แ แแกแแแแ แแแแแแแแแแแแ แแ แแแแฎแฃแ แแ.
แแ แแกแขแแ แแแก แแแแแ แแแ แกแแ, แ แแแแแก แแแ แแแแแแ แฌแงแแ แ แแงแ Uptime day 4 แแแแคแแ แแแชแแแก แแแฎแกแแแแแ, แ แแแแแแช แแ แแแแแแแแฃแแ แแงแ แแแแ , แจแแแแซแแแ แแแฎแ .
แคแแแแแฃแ แ แแ แฅแแขแแฅแขแฃแ แแก แแแแซแแแแแ
MCS แฆแ แฃแแแแก แกแแฏแแ แ แแแฌแแแ แแฎแแ แแแคแฃแซแแแแฃแแแ แแ Tier III แแแแแชแแแแ แชแแแขแ แจแ, แแแ แจแแ แแก แแ แแก แกแแแฃแแแ แ แแฃแฅแ แแแญแแแแแแ, แแแชแฃแแแ แคแแแแแฃแ แแแแแแ แกแฎแแแแแกแฎแแ แแแ แจแ แฃแขแแ, 200 แแแแขแ/แฌแ แแแแขแแ แฃแแแ แแแแแแแ. III แแแแ แฃแแ แฃแแแแแงแแคแก แจแแชแแแแแก แขแแแแ แแแขแแแแก แแฃแชแแแแแแ แแแแแก แคแแแแแฃแ แ แแแคแ แแกแขแ แฃแฅแขแฃแ แแกแแแแก.
แแฃแฅแ แแแญแแ แแแชแฃแแแ แ แแแแ แช แคแแแแแฃแ , แแกแแแ แแแแแแฃแ แแแแแแ. แแ แฎแแก แแแฏแแแจแแแก แแ แแชแแกแ แแแแแแแ แแแแแ แแงแ, แแ แแแแแแแแ แฌแแ แแแแจแแ แแ แฉแแแ แแฃแแแแแแ แแแฃแแฏแแแแกแแแ แแแแฃแแแแแชแแแก แแแแแชแแแแ แชแแแขแ แแแก แจแแ แแก.
แแแแแแแแแ, แแ แช แแกแ แแแแ แฎแแแก แฌแแ, แแ แ-แแ แ แแแแแชแแแแ แชแแแขแ แแแ แแฎแแแก แญแแแฃแ แฆแแแจแ แแฃแจแแแแแกแแก, แแฅแกแแแแแขแแ แแ แแแขแแฎแ แแแแ แแ แแ แแแแแก แจแแแแแ แแงแ แ แแแแ แช แแแแแแ แ, แแกแแแ แกแแ แแแแ แแ แแแขแแแฃแ แ แแแแแแ. แฉแแแแ แจแแชแแแแแก แขแแแแ แแแขแฃแแ แกแแแแแฃแแแแแชแแ แแ แฎแ แแแแแชแแแแ แชแแแขแ แแแ แแฆแแแฉแแแ แแแฃแชแแแแ แแ แ แแแแแแขแจแ, แญแแจแ. แจแแกแแแแแแกแแ, แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแฌแแแ แแแแแแ แแแ. แฉแแแ แแแแแแแขแแแแ แแแกแแแแแแ แแ แแแแแฆแแ แแแแแ แ แแแ แฅแแแแแแแแ, แแแ แจแแ แแก แแแแแขแแแแแ แแแขแแแแก แแแงแแแแแ แแแแแแแแ แ แญแแแฃแ แฆแแแจแ.
แแแแแชแแแแ แชแแแขแ แแแจแ แแ แแก แกแแแแแฃแแแแแชแแ แแ แแแแแแแ แแแแก แงแแคแแแก แแฃแแฅแขแแแ, แ แแแแแแแแแแช แฉแแแ แแฃแแแแแแแ แฉแแแแก แแ แแคแแฅแกแแแก BGP-แแก แกแแจแฃแแแแแแ. แแแแแแฃแแ แฅแกแแแแก แแแแแ แแฃแแแแแกแแแแก แแ แฉแแฃแแแ แกแแฃแแแแแกแ แแแขแ แแแ, แ แแช แกแแจแฃแแแแแแก แแซแแแแก แกแฎแแแแแกแฎแแ แแแแแแขแก แฃแแ แฃแแแแแงแแก แแแแจแแ แแก แกแแฃแแแแแกแ แฎแแ แแกแฎแ. แแฃ แแ แแ แแ แแแแแแแ แแก แแแจแแแแแแ แแแแฃแแแแแชแแ แจแแฌแงแแแแ, แฉแแแ แฎแแแแฎแแ แแแจแแแแแ แฉแแแแก แแแ แจแ แฃแขแแแแชแแแก แฎแแแแแกแแฌแแแแแ แแ แแแแแแแ แแแแก แแแจแแแแแแ.
แแฃ แแ แแแแแแแ แ แแแ แฎแแ แฎแแแแ, แฉแแแ แแแขแแแแขแฃแ แแ แแแแแแแแแแ แ แจแแแแแแแ. แแ แ-แแ แแ แแแแแชแแแแ แชแแแขแ แแก แแแฃแแแ แแแแแแก แจแแแแฎแแแแแจแ, แฉแแแ แแแแฅแแก แฉแแแแ แกแแ แแแกแแแแก แกแแ แแแกแแแฃแ แ แแกแแ แแแแ แ แแแแแชแแแแ แชแแแขแ แจแ, แ แแแแแแช แแฆแแแก แแแแ แแแขแแแ แแแแก.
แคแแแแแฃแ แ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแซแแแแแ
แ แแกแแช แแแงแแแแแ แแแแแแแชแแแก แแแแแก แจแแชแแแแแก แขแแแแ แแแขแแแแกแแแแก
แฉแแแแ แกแแ แแแกแ แแแแแฃแแแ แฆแแ แฌแงแแ แแก แ แแแแแแแแ แแแแแแแแแขแแ.
ExaBGP แแ แแก แกแแ แแแกแ, แ แแแแแแช แแฎแแ แชแแแแแแก แ แแ แคแฃแแฅแชแแแแก BGP-แแ แแแคแฃแซแแแแฃแแ แแแแแแแฃแ แ แแแ แจแ แฃแขแแแแชแแแก แแ แแขแแแแแแก แแแแแงแแแแแแ. แฉแแแ แแฅแขแแฃแ แแ แแแงแแแแแ แแแก แแแแ แกแแแจแ แจแแงแแแแแแ IP แแแกแแแแ แแแแแก แ แแแแแแแ แแแแกแแแแก, แ แแแแแแแแแช แแแแฎแแแ แแแแแแ แฌแแแแแแแ API-แแ.
HAProxy แแ แแก แแแฆแแแ แแแขแแแ แแแแก แแแแแแกแแ แ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแแคแแแฃแ แแ แแ แซแแแแแ แแแฅแแแแ แขแ แแคแแแแก แแแแแแแแกแแแแก แฌแแกแแแ OSI แแแแแแแก แกแฎแแแแแกแฎแแ แแแแแแ. แฉแแแ แแแงแแแแแ แแแก แงแแแแ แกแแ แแแกแแก แฌแแแแจแ แแแกแแแแแแแกแแแแแ: แแแแแชแแแแ แแแแแแ, แจแแขแงแแแแแแแแแแก แแ แแแแ แแแ, API แกแแ แแแกแแแ, แแแ แกแแ แแแกแแแ, แฉแแแแ แจแแแ แแ แแแฅแขแแแ - แงแแแแแคแแ แ HAProxy-แแก แฃแแแ แแแแก.
API แแแแแแแชแแ โ แแแแแแจแ แแแฌแแ แแแ แแแ แแแแแแแชแแ, แ แแแแแแแช แแแแฎแแแ แแแแแ แแแ แแแแก แแแแแก แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแ แกแแ แแแกแก.
แแฃแจแ แแแแแชแฎแแแ (แจแแแแแแแจแ แฃแแ แแแแ แแฃแจแ) - OpenStack แกแแ แแแกแแแจแ แแก แแ แแก แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแแแ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแขแแแแ API แแ แซแแแแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแจแ. แแแแแแแแแ, แแแกแแแก แจแแฅแแแ แฎแแแแ แแฃแจแแแจแ, แฎแแแ แจแแฅแแแแก แแแแฎแแแแ แฎแแแแ แแแแแแแชแแแก API-แจแ.
แกแขแแแแแ แขแฃแแ OpenStack แแแแแแแชแแแก แแ แฅแแขแแฅแขแฃแ แ
แกแแ แแแกแแแแก แฃแแแขแแกแแแ, แ แแแแแแแช แจแแแฃแจแแแแแฃแแแ OpenStack-แแกแแแแก, แชแแแแแแก แแแแชแแแก แแ แแ แแแ แแแแแแ. แกแแ แแแกแ, แ แแแแ แช แฌแแกแ, แจแแแแแแ 2 แแแฌแแแแกแแแ: API แแ แแฃแจแแแแแ (backend executors). แ แแแแ แช แฌแแกแ, API แแ แแก WSGI แแแแแแแชแแ แแแแแแจแ, แ แแแแแแช แแฎแกแแแแ แแ แแแแแฃแแแแแแแแ แแ แแชแแกแแก แกแแฎแแ (แแแแแแ), แแ แแแ Nginx แแ Apache แแแ แกแแ แแแ แแก แแแแแงแแแแแแ. API แแแฃแจแแแแแก แแแแฎแแแ แแแแแก แแแแฎแแแแแก แแ แแแแแกแชแแแก แจแแแแแแ แแแกแขแ แฃแฅแชแแแแก แแฃแจแ แแแแแแแชแแแก แจแแกแแกแ แฃแแแแแแ. แแแแแ แแชแฎแแ แฎแแแแ แจแแขแงแแแแแแแแแแก แแ แแแแ แแก แแแแแงแแแแแแ, แ แแแแ แช แฌแแกแ, RabbitMQ, แกแฎแแแแ แชแฃแแแ แแ แแก แแฎแแ แแแญแแ แแแ. แ แแแแกแแช แจแแขแงแแแแแแแแแ แแแแฆแฌแแแก แแ แแแแ แก, แแแ แแแฃแจแแแแแแ แแฃแจแแแ แแ แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ แฃแแ แฃแแแแแ แแแกแฃแฎแก.
แแก แแแ แแแแแแ แแแแชแแแก แฌแแ แฃแแแขแแแแแแแก แแแแแแ แแแฃแ แกแแแ แแ แฌแแ แขแแแแแก: RabbitMQ แแ แแแแแชแแแแ แแแแแก. แแแแ แแ RabbitMQ แแแแแแ แแแฃแแแ แแ แ แกแแ แแแกแจแ แแ, แแแแ แแฃแแแ, แจแแแซแแแแ แแงแแก แแแแแแแแฃแแแฃแ แ แแแแแแฃแแ แกแแ แแแกแแกแแแแก. แแกแ แ แแ, MCS-แจแ แฉแแแ แแแฅแกแแแแแฃแ แแ แแแแแแงแแคแ แแ แกแแ แแแกแแแก; แแแแแแฃแแ แแแแแแแแฃแแแฃแ แ แแ แแแฅแขแแกแแแแก แแฅแแแแ แชแแแแ แแแแแชแแแแ แแแแแก, แชแแแแ RabbitMQ. แแก แแแแแแแ แแแ แแแ, แ แแแแแ แแแแแแ แ แแแฃแชแแแ แฌแแ แขแแแจแ แแแแ แแแก แจแแแแฎแแแแแจแ, แแแแแ แกแแ แแแกแ แแ แแ แคแฃแญแแแแ, แแ แแแแ แแฎแแแแ แแแฌแแแ.
แแฃแจแแแ แแแแแแแชแแแแแก แ แแแแแแแแ แจแแฃแแฆแฃแแแแแ, แแแแขแแ API-แก แจแแฃแซแแแ แแแแแแแ แแแแคแแ แแแแแก แฐแแ แแแแแขแแแฃแ แแ แแแแแแกแแ แแแแก แฃแแแ, แ แแแ แแแแแ แแแก แจแแกแ แฃแแแแ แแ แจแแชแแแแแก แขแแแแ แแแขแแแ.
แแแแแแ แแ แกแแ แแแกแ แกแแญแแ แแแแก แแแแ แแแแแชแแแก แกแแ แแแกแจแ, แ แแแแกแแช แ แแฃแแ แแแแแแแแแแ แฃแแ แแแแ แแชแแแแ แฎแแแแ API-แแแกแ แแ แแฃแจแแแแแก แจแแ แแก. แแ แจแแแแฎแแแแแจแ แแแแแแงแแแแแ แแ แแแแแ แกแแแแแ แแแแแชแแ แชแแแขแ แ, แแแแกแขแแ แฃแแ แกแแกแขแแแ, แ แแแแ แแชแแ Redis, Memcache แแ แ.แจ., แ แแแแแแช แกแแจแฃแแแแแแก แแซแแแแก แแ แ แแฃแจแแแก แฃแแฎแ แแก แแแแ แแก, แ แแ แแก แแแแแแแแ แแแก แแแแแแแ (โแแแฎแแแ, แแ แแแแฆแแ แแกโ). แฉแแแ แแแงแแแแแ etcd. แ แแแแ แช แฌแแกแ, แแฃแจแแแ แแฅแขแแฃแ แแ แฃแ แแแแ แแแแแ แแแแแชแแแแ แแแแแกแแแ, แฌแแ แแ แแ แแแแฎแฃแแแแแ แแแคแแ แแแชแแแก แแฅแแแแ. แฉแแแ แแแงแแแแแ mariadb-แก, แ แแแแ แช แแแแแชแแแแ แแแแแก, แ แแแแแแช แแแแแแ แแแแก แแฃแแขแแแแกแขแแ แแแแกแขแแ แจแ.
แแก แแแแกแแแฃแ แ แแ แแฏแแ แแแ แกแแ แแแกแ แแ แแแแแแแแฃแแแ OpenStack-แแกแแแแก แแแแแแแ แแแฆแแแฃแแ แฌแแกแแ. แแก แจแแแซแแแแ แฉแแแแแแแแก แแแฎแฃแ แฃแ แกแแกแขแแแแ, แ แแแแแกแแแแกแแช แกแแแแแ แแแแก แแ แฎแแ แแแแแแแก แขแแแแ แแแขแแแแก แแแแแแแแ แกแแแแแแ แแจแแแ แแ. แแแแแแแแแ, API แจแแชแแแแแก แขแแแแ แแแขแแแแกแแแแก แกแแแแแ แแกแแ แแแ แฌแแ แแแแงแแแแ แแแแแแกแแ แ. แแฃแจแแแแก แกแแแแแ แแแ แแแแฆแฌแแแ แแแแ แ แแแแแแแแแก แแแแ แแแ.
แกแฃแกแขแ แฌแแ แขแแแ แแแแ แกแฅแแแแจแ แแ แแก RabbitMQ แแ MariaDB. แแแแ แแ แฅแแขแแฅแขแฃแ แ แแแกแแฎแฃแ แแแก แชแแแแ แกแขแแขแแแก.แแ แกแขแแขแแแจแ แแแแแ แแแแแแแฎแแแแ แงแฃแ แแแฆแแแ API แจแแชแแแแแแแก แขแแแแ แแแขแแแแแ.
Openstack แแแแแแแชแแแก แแ แฅแแขแแฅแขแฃแ แ. แฆแ แฃแแแแแแแ แแแแขแคแแ แแแก แแแแแแแแกแแแ แแ แจแแชแแแแแก แขแแแแ แแแขแแแ
HAProxy แแแแแแกแแ แแก แจแแชแแแแแกแแแแ แขแแแแ แแแขแฃแแ แแแแฎแแแแ ExaBGP-แแก แแแแแงแแแแแแ
แแแแกแแแแแก, แ แแ แฉแแแแ API-แแแ แแแกแจแขแแแฃแ แ, แกแฌแ แแคแ แแ แจแแชแแแแแกแแแแ แขแแแแ แแแขแฃแแ แแแแฎแแแแ, แแแ แฌแแ แแแงแแแแแ แแแขแแแ แแแแก แแแแแแกแแ แก. แฉแแแ แแแแ แฉแแแ HAProxy. แฉแแแ แแแ แแ, แแแก แแฅแแก แงแแแแ แกแแญแแ แ แแแฎแแกแแแแแแแแ แฉแแแแ แแแแชแแแแกแแแแก: แแแแแแแแกแแแ แ แแแแแแแแ OSI แแแแแแ, แแแ แแแแก แแแขแแ แคแแแกแ, แแแฅแแแแแแ แแ แแแกแจแขแแแฃแ แแแ, แแแแแแแแกแแแแก แแแแแแแแแก แแแแ แ แแแแแแแแ, แกแแกแแแก แชแฎแ แแแแแแก แแฎแแ แแแญแแ แ.
แแแ แแแแ แแ แแแแแแ, แ แแแแแแช แฃแแแ แแแแแแญแ แแก, แแงแ แแแแแ แแแแแแกแแ แแก แจแแชแแแแแก แขแแแแ แแแขแแแ. แแแแแแกแแ แแก แฃแแ แแแแ แแแงแแแแแ แแกแแแ แฅแแแแก แฌแแ แฃแแแขแแแแแแแก แฌแแ แขแแแก: แแแแแแกแแ แ แแจแแแแ แแ แกแแ แแแกแ แแจแแแแ. แแแแก แแแแแแแ แแกแแชแแแแแแแ, แฉแแแ แแแแแแแงแแแแ HAProxy ExaBGP-แแแ แแ แแแ.
ExaBGP แกแแจแฃแแแแแแก แแแซแแแแ แแแแแฎแแ แชแแแแแ แกแแ แแแกแแก แแแแแแแ แแแแแก แจแแแแฌแแแแแก แแแฅแแแแแแ. แฉแแแ แแแแแแแงแแแแ แแก แแแฅแแแแแแ HAProxy-แแก แคแฃแแฅแชแแแแแ แแแแก แจแแกแแแแฌแแแแแแ แแ แแ แแแแแแแแแก แจแแแแฎแแแแแจแ แแแแแ แแแ HAProxy แกแแ แแแกแ BGP-แแแ.
ExaBGP+HAProxy แกแฅแแแ
- แฉแแแ แแแแแกแขแแแแ แแแ แกแแญแแ แ แแ แแแ แแแฃแ แฃแแ แฃแแแแแงแแคแแก ExaBGP แแ HAProxy แกแแ แกแแ แแแ แแ.
- แฉแแแ แแฅแแแแ loopback แแแขแแ แคแแแกแก แแแแแแฃแ แกแแ แแแ แแ.
- แกแแแแแ แกแแ แแแ แแ แฉแแแ แแ แแแขแแ แคแแแกแก แแแแแญแแแ แแ แแกแ แแ แแแแแ แแแแ IP แแแกแแแแ แแก.
- แแแแ แ IP แแแกแแแแ แแ แ แแแแแแแ แแแฃแแแ แแแขแแ แแแขแจแ ExaBGP-แแก แกแแจแฃแแแแแแ.
แจแแชแแแแแแแก แขแแแแ แแแขแแแ แแแแฆแฌแแแ แกแแแแแ แกแแ แแแ แแ แแ แแ แแ แแแแแ IP แแแกแแแแ แแแก แ แแแแแแแ. แฅแกแแแแก แแแแแกแแแ แแกแแ, แแ แแ แแ แแแแแ แแแกแแแแ แแ แฎแแแแแกแแฌแแแแแแ แกแแแ แแแแกแฎแแแแแแฃแแ แจแแแแแแ แฐแแแแแแ. แ แแฃแขแแ แ แฎแแแแแก แกแแ แแแแแขแฃแ แแแ แจแ แฃแขแก, แแ แฉแแแก แแแแแแ แฃแแแฆแแแก แแ แแแ แแขแแขแก แกแแแฃแแแ แ แแแขแ แแแแก แกแแคแฃแซแแแแแ (แแก แฉแแแฃแแแแ แแ แแแแแ แแแ แแแแขแแ) แแ แขแ แแคแแแ แแแแแก แแฎแแแแ แแ แ แกแแ แแแ แแ.
HAProxy-แแก แแฃแจแแแแแกแแแ แแแแแแจแแ แแแฃแแ แแ แแแแแแแแแก แแ แกแแ แแแ แแก แแแฃแแแ แแแแแแก แจแแแแฎแแแแแจแ, ExaBGP แฌแงแแแขแก แแแ แจแ แฃแขแแก แแแแแชแฎแแแแแแก แแ แขแ แแคแแแ แจแแฃแคแแ แฎแแแแแ แแแแแแแก แกแฎแแ แกแแ แแแ แแ.
แแแ แแแแ, แฉแแแ แแแแแฆแฌแแแ แแแแแแกแแ แแก แจแแชแแแแแก แขแแแแ แแแขแแแแก.
HAProxy แแแแแแกแแ แแแแก แจแแชแแแแแก แขแแแแ แแแขแแแ
แกแฅแแแ แแ แแกแ แฃแแงแแคแแแ แแฆแแแฉแแแ: แฉแแแ แแแกแฌแแแแแ แ แแแแ แแแฏแแแจแแแ HAProxy, แแแแ แแ แแ แแแกแฌแแแแแ แ แแแแ แแแแแแแแแฌแแแแ แแแขแแแ แแแ แกแแ แแแกแแแจแ. แแแแขแแ, แฉแแแ แแแแแ แแแแแคแแ แแแแแ แแก แกแฅแแแ: แแแแแแแแแ แ แแแแแแแแ แแแแ IP แแแกแแแแ แแก แจแแ แแก แแแแแแแแกแแแแแ.
แแแแแแแแกแแแ DNS แแแฃแก BGP-แแ แแแคแฃแซแแแแฃแแ
แฉแแแแ HAProxy-แแก แแแขแแแ แแแแก แแแแแแแแกแแแแก แกแแแแแฎแ แแแแแฃแญแ แแแ แ แฉแแแ. แแฃแแชแ, แแแกแ แแแแแแ แแแ แกแแแแแแ แแแ แขแแแแ แจแแแซแแแแ, แ แแแแ แช แฉแแแ แแแแแแแแแ แแฅ.
แกแแแ แกแแ แแแ แแก แแแกแแแแแแแกแแแแแ แแแแญแแ แแแแแ 3 แแแแ แ IP แแแกแแแแ แแ แแ แแแ แแ แซแแแแ DNS. แแแแแแฃแแ แแก แแแกแแแแ แแ แแแแแกแแแฆแแ แแแ แแแแแแฃแแ HAProxy-แแก loopback แแแขแแ แคแแแกแแ แแ แ แแแแแแแ แแแฃแแแ แแแขแแ แแแขแจแ.
OpenStack-แจแ แ แแกแฃแ แกแแแแก แกแแแแ แแแแแ แแแแแแงแแแแแ แกแแ แแแกแแก แแแ แแฅแขแแ แแ, แ แแแแแแช แแแแกแแแฆแแ แแแก แแแแแ แแขแฃแแ แกแแ แแแกแแก แแแแ แฌแแ แขแแแแก API-แก. แแ แแแ แแฅแขแแ แแแจแ แฉแแแ แแแ แแแแกแขแ แแ แแแ แแแแแแแก แกแแฎแแแก - public.infra.mail.ru, แ แแแแแแช แฌแงแแแแ DNS-แแก แกแแจแฃแแแแแแ แกแแแ แแแแกแฎแแแแแแฃแแ IP แแแกแแแแ แแแ. แจแแแแแแ, แฉแแแ แแแฆแแแ แแแขแแแ แแแแก แแแแแฌแแแแแแก แกแแ แแแกแแแแ แแก แจแแ แแก DNS-แแก แกแแจแฃแแแแแแ.
แแแแ แแ แ แแแแแ แแแแ แ IP แแแกแแแแ แแแแแก แแแแแชแฎแแแแแแกแแก แฉแแแ แแ แแแแแแขแ แแแแแ แกแแ แแแ แแก แจแแ แฉแแแแก แแ แแแ แแขแแขแแแก, แแก แฏแแ แแ แแ แแก แแแแแแแแกแแแฃแแ. แ แแแแ แช แฌแแกแ, แแฎแแแแ แแ แแ แกแแ แแแ แ แจแแแ แฉแแแ IP แแแกแแแแ แแแก แฎแแแแ แซแแแแแแแก แแแฎแแแแแ, แฎแแแ แแแแแ แฉแแแ แแ แ แแฅแแแแ แฃแแแฅแแแแ, แ แแแแแ BGP-แจแ แแ แแ แแก แแแแแแแแฃแแ แแแขแ แแแ.
แฉแแแ แแแแแฌแงแแ แแแ แจแ แฃแขแแแแก แแแแแแแแ ExaBGP-แแ แกแฎแแแแแกแฎแแ แแแขแ แแแแแแ. แแแแแแฃแแ แแแแแแกแแ แ แแฅแแแงแแแแก แกแแแแแ แแแแ IP แแแกแแแแ แแก, แแแแ แแ แแ แแ แแแแแแแ, แแแแแแ แ แแ แแแแแแกแแ แแกแแแแก, แ แแแแแแแ แแแฃแแแ แแแแแแแแฃแ แ แแแขแ แแแแ. แแกแ แ แแ, แกแแแแ แกแแแแแ แแแแแแกแแ แ แแฃแจแแแแก, แแแ แแแ IP แแแกแแแแ แแแ แแแ แแแ แแแแแก แแแ แแแ แแแแแแกแแ แแ, แแแแ แแแ แแแแ แแแ แแ แแแกแแแแแ แแแกแแแแแ.
แ แ แฎแแแแ, แ แแแแกแแช แแ แ-แแ แแ แแแแแแกแแ แ แแแ แแแแ? แแฃ แ แแแแแแแ แแแแแแกแแ แ แแแ แฎแแ แฎแแแแ, แแแกแ แแแแแแ แ แแแกแแแแ แแ แแแแแ แ แแแแแแแ แแแฃแแแ แแแแแ แฉแแแ แแ แแแแ แแ แขแ แแคแแแ แแแแแแแฌแแแแแแ แแแ แจแแ แแก. แแแ แแแแ, แแแแฎแแแ แแแแแก DNS-แแก แกแแจแฃแแแแแแ แแ แแแ แแฃแแแ แ แแแแแแแแ IP แแแกแแแแ แแก แแแซแแแแ. DNS แแ แกแฎแแแแแกแฎแแ แแแขแ แแแแก แแแแแแแแกแแแแ, แฉแแแ แแแฆแแแ แแแขแแแ แแแแก แแแแแแแ แแแแแฌแแแแแแก แกแแแแแ แแแแแแกแแ แแ. แแ แแแแแ แแ แแก แฉแแแ แแ แแแแ แแแแ แจแแชแแแแแก แจแแแฌแงแแแ แแแแแแแก.
HAProxy-แแก แแแแแแแแกแแแ DNS + BGP-แแ แแแคแฃแซแแแแฃแแ
แฃแ แแแแ แแฅแแแแแแ ExaBGP-แกแ แแ HAProxy-แก แจแแ แแก
แแกแ แ แแ, แฉแแแ แแแแแแฎแแ แชแแแแแ แจแแชแแแแแแแก แขแแแแ แแแขแแแ แกแแ แแแ แแก แฌแแกแแแแก แจแแแแฎแแแแแจแ, แแแ แจแ แฃแขแแแแก แแแแแชแฎแแแแแแก แจแแฌแงแแแขแแก แกแแคแฃแซแแแแแ. แแแแ แแ HAProxy แจแแแซแแแแ แแแแฎแฃแ แแก แกแฎแแ แแแแแแแแแก แแแแ, แแแ แแ แกแแ แแแ แแก แฃแแแแ แแกแแแแก: แแแแแแแกแขแ แแชแแแก แจแแชแแแแแแ, แฉแแแแ แแแแแ แกแแ แแแกแจแ. แแ แจแแแแฎแแแแแจแแช แแแแแแ แแแขแแแ แแแแก แฅแแแจ แแแจแแแแ แแแแแแกแแ แ แแแแแแฆแแ แแ แกแฎแแ แแแฅแแแแแแ แแแญแแ แแแแ.
แแแแขแแ, แฌแแแ แกแฅแแแแก แแแคแแ แแแแแแ, แฉแแแ แแแแแแฎแแ แชแแแแแ แแฃแแแกแชแแแ ExaBGP-แกแ แแ HAProxy-แก แจแแ แแก. แแก แแ แแก ExaBGP-แกแ แแ HAProxy-แก แจแแ แแก แฃแ แแแแ แแฅแแแแแแแก แแ แแแ แแแฃแแ แแแแฎแแ แชแแแแแแ, แ แแแแกแแช ExaBGP แแงแแแแแก แแแ แกแแแแแฃแ แกแแ แแแขแแแก แแแแแแแชแแแแแก แกแขแแขแฃแกแแก แจแแกแแแแฌแแแแแแ.
แแแแกแแแแแก แแฅแแแ แฃแแแ แแแแแแแคแแแฃแ แแ แแ แฏแแแแ แแแแแแแก แจแแแแแฌแแแแแแ ExaBGP แแแแคแแแฃแ แแชแแแจแ, แ แแแแแกแแช แจแแฃแซแแแ แจแแแแแฌแแแก HAProxy-แแก แกแขแแขแฃแกแ. แฉแแแแก แจแแแแฎแแแแแจแ, แฉแแแ แแแแแงแแแแ แฏแแแแ แแแแแแแก backend-แแก แแแแคแแแฃแ แแชแแ HAProxy-แจแ แแ ExaBGP แแฎแ แแแแ แแแแแฌแแแแ แแแ แขแแแ GET แแแแฎแแแแแ. แแฃ แแแแชแฎแแแแแ แจแแฉแแ แแแแ, แแแจแแ HAProxy แแแแ แแแแแแแแแ แแ แแฃแจแแแแก แแ แแ แแ แแก แกแแญแแ แ แแแกแ แ แแแแแแแ แแแ.
HAProxy แฏแแแแ แแแแแแแก แจแแแแฌแแแแ
HAProxy Peers: แกแแกแแแก แกแแแฅแ แแแแแแชแแ
แจแแแแแแ, แ แแช แแแกแแแแแแแแแ แแงแ, แแงแ แกแแกแแแแแก แกแแแฅแ แแแแแแชแแ. แแแแแฌแแแแแฃแแ แแแแแแกแแ แแแแ แแฃแจแแแแแกแแก แ แแฃแแแ แแแแแแขแแก แกแแกแแแแแก แจแแกแแฎแแ แแแคแแ แแแชแแแก แจแแแแฎแแแก แแ แแแแแแแแ. แแแแ แแ HAProxy แแ แแก แแ แ-แแ แแ แแ แ แแแแแแแแ แแแแแแกแแ แแแแ, แ แแแแแกแแช แจแแฃแซแแแ แแแแก แแแแแแแแ Peers-แแก แคแฃแแฅแชแแแแแแแแแก แแแแ - แกแแกแแแก แชแฎแ แแแแแแก แแแแแขแแแแก แฃแแแ แ แกแฎแแแแแกแฎแแ HAProxy แแ แแชแแกแแแก แจแแ แแก.
แแ แกแแแแแก แกแฎแแแแแกแฎแแ แแแแแแแแกแแแแก แแแแแแ: แแแ แขแแแ, แ แแแแ แแชแแ แแ แแแคแแ แแแแแฃแแ, แ แแแแกแแช แแแแแแขแแก แกแแกแแแก แแแแแฎแกแแแ แแแ แฎแแแแ แแ แงแแแแ แฏแแ แแ แแก แแแแแ แแแแ แแแแแ แกแแ แแแ แแ, แ แแแแ แช แแแ แ. แฉแแแ แแแแแแแแ แแแแ แ แแแ แแแแขแแก แแแแฎแแ แชแแแแแแ.
แแ แแแฅแแแแแแแก แแแแแแขแแก แกแแกแแแแแก แจแแกแแแแฎแแ HAProxy แแงแแแแแก แฏแแฎแแแแก แชแฎแ แแแแแก. แแกแแแ แแแแฎแแแแ แแแแแแขแแก แแแแแแแแ แแแ IP แแแกแแแแ แแก, แจแแ แฉแแฃแ แกแแแแแแ แแแกแแแแ แแก (backend) แแ แกแแ แแแกแแก แแแ แแแแฃแ แแแคแแ แแแชแแแก. แ แแแแ แช แฌแแกแ, แฏแแฎแ แชแฎแ แแแแแ แแแแแแงแแแแแ แฌแงแแ แ-IP + แแแแแจแแฃแแแแแก-IP แฌแงแแแแแก แจแแกแแแแฎแแ, แ แแช แแแแกแแแฃแแ แแแแ แกแแกแแ แแแแแแ แแแแแแแชแแแแแกแแแแก, แ แแแแแแกแแช แแ แจแแฃแซแแแแ แแแแฎแแแ แแแแแก แกแแกแแแก แแแแขแแฅแกแขแแก แแแแแขแแแ แกแฎแแ แแแแแแกแแ แแ แแแแแกแแแแกแแก, แแแแแแแแแ, RoundRobin แแแแแแกแแ แแแแก แ แแแแแจแ.
แแฃ แฏแแฎแแก แชแฎแ แแแก แแกแฌแแแแแแ แแแแแแแแแแแแแก แกแฎแแแแแกแฎแแ HAProxy แแ แแชแแกแแแก แจแแ แแก (แ แแแแแแ แจแแ แแก แฎแแแแ แแแแแแแแกแแแ), แฉแแแแ แแแแแแกแแกแขแแแ แจแแซแแแแแ แแแฃแจแแแ แฏแแฎแแก แชแฎแ แแแแแแก แแ แ แแฃแแแแ. แแก แจแแกแแซแแแแแแก แแแฎแแแก แแแแแแขแแก แฅแกแแแแก แจแแฃแคแแ แฎแแแแแ แแแแแ แแแแก, แแฃ แแ แ-แแ แแ แแแแแแกแแ แ แแแ แฎแแ แฎแแแแ; แแแแแแขแแก แกแแกแแแแแแ แแฃแจแแแแ แแแแ แซแแแแแแ แแแแแ แแแฅแแแแแแแ, แ แแแแแแแช แแแ แ แแงแ แแ แฉแแฃแแ.
แกแแแแแแแ แแฃแจแแแแแกแแแแก, แฃแแแ แแแแแแ แแแก แแแแแแกแแ แแก แฌแงแแ แแก IP แแแกแแแแ แแแก แแ แแแแแแ, แกแแแแแแแช แจแแแฅแแแ แกแแกแแ. แฉแแแแก แจแแแแฎแแแแแจแ, แแก แแ แแก แแแแแแแฃแ แ แแแกแแแแ แแ loopback แแแขแแ แคแแแกแแ.
แแแแแขแแแแแแก แกแฌแแ แ แแฃแจแแแแ แแแแฆแฌแแแ แแฎแแแแ แแแ แแแแฃแ แแแ แแแแแจแ. แแแฃ, TCP แแแแแแ แฃแแแ แแงแแก แกแแแแแ แแกแแ แแแแ แแ แแแแแ แแแ แกแแแแแ แแกแแ แกแฌแ แแคแ แฃแแแ แแงแแก แแกแ, แ แแ TCP แกแแกแแแก แแ แฐแฅแแแแแก แแ แ แจแแฌแงแแแขแแกแแแแก. แแฃแแชแ, แแก แแซแแแแ แฃแฌแงแแแขแ แแแแแ แแแแก แกแแจแฃแแแแแแก.
IaaS-แจแ แฉแแแ แแแแฅแแก แกแแ แแแกแ แแแแแฃแแ แแแแแ แขแแฅแแแแแแแแก แแแแแงแแแแแแ. แแก , แ แแแแแกแแช แแฅแขแแแแ แฐแฅแแแ. แแก แแแคแฃแซแแแแฃแแแ แแ HAProxy แแ แแชแแกแแ แแ แแแแแแแแ แแแแแ แแแแชแแแก แแแแแขแแแแแแก แแฎแแ แแแญแแ แแก. แแแ แแแแแแแแ แแแแ แจแแกแแแแจแแแแแ แแแแแขแแแชแแก แแ แกแแแกแแฎแฃแ แจแ.
แกแฃแ แแแ แกแฅแแแแขแฃแ แแ แแแแฉแแแแแแก แแแแแขแแแแแแก แชแฎแ แแแแแแก แแแซแ แแแแแก แกแแ HAProxy แแแกแขแแแชแแแก แจแแ แแก, แจแแแแแแแแแแแฃแแแ แแแแคแแแฃแ แแชแแ แแแแก แจแแกแแฎแแ, แแฃ แ แแแแ แจแแแซแแแแ แแแกแ แแแแคแแแฃแ แแชแแ:
HAProxy Peers (แกแแกแแแก แกแแแฅแ แแแแแแชแแ)
แแฃ แแฅแแแ แแแแแฎแแ แชแแแแแแ แแแแแ แกแฅแแแแก, แแแกแ แแแฅแแแแแแ แแฃแแแแกแแแ แฃแแแ แจแแแแฌแแแแก. แคแแฅแขแ แแ แแ แแก, แ แแ แแก แแแแแ แแแแ แแแฃแจแแแแแก แแ แแแก 100%. แแแแ แแ แแแแแช แแ แแแแแ แแแแ แฏแแฎแแแแก แชแฎแ แแแแแก, แ แแแแกแแช แแญแแ แแแแแ แแแแแแขแแก แฌแงแแ แแก IP-แแก แแแแแฎแกแแแ แแแ.
แแ แแ แแ แแแแแ แแแแแแขแแก แแ แแแ แแฃแแ แแแแฎแแแแแแแก แ แแแแแแแแแก แจแแแฆแฃแแแ
แแแแแกแแแแ แ แกแแ แแแกแ, แ แแแแแแช แฎแแแแแกแแฌแแแแแแ แกแแฏแแ แแ, แแแ แจแแ แแก แฉแแแแ API, แจแแแซแแแแ แแแแฅแแแแแแแแ แแก แแแแแแก แแแแฎแแแแแแก. แแแแ แแแแแแแแ แจแแแซแแแแ แแงแแก แกแ แฃแแแแ แแแแกแฎแแแแแแฃแแ, แแแแฎแแแ แแแแแก แจแแชแแแแแแแแแ แแแแแแแแแแ แแฃแ แจแแขแแแแแแแแ. แฉแแแ แแแ แแแแฃแแแ DDoSed แฎแแแแ IP แแแกแแแแ แแแแแ. แแแแแแขแแแ แฎแจแแ แแ แฃแจแแแแแ แจแแชแแแแแแก แแแแแแแ แกแแ แแแขแแแจแ แแ แแแแซแแแแแ แแแแ-DDoS-แแแก.
แแกแแ แแฃ แแกแ, แแแแแขแแแแแ แแแชแแ แฃแแแ แแงแแก แฃแแ แฃแแแแแงแแคแแแ. แแจแแแ แ แแแแแกแแแแแ แแ แแก API แแแแฎแแแแแก แ แแแแแแแแแก แจแแแฆแฃแแแ แแ แแ แแแฎแแ แฏแแ CPU แแ แ แแแแแ แแแแฎแแแแแแแก แแแแฃแจแแแแแแแ.
แแกแแแ แจแแแฆแฃแแแแแแก แแแแกแแฎแแ แชแแแแแแแแ, แฉแแแ แแแงแแแแแ แแแแแแแแแแก แแแแแขแแแก, แ แแแแแแแช แแ แแแแแแแแฃแแแ HAProxy-แแก แกแแคแฃแซแแแแแ, แแแแแ แฏแแฎแแก แชแฎแ แแแแแแก แแแแแงแแแแแแ. แแแแแขแแแแก แแแงแแแแแ แกแแแแแแ แแแ แขแแแแ แแ แกแแจแฃแแแแแแก แแแซแแแแ แจแแแฆแฃแแแ แแแแฎแแแ แแแแแ API-แแ แแแแฎแแแแแก แ แแแแแแแแแ. แแแแแ แแแแ แแแแฎแกแแแ แแแก แฌแงแแ แแก IP-แก, แกแแแแแแแช แฎแแแแ แแแแฎแแแแแแ แแ แแฆแฃแแแแก แแ แแ แแแแฎแแแ แแแแแก แแ แแแ แแฃแแ แแแแฎแแแแแก แ แแแแแแแแแก. แ แ แแฅแแ แฃแแแ, แฉแแแ แแแแแแแแแแแ API แแแขแแแ แแแแก แกแแจแฃแแแ แแ แแคแแแ แแแแแแฃแแ แกแแ แแแกแแกแแแแก แแ แแแแแฌแแกแแ แแแแแขแ แแ แแแแจแแแแแแแแก โ 10-แฏแแ . แฉแแแ แแแแ แซแแแแแ แกแแขแฃแแชแแแก แแญแแแ แ แแแแแขแแ แแแแก แแ แแแแก แแฃแแกแแ แแแขแแ แแแ.
แ แแก แฐแแแแก แแก แแ แแฅแขแแแแจแ? แฉแแแ แแแงแแแก แแแแฎแแแ แแแแแแ, แ แแแแแแแช แแฃแแแแแแ แแงแแแแแแ แฉแแแแก แแแขแแกแแแแแ แแแแก API-แแแก. แแกแแแ แฅแแแแแ แแแแฎแแแแแแ แแ แแก แกแแแแก แแแ แขแฃแแแฃแ แแแแฅแแแแก แแแแแ แแ แจแแแแ แแแ แกแแฆแแแแก. OpenStack-แแกแแแแก แแแ แขแฃแแแฃแ แ แแแแฅแแแแก แจแแฅแแแ, แแกแแแ PaaS แกแแ แแแกแแแแ, แแแแแฎแแแก แแแแแแฃแ 1000 API แแแแฎแแแแแก, แแแแแแแแ แกแแ แแแกแแแก แจแแ แแก แฃแ แแแแ แแฅแแแแแแ แแกแแแ แฎแแแแ API-แแก แแแจแแแแแแ.
แแแแแแแแแแแก แแกแแแ แแแแแชแแแ แแฌแแแแก แกแแแแแแ แแแ แแแขแแแ แแแแก. แฉแแแ แจแแแแคแแกแแ แแก แแแขแแแ แแแ, แจแแแแแ แแแแ แงแแแแแแฆแแฃแ แ แแแแแแ, แแแแแแ แแแ แแกแแแ แแแฏแแ แแ แแก แแแฎแแ แฉแแแแ แแแแแแแแแแก แแแแแขแ. แแแแก แแฃแแกแแ แแแขแแ แแแ. แฉแแแ แฎแจแแ แแ แแฎแแแแแ แแแขแแแก แแ แกแแแแแ แแแก, แ แแแแแแแช แชแแแแแแแ แฉแแแแกแแแ แแแฎแแ, แแแแฅแแก แแฃ แแ แ CGA แกแแ แแแขแแแ, แ แแแแแแ แแแจแแแแแช แจแแกแแซแแแแแแแ, แฉแแแ แแฅแขแแฃแ แแ แแญแ แแ แแแ.
แ แแแแ แแแแแแฎแแแ แแฅแแแแ แแแแแแแก แแแแ แแแแฎแแแ แแแแแแแก แจแแฃแแฉแแแแแแ
แฉแแแ แแกแแแ แแแฎแแ แชแแแแแแ แจแแชแแแแแแแก แจแแแฌแงแแแ แแแแแแแก แแแแแก แแแแแแแแแแก แแ แแชแแกแแแแก แแแแแแ. แแแจแแแแแก แแ แแก แจแแแซแแแแ แแงแแก แฎแแ แแแแแแ, แแแแ แแ แแแแ แแแแแแแ แกแแ แแแกแแก แฎแแแแแกแแฌแแแแแแแแแ แจแแแซแแแแ แแแแแแฃแแแแแ แจแแแชแแ แแแก.
แฉแแแ แแฃแแแแแแ แแแแฎแแแแ แฉแแแแก แกแแ แแแกแแแก แแ แฃแแแ แแแแ แฌแแฃแแแแ, แ แแ แแแแแแแก แแแแ แแแแแฎแแแแแ แแแแฎแแแ แแแแแแแ แแแแแฅแแแแแแแก แแแ แแจแ. แฉแแแ แแแแแฎแแ แฎแแ แแ แแ แแแแแแแก แแแแแญแ แ HAProxy-แแก แแแ แแแแก แจแแกแแซแแแแแแแแแแกแ แแ Graceful Shutdown-แแก แแแแแ แแแแ แฉแแแแก แกแแ แแแกแแแจแ.
แแ แแ แแแแแแแก แแแแแกแแญแ แแแแ แกแแญแแ แ แแงแ แแแแแแกแแก แแแแขแ แแแ แแ แกแแ แแแกแแแแก "แกแฌแแ แ" แแแแแ แแแ:
- HAProxy-แแก แจแแแแฎแแแแแจแ แแแแขแ แแแ แฎแแ แชแแแแแแแ stats แคแแแแแก แกแแจแฃแแแแแแ, แ แแแแแแช แแ แกแแแแแแ แแ แแก แกแแแแขแ แแ แแแแกแแแฆแแ แฃแแแ HAProxy แแแแคแแแฃแ แแชแแแจแ. แจแแแแซแแแแ แแแก แแ แซแแแแแแแ แแแฃแแแแแแแ stdio-แก แกแแจแฃแแแแแแ. แแแแ แแ แฉแแแแ แแแแแแ แ แแแแคแแแฃแ แแชแแแก แแแแขแ แแแแก แฎแแแกแแฌแงแ แแ แแก แฎแแแแแกแแฌแแแแแ, แแแแขแแ แแแก แแฅแแก แฉแแจแแแแแฃแแ แแแแฃแแ HAProxy-แแก แแแ แแแแกแแแแก. แ แแแแแกแแช แฉแแแ แแฅแขแแฃแ แแ แแแงแแแแแ.
- แฉแแแแ API แแ Engine แกแแ แแแกแแแแก แฃแแแขแแกแแแ แแฎแแ แก แฃแญแแ แก แแแฎแแแแแแ แแแแแ แแแแก แขแแฅแแแแแแแแแก: แแแแแ แแแแกแแก แแกแแแ แแแแแ แแแแแแแแ แ แแแแชแแแแก แแแกแ แฃแแแแแก, แแฅแแแแ แแก http แแแแฎแแแแ แแฃ แ แแแแ แกแแ แแแกแแก แแแแแแแแ. แแแแแ แฎแแแแ แแฃแจแแก แจแแแแฎแแแแแจแแช. แแแ แแชแแก แงแแแแ แแแแแแแแ, แ แแกแแช แแแแแแแก แแ แแแแแ แแแแ, แ แแชแ แงแแแแแคแแ แก แฌแแ แแแขแแแแ แแแแกแ แฃแแแแก.
แแ แแ แ แฌแแ แขแแแแก แฌแงแแแแแแ, แฉแแแแ แแแแแแแแแแก แฃแกแแคแ แแฎแ แแแแแ แแแแ แแกแ แแแแแแงแฃแ แแแ.
- แแแแแแแแแ แ แแฌแงแแแก แแแแแก แแฎแแ แแแแแขแก (แฉแแแแแแแก แแก แแ แแก RPM), แแแแฌแแแแก แแแก dev แแแ แแแแจแ, แแแแฌแแแแก แกแชแแแแแ แแ แขแแแแแก แกแชแแแแก แกแแชแแแจแ.
- แแแแแแแแแ แ แแแแแแก แแแแแแแแแแก แแแแแแแแแก โแแ แขแแคแแฅแขแแแแกโ แงแแแแแแ แแแขแแแฃแ แ แแฆแฌแแ แแ: แแฎแแแ แแแแแขแแก แแแ แกแแ, แแฎแแแ แคแฃแแฅแชแแแแแ แแแแก แแฆแฌแแ แ แแ แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ แแแแแแแแแแก แกแฎแแ แแแขแแแแแ.
- แกแแกแขแแแแก แแแแแแแกแขแ แแขแแ แ แแฌแงแแแก แแแแแฎแแแแแก. แฃแจแแแแก Ansible playbook-แก, แ แแแแแแช แแแแแก แแฎแ แแ แแแแแแแก แจแแแแแแก:
- แแฆแแแก แแแแแขแก แแขแแแแก แกแแชแแแแแแ แแ แแงแแแแแก แแแก แแ แแแฃแฅแขแแก แกแแชแแแจแ แแแแแขแแก แแแ แกแแแก แแแแแฎแแแแแกแแแแก.
- แแแแแแก แแแแแฎแแแแฃแแ แกแแ แแแกแแก แแแฅแแแแแแแก แกแแแก.
- แแแจแแแก แแแ แแแ แกแแ แแแกแก, แ แแแแแแช แแแแแฎแแแแแ HAProxy-แจแ แแ แแแแแแแ แแแกแ แแ แแชแแกแแแแก แแแจแแแแแก. แแแฎแแแแแแ แแแแแ แแแแก แฌแงแแแแแแ, แฉแแแ แแแ แฌแแฃแแแแฃแแแ แแแ แ, แ แแ แแแแแแขแแก แงแแแแ แแแแแแแแ แ แแแแฎแแแแ แฌแแ แแแขแแแแ แแแกแ แฃแแแแแ.
- แแแก แจแแแแแ, แ แแช API แแ แแฃแจแแแแแ แแแแแแแแ แจแแฉแแ แแแฃแแแ แแ HAProxy แแแแแ แแฃแแแ, แแแแ แแแแแฎแแแแแ.
- Ansible แแแ แแแแก แกแแ แแแกแแแก.
- แแแแแแฃแแ แกแแ แแแกแแกแแแแก แแญแ แแแ แแแ แแแแฃแแ โแกแแฎแแแฃแ แแแโ, แ แแแแแแแช แแกแ แฃแแแแแ แแ แแแฃแแแก แขแแกแขแแ แแแแก แฌแแแแกแฌแแ แแแแกแแแฆแแ แฃแ แกแแแแแแซแ แขแแกแขแแแแ. แฎแแแแ แแฎแแแ แแแแแก แซแแ แแแแแ แจแแแแฌแแแแ.
- แแฃ แฌแแแ แกแแคแแฎแฃแ แแ แจแแชแแแแแแ แแ แแฅแแ แแแแแแแ, backend แแแแฅแขแแฃแ แแแฃแแแ.
- แแแแแ แแแแแแแแแ แจแแแแแ แแแฅแแแแแ.
- แแแก แจแแแแแ, แ แแช แงแแแแ backend แแแแแฎแแแแแ, แคแฃแแฅแชแแแแแแฃแ แ แขแแกแขแแแ แแฌแงแแแ. แแฃ แแกแแแ แแแแแ, แแแจแแ แแแแแแแแแ แ แฃแงแฃแ แแแก แแแก แแแแ แจแแฅแแแแ แแแแแกแแแแ แแฎแแ แคแฃแแฅแชแแแก.
แแก แแกแ แฃแแแแก แแแแแแแแแแก.
แกแแ แแแกแแก แแแแแฎแแแแแก แชแแแแ
แแก แกแฅแแแ แแ แแแฃแจแแแแแแ, แแ แแ แฌแแกแ แ แแ แแ แแแฅแแแแแก. แฉแแแ แแฎแแ แก แแฃแญแแ แ แ แแแแ แช แซแแแ, แแกแแแ แแฎแแ แแแ แกแแแแก แแ แซแแแแจแ. แฌแแแแกแฌแแ , แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแแฃแจแแแแแแก แแขแแแแ, แแแแแแแแแแ, แ แแ แกแแ แแแกแแก แแแแแชแแแแ แแแแแจแแช แ แแ แจแแแชแแแแแก แชแแแแแแแแแ, แแกแแแ แแ แแ แฆแแแแแ แฌแแแ แแแแก. แจแแแแแแ, แแแแแแแก แแแแ แแแแแแแแ แแแแแฎแแแแแ.
แแแกแแแแ
แแแแแแ แแ แฉแแแก แแแ แแแก แจแแชแแแแแแแก แขแแแแ แแแขแฃแแ WEB แแ แฅแแขแแฅแขแฃแ แแก แจแแกแแฎแแ, แแแแแ แแ แแฎแแ แแแแแ แแฆแแแแจแแ แแแกแ แซแแ แแแแแ แแฃแแฅแขแแแ:
- แคแแแแแฃแ แ แจแแชแแแแแก แขแแแแ แแแขแแแ;
- แฅแกแแแแก แแแฃแแแ แแแแแแก แขแแแแ แแแขแแแ (แแแแแแกแแ แแแ, BGP);
- แแแแแงแแแแแฃแแ แแ แจแแแฃแจแแแแแฃแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แจแแชแแแแแก แขแแแแ แแแขแแแ.
แกแขแแแแแฃแ แ แแฃแจแแแแแก แแ แ แงแแแแแก!
แฌแงแแ แ: www.habr.com
