แแแแแ แฏแแแ, แแ แแแ แกแแ แแแ แแแแแชแแแ, แแแแแแ แแแแ
แแแ แแแ แ แแแจแ, แจแแแแแแแแแแแแ แ แแแแแแแแ แขแแ แแแแก:
- VIP (แแแ แขแฃแแแฃแ แ IP) - แแแแแแกแแ แแก IP แแแกแแแแ แแ
- แกแแ แแแ แ, แแแฅแแแแ, แแแแแแแแ - แแแ แขแฃแแแฃแ แ แแแแฅแแแ, แ แแแแแแช แแฃแจแแแแก แแแแแแแชแแแจแ
- RIP (แ แแแแฃแ แ IP) - แกแแ แแแ แแก IP แแแกแแแแ แแ
- Healthcheck - แกแแ แแแ แแก แแแแแงแแคแแแก แจแแแแฌแแแแ
- แฎแแแแแกแแฌแแแแแแแแก แแแแ, AZ - แแแแแแ แแแฃแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แ แแแแแชแแแแ แชแแแขแ แจแ
- แ แแแแแแ - แกแฎแแแแแกแฎแแ AZ-แแแแก แแแแ แแแแแแแ
แแแขแแแ แแแแก แแแแแแกแแ แแแ แฌแงแแแขแแ แกแแ แซแแ แแแแ แแแแชแแแแก: แแกแแแ แแแแแ แแกแ แฃแแแแแ แแแแแแแแกแแแแก, แแฃแแฏแแแแกแแแแ แกแแ แแแกแแก แจแแคแแ แฎแแแแก แขแแแแ แแแขแแแแก แแ แแแแ แขแแแแแก แแแก แแแกแจแขแแแแ แแแแก. แจแแชแแแแแแแก แขแแแแ แแแขแแแ แฃแแ แฃแแแแแงแแคแแแแ แขแ แแคแแแแก แแแขแแแแขแฃแ แ แแแแแฏแแแแขแแ: แแแแแแกแแ แ แแแแแขแ แแแแแก แแแแแแแชแแแก แแแแแแแ แแแแแก แแ แแแแแ แแชแฎแแแก แแแแแแกแแ แแแแก แจแแแแฎแแแแแแก, แ แแแแแแแช แแ แแแแแแแแ แกแแชแแชแฎแแแก แจแแแแฌแแแแแก. แกแแแแแ แแแ แฃแแ แฃแแแแแงแแคแแแแ แแแกแขแแแชแแแแแ แแแขแแแ แแแแก แแแแแแ แแ แแแแแฌแแแแแแ, แแแ แแแแ แแแกแขแแแชแแแแแก แกแแแก แแแแแฎแแแแแ. แแฃ แแแแแแแแกแแแ แแ แแ แแก แกแแแแแ แแกแแ แแ แแแแแ แแแแแ, แแแแแแ แแ แแแกแขแแแชแแ แแแแฆแแแก แแแขแแแ แแแแก, แ แแแแแแช แแฆแแแแขแแแ แแแแ แกแแแซแแแแ แแก แแแแแขแก แแ แกแแ แแแกแ แแแฎแแแแ แแแแแแแแ แกแแแแแแ.
แแแขแแแ แแแแก แแแแแแกแแ แ แฎแจแแ แแ แแแแกแแคแแชแแ แแแแ แแ แแขแแแแแแก แคแแแแ OSI แแแแแแแแแ, แ แแแแแแแช แแก แแฃแจแแแแก. Cloud Balancer แแฃแจแแแแก TCP แแแแแแ, แ แแแแแแช แจแแแกแแแแแแแ แแแแแฎแ แคแแแแก, L4.
แแแแแ แแแแแแแแแ Cloud balancer แแ แฅแแขแแฅแขแฃแ แแก แแแแแฎแแแแแแ. แฉแแแ แแแแแแแแ แแแแแ แแแ แแแขแแแแแแก แแแแแก. แฉแแแ แแงแแคแ แแแแแแกแแก แแแแแแแแแขแแแก แกแแ แแแแกแแ. แแแแคแแแฃแ แแชแแแก แกแแแ แขแงแแก แแแแกแ แแแกแฃแฎแแกแแแแแแแแ แแแแฎแแแ แแแแแก แแแขแแ แแฅแชแแแแ แแ แแแแฎแแแก แกแแกแขแแแแก แกแแแแแแ แแแแแแแ แแแแแก. แกแแแแแขแ แแแ แกแแแ แขแงแ แแแแฎแแแก แกแแกแขแแแแก แแแแแแแแแแ แแแแแแแ แแแแแก แแ แแแ แแแแก แกแแกแขแแแแแก แแแแแชแแแแ แกแแแ แขแงแแก แแแแกแแแแ, แ แแแแแแแช แฃแจแฃแแแแ แแ แแแ แแแกแฃแฎแแกแแแแแแแแ แแแแแแขแแแแกแแแ แขแ แแคแแแแก แแแฌแแแแแแแ แแฅแแแแก แแแกแขแแแชแแแแแ.
แแแแแชแแแแ แแแแแแคแ แแแแแ
แขแ แแคแแแ แแแแแ แแแแ แซแแแ แแแฆแแ แแแฃแ แแแฌแงแแแแแแแแแแ, แกแแฎแแแฌแแแแแแ แกแแกแแแฆแแ แ แแแ แจแ แฃแขแแแแขแแ แแแ. แจแแชแแแแแแแก แขแแแแ แแแขแแแแก แแแแ แแแก แแแแแแ, แ แแแแแแแแ แแกแแแ แแแฌแงแแแแแแแ แแ แแแ แแฃแแแ แแฃแจแแแแก แแ แ แแแแแชแแแแ แชแแแขแ แจแ. แจแแแแแแ, แขแ แแคแแแ แแแแแก แแแแแแกแแ แแแแ, แ แแแแแแแช แแชแฎแแแแแแ แแแแแกแแแแ IP แแแกแแแแ แแแแก แงแแแแ AZ-แก BGP-แแก แกแแจแฃแแแแแแ แแแแแแขแแแแกแแแแก.
แขแ แแคแแแ แแแแแแชแแแ ECMP-แแ - แแก แแ แแก แแแ แจแ แฃแขแแแแชแแแก แกแขแ แแขแแแแ, แ แแแแแก แแแฎแแแแแแแช แจแแแซแแแแ แแงแแก แ แแแแแแแแ แแแแแแ แแ แแแ แแ แแแ แจแ แฃแขแ แกแแแแแแแแแ (แฉแแแแก แจแแแแฎแแแแแจแ, แกแแแแแแ แแฅแแแแ แแแแแจแแฃแแแแแก IP แแแกแแแแ แแ) แแ แแแแแขแแแแก แแแแแแแแ แจแแกแแซแแแแแแแ แ แแแแแแแ แแแแแแแแก แแแกแฌแแ แแ. แฉแแแ แแกแแแ แแฃแญแแ แ แแฎแแ แก แแฃแจแแแแแก แ แแแแแแแแ แฎแแแแแกแแฌแแแแแแแแก แแแแแจแ แจแแแแแแ แกแฅแแแแก แแแฎแแแแแ: แฉแแแ แแแชแฎแแแแแ แแแกแแแแ แแก แแแแแแฃแ แแแแแจแ, แขแ แแคแแแ แแแแแก แฃแแฎแแแแก แแแแแจแ แแ แแ แกแชแแแแแแ แแแก แกแแแฆแแ แแแก. แแแแแแแแแแแ แแแกแขแจแ แฃแคแ แ แแแขแแแฃแ แแ แแแแแแฎแแแแแ แ แ แฎแแแแ แขแ แแคแแแก.
แแแแคแแแฃแ แแชแแแก แแแแแแคแ แแแแแ
แแแแคแแแฃแ แแชแแแก แกแแแ แขแงแแก แซแแ แแแแแ แแแแแแแแแขแแ API, แ แแแแแก แแแจแแแแแแแแช แฎแแ แชแแแแแแแ แซแแ แแแแแ แแแแ แแชแแแแ แแแแแแกแแ แแแแแ: แจแแฅแแแ, แฌแแจแแ, แแแกแขแแแชแแแแแก แจแแแแแแแแแแแแก แจแแชแแแ, แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แจแแแแแแแแก แแแฆแแแ แแ แ.แจ. แแ แแแก แแฎแ แแ, แแก แแ แแก REST API แแ แกแฎแแแแ แจแแ แแก, แฉแแแ Cloud-แจแ แซแแแแแ แฎแจแแ แแ แแแงแแแแแ แฉแแ แฉแแก gRPC, แแแแขแแ REST-แก "แแแแ แแแแแ" gRPC-แแ แแ แจแแแแแ แแแงแแแแแ แแฎแแแแ gRPC-แก. แแแแแกแแแแ แ แแแแฎแแแแ แแฌแแแแก แแกแแแฅแ แแแฃแแ แแแแแแแขแแแขแฃแ แ แแแแชแแแแแแก แกแแ แแแก แจแแฅแแแแก, แ แแแแแแแช แจแแกแ แฃแแแแฃแแแ Yandex.Cloud แแฃแจแแแแแแก แกแแแ แแ แแฃแแแ. แแแแชแแแแแ แแฌแแ แแแ แแกแ, แ แแ แแแแ แจแแฉแแ แแแ แแแแแกแแแแ แแ แแก แจแแแซแแแแ แแ แจแแแแแ แฎแแแแฎแแ แแแฌแงแแแ. แแก แฃแแ แฃแแแแแงแแคแก แแแกแจแขแแแฃแ แแแแก, แแแแแแแ แแแแแแแแก แแ แแแแ แแชแแแแแก แแฆแ แแชแฎแแแก.
แจแแแแแแ, API-แแแ แแแแแแแแ แแแแแ แแแแก แแแแฎแแแแแก แแแแแแกแแ แแก แกแแ แแแกแแก แแแแขแ แแแแ แแแ, แ แแแแแแช แฉแแฌแแ แแแแ Go-แจแ. แแแก แจแแฃแซแแแ แแแแแแขแแก แแ แฌแแจแแแแก แแแแแแกแแ แแแ, แจแแชแแแแแก แแแฅแแแแแแแก แจแแแแแแแแแแแ แแ แแแ แแแแขแ แแแ.
แกแแ แแแกแ แแแแฎแแแก แแแแแก แแแแแแแ แแแแแก Yandex Database-แจแ, แแแแแฌแแแแแฃแ แแแ แแฃแ แแแแแชแแแแ แแแแแจแ, แ แแแแแก แแแแแงแแแแแแกแแช แแแแ แจแแซแแแแ. Yandex.Cloud-แจแ, แ แแแแ แช แฃแแแ
แแแแฃแแ แฃแแแแ แแแแแแกแแก แแแแขแ แแแแ แก. แแแกแ แแแแชแแแแ แจแแแแแฎแแก แแแคแแ แแแชแแ แแแแแแกแแ แแก แจแแกแแฎแแ แแ แแแแแแแแแก แแแแแแแแ แแแ แขแฃแแแฃแ แ แแแแฅแแแแก แแแแแงแแคแแแก แจแแกแแแแฌแแแแแแ แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แแแแขแ แแแแ แแแ.
แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แแแแขแ แแแแ แ
แแก แแฆแแแก แแแแฎแแแแแแก แจแแแแฌแแแแแก แฌแแกแแแแก แจแแกแแชแแแแแแ, แแแแฎแแแก แแแ YDB-แจแ, แแแแฌแแแแแก แแแแแแแแแแก แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แแแแแซแแแก แจแแ แแก แแ แแแ แแแแแก แจแแแแแแแก, แ แแแแแแแช แจแแแแแ แแแแฎแแแ แแแแแชแแแแ แแแแแจแ แแ แแแแแแแแแ loadbalancer แแแแขแ แแแแ แจแ. แแก, แแแแแก แแฎแ แแ, แแแแแแแแก แแแแฎแแแแแก แแแแแชแแแแ แกแแแ แขแงแแจแ แแแแกแขแแ แแก แจแแแแแแแแแแแแก แจแแชแแแแก แจแแกแแฎแแ loadbalancer-node-แแ, แ แแกแแช แฅแแแแแ แแแแแแฎแแแแ.
แแแแแ แแแกแแฃแแ แแ แฃแคแ แ แแแขแ แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แจแแกแแฎแแ. แแกแแแ แจแแแซแแแแ แแแแงแแก แ แแแแแแแแ แแแแกแแ. แแฃแแแขแก แฌแแ แแแขแแแแก แกแฎแแแแแกแฎแแ แแ แแขแแ แแฃแแ แแฅแแก. TCP แจแแแแฌแแแแแก แกแญแแ แแแแ แแแแจแแ แแก แฌแแ แแแขแแแแ แแแแงแแ แแแ แคแแฅแกแแ แแแฃแ แแ แแจแ. HTTP แจแแแแฌแแแแ แแแแแฎแแแก แ แแแแ แช แฌแแ แแแขแแแฃแ แแแแจแแ แก, แแกแแแ แแแกแฃแฎแก 200 แกแขแแขแฃแกแแก แแแแแ.
แแกแแแ, แฉแแแแแ แแแแกแฎแแแแแแแ แแแฅแแแแแแแก แแแแกแจแ - แแกแแแ แแฅแขแแฃแ แ แแ แแแกแแฃแ แแ. แแแกแแฃแ แ แจแแแแฌแแแแแแ แฃแแ แแแแ แแแแแขแ แแแแแแ แ แ แฎแแแแ แขแ แแคแแแแแ แแแแแแจแแ แแแแ แ แแแแ แแแแกแแแฃแแ แแแฃแแ แแแฅแแแแแแแก แแแ แแจแ. แแก แแ แแฃแจแแแแก แซแแแแแ แแแ แแแ L4-แแ, แ แแแแแ แแก แแแแแแแแแแฃแแแ แฃแคแ แ แแแฆแแแ แแแแแก แแ แแขแแแแแแแแก แแแแแแแแ: L4-แแ แแ แแ แแก แแแคแแ แแแชแแ แแแแก แจแแกแแฎแแ, แแฃ แ แแแแแ แฎแแแก แแแแ แซแแแแ แแแแ แแชแแ แแ แแงแ แแฃ แแ แ แแแแจแแ แแก แแแกแ แฃแแแแ แแแ แแ แแ แชแฃแแ. แแฅแขแแฃแ แ แจแแแแฌแแแแแแ แแแแแฎแแแก แแแแแแกแแ แก แแแแแแแแแแแแก แแแแฎแแแแแแ แกแแ แแแ แแก แแแแแแฃแ แแแกแขแแแชแแแแ.
แแแขแแแ แแแแก แแแแแแกแแ แแแแก แฃแแแขแแกแแแ แแแแแ แแฎแแ แชแแแแแแก แกแแชแแชแฎแแแกแฃแแแ แแแแแแแก แจแแแแฌแแแแแก. Cloud-แจแ แแแแแแฌแงแแแขแแ แกแแกแขแแแแก แแ แแแฌแแแแแแก แแแแแงแแคแ แแแกแจแขแแแฃแ แแแแก แแแกแแแ แแแแแ. แแก แแแแแแแ แกแแจแฃแแแแแแก แแแแแชแแแก แแแแแแ แแแ แแแแแแกแแ แแแแก แ แแแแแแแแ แกแแ แแแกแแ แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แแแแฎแแแแแก แ แแแแแแแแแก แจแแแแ แฉแฃแแแแแ. แจแแแแฌแแแแแแ แฎแแ แชแแแแแแแ แชแแแแแฃแแ แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แแแแแซแแแแ, แ แแแแแแจแแช แจแแแแฌแแแแแก แกแแแแแแแแแ แแจแแแแ แแ แแ แแแแแแแ. แแฅแแแ แแ แจแแแแซแแแแ แจแแแกแ แฃแแแ แจแแแแฌแแแแ แแ แแ แฐแแกแขแแแแ, แ แแแแแ แแก แจแแแซแแแแ แแแ แแแฎแแ แฎแแแก. แแแจแแ แฉแแแ แแแ แแแแแฆแแแ แแแก แแแแ แจแแแแฌแแแแฃแแ แจแแแแฎแแแแแแแก แแแแแแแ แแแแแก. แฉแแแ แแแกแ แฃแแแแ แจแแแแฌแแแแแก แแแแแกแแแแ แจแแแแฎแแแแแแ แแแแแแฃแ แกแแแ แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แแแแแซแแแแ. แฉแแแ แแแแแฌแแแแแ แแแแแซแแแก แจแแ แแก แจแแแแฌแแแแแก แแแแแแแก แแแแแแแแแแ แฃแแ แฐแแจแแ แแแแก แแแแแ แแแแแแแก แแแแแงแแแแแแ.
แแแแแแแแกแแแแกแ แแ แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แแแแแฏแแแแ แจแแแซแแแแ แแแแแแฌแแแแก แแ แแแแแแแแ. แแฃ แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แแแแแซแ แแแแแ แแแแก แแแกแขแแแชแแแก แแแแฎแแแแแแก, แแแแ แแแก แแแแแ แแแแแแกแแ แก (แ แแแแแแช แแแแแแแ แแ แแแกแแฎแฃแ แแแ แขแ แแคแแแก), แแแจแแ แฌแแ แแแแฅแแแแแ แฃแชแแแฃแ แ แกแแขแฃแแชแแ: แ แแแแ แช แฉแแแก, แ แแกแฃแ แกแ แชแแชแฎแแแแ, แแแแ แแ แขแ แแคแแแ แแแก แแแ แแแแฆแฌแแแก. แฉแแแ แแ แแ แแแแแแแก แแแแแแ แแแ แแ แแแแ: แแแ แแแขแแ แแแฃแแ แแแแฅแแก แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แขแ แแคแแแแก แแแแชแแ แแแ แแแแแแกแแ แแแแก แแแจแแแแแแ. แกแฎแแ แกแแขแงแแแแแ แ แแ แแแฅแแแ, แแแแแแขแแแแกแแแ แแ แฏแแแแ แแแแแแแก แจแแแแฌแแแแแแแแแ แขแ แแคแแแแ แแแแแขแแแแก แแแแแแแแแแแแแก แกแฅแแแ แแแแแแแแฃแ แแ แแแแกแฎแแแแแแแ: แแ แแแ แจแแแแฎแแแแแจแ, แแแแแขแแแ แแแแฆแฌแแแก แแแแแแกแแ แแแก, แ แแแแแแแช แแแแฌแแแแแ แแแ แกแแแแแแ แ แแกแฃแ แกแแแก.
แแแแกแฎแแแแแแ แแกแแ, แ แแ แแแแแแขแแแ แแแแฎแแแแแแก แฃแงแแแแแแ VIP-แก, แฎแแแ แฏแแแแ แแแแแแแก แจแแแแฌแแแแ แแแแแแฃแ แแแแแแแแฃแแแฃแ RIP-แก. แแฅ แฉแแแแแ แกแแแแขแแ แแกแ แแ แแแแแแ: แฉแแแ แแแแฎแแแ แแแแแแก แแแซแแแแ แจแแกแแซแแแแแแแแก แจแแฅแแแแ แ แแกแฃแ แกแแแ แ แฃแฎแ IP แฅแกแแแแแจแ. แฌแแ แแแแแแแแแแ, แ แแ แแ แกแแแแแก แแ แ แแแแกแฎแแแแแแฃแแ แฆแ แฃแแแแก แแคแแแแแแ, แ แแแแแแแแช แแแแแแแแ แกแแ แแแกแแแ แแแแแแแก แแแแแแกแแ แแแแก แแแฆแแ. แแแแแแฃแ แแแแแแแก แแฅแแก แ แแกแฃแ แกแแแ 10.0.0.1/24 แฅแแแฅแกแแแจแ, แแแแแ แแแกแแแแ แแแแแ. แแฅแแแ แฃแแแ แจแแซแแแ แ แแแแ แแ แแแแแกแฎแแแแแ แแกแแแ แแ แแฅ แแฅแแแ แฃแแแ แฉแแงแแแแแแ Yandex.Cloud แแแ แขแฃแแแฃแ แ แฅแกแแแแก แกแขแ แฃแฅแขแฃแ แแจแ. แฏแแแแ แแแขแ แแแขแแแแแ แแแแแแ
แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แแแแแซแแแ แแแฃแแแแจแแ แแแแแแ แแแแแแกแแ แแแก แ.แฌ. แแแแแ-IPv6 แแแกแแแแ แแแแแก แแแแแงแแแแแแ. แแแแแ-แแแกแแแแ แแ แแ แแก IPv6 แแแกแแแแ แแ IPv4 แแแกแแแแ แแแ แแ แแแแฎแแแ แแแแแก แฅแแแฅแกแแแแก ID-แแ, แ แแแแแแช แฉแแจแแแแแฃแแแ แแแกแจแ. แขแ แแคแแแ แแฆแฌแแแก แแแแแแกแแ แก, แ แแแแแแช แแแแแฆแแแก แแแกแแแ IPv4 แ แแกแฃแ แกแแก แแแกแแแแ แแก, แแแแชแแแแแก IPv6-แก IPv4-แแ แแ แแแแแแแแก แแแแแขแก แแแแฎแแแ แแแแแก แฅแกแแแจแ.
แกแแแแ แแกแแแ แ แขแ แแคแแแ แแแแแ แแแแ แแแแแก: แแแแแแกแแ แ แฎแแแแแก, แ แแ แแแแแจแแฃแแแแ แแ แแก แแแชแ แแกแคแแ แ แฅแกแแแ แฏแแแแ แแแแแแแก แจแแแแแฌแแแแแแแแกแแแ แแ แแแ แแแฅแแแแก IPv4-แก IPv6-แแ.
VPP - แแแแแชแแแแ แกแแแ แขแงแแก แแฃแแ
แแแแแแกแแ แ แแแแแ แแแแแ Vector Packet Processing (VPP) แขแแฅแแแแแแแแก แแแแแงแแแแแแ, Cisco-แก แฉแแ แฉแ แฅแกแแแแก แขแ แแคแแแแก แฏแแฃแคแฃแ แ แแแแฃแจแแแแแแกแแแแก. แฉแแแแก แจแแแแฎแแแแแจแ, แฉแแ แฉแ แแฃแจแแแแก แแแแฎแแแ แแแแแก แกแแแ แชแแก แฅแกแแแแก แแแฌแงแแแแแแแแก แแแ แแแแก แแแแแแแแแแแก แแแแแ - Data Plane Development Kit (DPDK). แแก แฃแแ แฃแแแแแงแแคแก แแแแแขแแก แแแแฃแจแแแแแแก แแแฆแแ แจแแกแ แฃแแแแแก: แแแชแแแแแแ แแแแแแแ แจแแคแแ แฎแแแแแ แฎแแแแ แแแ แแแจแ แแ แแ แแ แแก แแแแขแแฅแกแขแฃแ แ แแแแแแ แแแแแแแ แแแ แแแแก แกแแแ แชแแกแ แแ แแแแฎแแแ แแแแแก แกแแแ แชแแก แจแแ แแก.
VPP แแแแแ แฃแคแ แ แจแแ แก แแแแแก แแ แแแแแ แฃแคแ แ แแแข แจแแกแ แฃแแแแแก แแแชแแ แแแก แกแแกแขแแแแกแแแ แแแแแขแแแแก แแแ แขแแแแแ แแแแ แแแแแแแแ. แจแแกแ แฃแแแแแก แแแฆแฌแแแแแ แแแแแก แแแแแแแแ แแแ แแ แแชแแกแแ แแแแ แฅแแจแแก แแแ แแกแแฃแแ แแแแแงแแแแแแ. แแแแแแงแแแแแ แ แแแแ แช แแแแแชแแแแ แฅแแจแ (แแแแแขแแแ แแฃแจแแแแแแ โแแแฅแขแแ แแแจแโ, แแแแแชแแแแแ แแฎแแแกแแ แแ แแแแแแแแแ) แแ แแแกแขแ แฃแฅแชแแแก แฅแแจแ: VPP-แจแ แแแแแขแแก แแแแฃแจแแแแแ แแแฐแงแแแแ แแ แแคแแแก, แ แแแแแก แแแแแซแแแ แจแแแชแแแก แคแฃแแฅแชแแแแก, แ แแแแแแแช แแกแ แฃแแแแแ แแ แแกแ แแ แแแแแ แแแแชแแแแก.
แแแแแแแแแ, IP แแแแแขแแแแก แแแแฃแจแแแแแ VPP-แจแ แฎแแแแ แจแแแแแแ แแแแแแแแแแ แแแแ: แฏแแ แแแแแขแแแแก แกแแแแฃแ แแแ แแแฌแแแแแแ แแแแแแแฃแ แแแแแซแจแ, แจแแแแแ แแ แแแแแแแแแ แแแแแซแจแ, แ แแแแแแช แจแแแแแแแจแ แแแแแกแชแแแก แแแแแขแแแก แแแ แจแ แฃแขแแแแชแแแก แชแฎแ แแแแแแก แแแฎแแแแแ.
แชแแขแ แฐแแ แแแแ แ. VPP-แแก แแแขแแ แแแ แแ แแแแแแแแแ แแแแแ แแแแกแแแก แแ แแชแแกแแ แแก แฅแแจแแก แแแแแงแแแแแแจแ, แแแแขแแ แแแแแขแแแแก แแแฅแขแแ แแก แแแแฃแจแแแแแแก แขแแแแฃแ แ แแแแ แจแแแชแแแก แฎแแแแ แแแฅแขแแ แแแแชแแแก: แแ แแก แแแแฃแจแแแแแแก แแแ แงแฃแแ, แ แแแแแจแแช แแฃแจแแแแแแ แกแแขแฃแแชแแ, แ แแแแ แแชแแ "แฉแแแ แแแแฅแแก แแแฎแ แแแแแขแ แ แแแจแ". แจแแแแแ แแแแแ แแ แ, แจแแแแแ - แแ แแ. แฌแแแแกแฌแแ แ แจแแงแแแแแก แแแกแขแ แฃแฅแชแแแแ แฎแจแแ แแ แแแแแแงแแแแแ แแแแแชแแแแแแก แฅแแจแแแจแ แฉแแกแแขแแแ แแแ, แ แแแ แแแแฉแฅแแ แแก แแแแแ แฌแแแแแ แจแแแแแแ แแแแแแ แแแแแจแ.
n_left_from = frame->n_vectors;
while (n_left_from > 0)
{
vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
// ...
while (n_left_from >= 4 && n_left_to_next >= 2)
{
// processing multiple packets at once
u32 next0 = SAMPLE_NEXT_INTERFACE_OUTPUT;
u32 next1 = SAMPLE_NEXT_INTERFACE_OUTPUT;
// ...
/* Prefetch next iteration. */
{
vlib_buffer_t *p2, *p3;
p2 = vlib_get_buffer (vm, from[2]);
p3 = vlib_get_buffer (vm, from[3]);
vlib_prefetch_buffer_header (p2, LOAD);
vlib_prefetch_buffer_header (p3, LOAD);
CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, STORE);
CLIB_PREFETCH (p3->data, CLIB_CACHE_LINE_BYTES, STORE);
}
// actually process data
/* verify speculative enqueues, maybe switch current next frame */
vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
to_next, n_left_to_next,
bi0, bi1, next0, next1);
}
while (n_left_from > 0 && n_left_to_next > 0)
{
// processing packets by one
}
// processed batch
vlib_put_next_frame (vm, node, next_index, n_left_to_next);
}
แแกแ แ แแ, Healthchecks แกแแฃแแ แแแก IPv6-แแ VPP-แแ, แ แแแแแแช แแฅแชแแแก แแแ IPv4-แแ. แแก แแแแแแแ แแ แแคแแแแก แแแแแซแแก แแแแ , แ แแแแแกแแช แฉแแแ แแฃแฌแแแแแ แแแแแ แแแแฃแ NAT-แก. แกแแแแ แแกแแแ แ แขแ แแคแแแแกแแแแก (แแ IPv6-แแแ IPv4-แจแ แแแแแงแแแแแกแแแแก) แแ แแก แแแแแ แแแแแ แแแแฃแแ NAT แแแแแซแ.
แแแ แแแแแ แ แขแ แแคแแแ แแแแแแแแแกแแแแแ แแแแแแขแแแแแแ แแแแแก แแ แแคแแแแก แแแแแซแแแจแ, แ แแแแแแแช แแแแแ แแกแ แฃแแแแแ แแแแแแแแกแแแแก.
แแแ แแแแ แแแแแซแ แแ แแก แฌแแแแแแแ แกแแกแแแแ. แแก แแแแฎแแแก แฐแแจแก
5 แแ แแแแ แฐแแจแ แแแแฎแแแ แแแ แแแแแแแ แแแแแแแแแแแก แจแแกแ แฃแแแแแจแ แจแแแแแแ แแแแแแแแแแ แฃแ แฐแแจแแแ แแแแแซแจแ, แแกแแแ แฃแแแ แแแแฃแแแแแแแแ แ แแกแฃแ แกแแแแก แกแแแก แชแแแแแแแแแก แแแแแแกแแ แแก แฃแแแ. แ แแแแกแแช แแแแแขแ, แ แแแแแกแแแแกแแช แแ แแ แแก แกแแกแแ, แแแแแก แแแแแแกแแ แแแ, แแก แแแแแแแแแ แแแแแแแแแแ แฃแแ แฐแแจแแ แแแแก แแแแแซแจแ. แกแฌแแ แแ แแฅ แฎแแแแ แแแแแแแแกแแแ แแแแแแแแแแ แฃแแ แฐแแจแแ แแแแก แแแแแงแแแแแแ: แฉแแแ แแแ แฉแแแ แ แแกแฃแ แกแก แฎแแแแแกแแฌแแแแแ โแชแแชแฎแแแโ แ แแกแฃแ แกแแแแก แกแแแแแ. แจแแแแแแ, แแแแแขแแแ แแแแแแแแแ NAT แแแแแซแจแ, แ แแแแแแช แคแแฅแขแแแ แแแแ แชแแแแก แแแแแจแแฃแแแแแก แแแกแแแแ แแก แแ แฎแแแแฎแแ แแแแแแแแแก แกแแแแแขแ แแแ แฏแแแแแก. แ แแแแ แช แฎแแแแแ, แฉแแแ แแแชแแแ VPP-แแก แฌแแกแแแก - แแแกแฌแแแก แแแฌแแแแแ, แแกแแแแกแ แแแแแแแแแแแก แแแฏแแฃแคแแแ แแ แแชแแกแแ แแก แฅแแจแแก แแคแแฅแขแฃแ แแแแก แแแกแแแ แแแแแ.
แแแแแแแแแแ แฃแแ แฐแแจแแแแ
แ แแขแแ แแแแ แฉแแแ แแ แ แ แแ แแก แแก? แแแ แแแ แ แแแจแ, แแแแแแฎแแแแ แฌแแแ แแแแแแแแ - แ แแกแฃแ แกแแก แจแแ แฉแแแ แกแแแแแ.
แแ แแแแแแแแแแแ แฃแแ แฐแแจแแ แแแแ, แแแแแแแแแแแ แจแแแแแแแแแ แแแแแขแแก แฐแแจแ, แแ แ แแกแฃแ แกแ แจแแแ แฉแแแ แกแแแแแ แแ แฐแแจแแก แ แแกแฃแ แกแแแแก แ แแแแแแแแแแ แแแงแแคแแ. แกแแแแ แกแแ แฃแชแแแแแ แ แฉแแแ, แแก แกแฅแแแ แแแ แแแ แแฃแจแแแแก: แฉแแแ แงแแแแแแแแก แแแแแแแแแ แแแแแขแแแก แแ แแแแแแแแแ 5-แฏแแ แแแ แแ แแกแ แแ แแแแแ แแแกแขแแแชแแแแ. แแฃ, แแแแแแแแแ, แแแแแแ แแแ แ แแกแฃแ แกแแ แจแแฌแงแแแขแ แแแกแฃแฎแแก แแแชแแแ แฏแแแแ แแแแแแแก แจแแแแฌแแแแแแแ, แแแจแแ แฐแแจแแแแก แแแแจแแแแแแแแแ แแแฌแแแแกแแแแก แแ แฉแแแแแ แจแแแชแแแแแ. แแแแแแขแแก TCP แแแแจแแ แแแ แแแแ แฆแแแแ: แแแแแขแแ, แ แแแแแแช แแแ แ แแแแฆแฌแแ A แแแแแแแแก, แจแแแซแแแแ แแแแฌแงแแก B แแแแแแแแแ, แ แแแแแแช แแ แแชแแแแก แแ แแแแแขแแก แกแแกแแแก.
แแแแแแแแแแ แฃแแ แฐแแจแแแแ แฌแงแแแขแก แแฆแฌแแ แแ แแ แแแแแแแก. แแ แแแแชแแคแชแแแก แแฎแกแแแก แงแแแแแแ แแแ แขแแแ แแแ แแกแแแแ: แฌแแ แแแแแแแแแ, แ แแ แแฅแแแ แแแฅแแ แ แแแแ, แ แแแแแแแช แ แแกแฃแ แกแแแก แแแแฌแแแแแ แฐแแจแแก แแแฎแแแแแ (แแแแแแแแแ, IP:แแแ แขแแก แกแแจแฃแแแแแแ). แ แแกแฃแ แกแแก แแ แฉแแแ แแ แแก แแแ แแแแก แจแแแแแ แฃแแแแ แแฃแแฎแแ, แ แแแแแแช แแแแแกแแแฆแแ แแแ แแแแแขแแก แฐแแจแแ.
แแก แแแชแแ แแแก แขแ แแคแแแแก แแแแแแแฌแแแแแแก, แ แแแแกแแช แแชแแแแแ แ แแกแฃแ แกแแแแก แจแแแแแแแแแแแ. แ แแกแฃแ แกแแก แฌแแจแแ แแแแแแแแก แแแแฎแแแแก แแฎแแแแ แแแแแแแแแแ แฃแแ แฐแแจแแ แแแแก แ แแแแแก แแแฌแแแแ, แ แแแแแจแแช แแแแแแ แแแแแ แ แแกแฃแ แกแ. แ แแกแฃแ แกแแก แแแแแขแแแ แแกแแแ แชแแแแก แแแกแขแ แแแฃแชแแแก, แแแแ แแ แแแแฅแแก แฌแแแแแแแ แกแแกแแแแแก แแแแแซแ, แ แแแแแแช แกแแจแฃแแแแแแก แแแแซแแแแก แแ แแแแแแแขแแแแ แฃแแแ แจแแฅแแแแแ แกแแกแแแแ แแฎแแ แ แแกแฃแ แกแแแแ.
แฉแแแ แจแแแฎแแแแ แ แ แฎแแแแ แฃแจแฃแแแ แขแ แแคแแแก แแแแแแกแแ แกแ แแ แ แแกแฃแ แกแแแก แจแแ แแก. แแฎแแ แแแแแ แจแแแฎแแแแ แแแแ แฃแแแแแก แแแซแ แแแแแก. แแก แแแฐแงแแแแ แแแแแ แกแฅแแแแก, แ แแแแ แช แกแแแแแขแ แแแ แขแ แแคแแแก - แแแแแ แแแแฃแแ NAT-แแก แแแจแแแแแแ, แแแฃ แกแแแแ แแกแแแ แ NAT 44-แแก แแแจแแแแแแ แแแแแแขแแก แขแ แแคแแแแกแแแแก แแ NAT 46-แแก แแแจแแแแแแ แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แขแ แแคแแแแกแแแแก. แฉแแแ แแแชแแแ แฉแแแแก แกแแแฃแแแ แกแฅแแแแก: แฉแแแ แแแแ แแแแแแแ แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แขแ แแคแแแก แแ แ แแแแฃแ แแแแฎแแแ แแแแแก แขแ แแคแแแก.
Loadbalancer-แแแแแซแ แแ แแฌแงแแแแแ แแแแแแแแแขแแแ
แแแแแแกแแ แแแแกแ แแ แ แแกแฃแ แกแแแแก แจแแแแแแแแแแแ VPP-แจแ แแฃแฌแงแแแ แแแแแแแแ แแแ แกแแ แแแกแ - loadbalancer-node. แแแ แแฌแแ แก แแแแแแแแแแก แแแแแแก แแแขแแแ แแแแก แแแแแแกแแก แแแแขแ แแแแ แแแแ แแ แจแแฃแซแแแ แแแแแกแแฎแแก แแแแกแฎแแแแแแ แแแแแแแแ แ VPP แแแแแแแ แแแแแกแ แแ แแแแขแ แแแแ แแกแแแ แแแฆแแแฃแ แกแแแแแแ แแแแแแแ แแแแแก แจแแ แแก. แฉแแแ แแแฆแแแ แแแฎแฃแ แฃแ แกแแกแขแแแแก: API-แแแ แแแแแแแแแ แแแแแก แแแแแแกแแก แแแแขแ แแแแ แแแ, แ แแแแแแช แแแแแแแแแแก แแแแญแแแก แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แแแแขแ แแแแ แก แ แแกแฃแ แกแแแแก โแกแแชแแชแฎแแแกโ แจแแกแแแแฌแแแแแแ. แแก, แแแแแก แแฎแ แแ, แแแแญแแแก แแแแแแแแแแก แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แแแแแซแก แแ แแแ แแแแแก แจแแแแแแแก, แ แแก แจแแแแแแแช แแก แฃแแแแแแแก แแแ แแแแแแกแแก แแแแขแ แแแแ แก. Loadbalancer-node แแฌแแ แก แแแแแแแแแก แแแแขแ แแแแ แแแแ แแ แชแแแแก VPP-แแก แแแแแแแ แแแแแก. แแกแแ แกแแกแขแแแแจแ แแแแแแฃแแแ แกแแ แแแกแแ แแชแแก แแฎแแแแ แแก, แ แแช แกแแญแแ แแ แแแแแแแแ แกแแ แแแกแแแแก แจแแกแแฎแแ. แแแแจแแ แแแแก แ แแแแแแแแ แจแแแฆแฃแแฃแแแ แแ แแแแฅแแก แจแแกแแซแแแแแแแ แกแฎแแแแแกแฎแแ แกแแแแแแขแแแแก แแแแแฃแแแแแแแแ แแฃแจแแแแ แแ แแแกแจแขแแแแ แแแ.
แ แ แกแแแแแฎแแแ แแฅแแ แแชแแแแแฃแแ?
แงแแแแ แฉแแแแ แกแแ แแแกแ แกแแแแแขแ แแแ แกแแแ แขแงแแจแ แฉแแฌแแ แแแแ Go-แจแ แแ แแฅแแก แแแ แแ แแแกแจแขแแแแ แแแแก แแ แกแแแแแแแแแแก แแแฎแแกแแแแแแแแแ. Go-แก แแฅแแก แแ แแแแแ แฆแแ แแแแแก แแแแแแแแแแ แแแแแฌแแแแแฃแแ แกแแกแขแแแแแแก แจแแกแแฅแแแแแแ. แฉแแแ แแฅแขแแฃแ แแ แแแงแแแแแ GRPC-แก, แงแแแแ แแแแแแแแแขแ แจแแแชแแแก แกแแ แแแกแแก แแฆแแแฉแแแแก แฆแแ แแแแแก แแแแฎแแ แชแแแแแแแก - แฉแแแแ แกแแ แแแกแแแ แแแแแ แแแแแแ แแ แแแแแแแแก แแฃแจแแแแแก, แจแแฃแซแแแแ แแแแแแแฃแ แแ แจแแชแแแแแ แแแแ แจแแแแแแแแแแแ แแ แฉแแแ แแก แแแแฃแแแแจแแ แแ GRPC แแแแแแแแกแแแแก. แแแขแ แแแแแแกแแแแก, แฉแแแ แแกแแแ แแแงแแแแแ แฆแแ แแแแแก แแแแแฌแงแแแขแแก. แแแแแชแแแแ แกแแแ แขแงแแจแ, แฉแแแ แแแแแฆแแ แฆแแ แกแแฃแแ แจแแกแ แฃแแแแ แแ แแแแ แ แแกแฃแ แกแแก แ แแแแ แแ: แแฆแแแฉแแแ, แ แแ แซแแแแแ แ แแฃแแ แแงแ แกแขแแแแแก แจแแแ แแแ, แ แแแแแแแแแช แจแแแแแซแแ แแแแแงแ แแแแ VPP-แแก แแฃแจแแแแแก แแ แแ แ แ แแแแแก แฅแกแแแแก แแแ แแแก.
แแ แแแแแแแแ แแ แแแแแฌแงแแแขแแแแแแแ
แ แ แแ แแฃแจแแแแแ แแกแ แแแ แแแ? Go-แก แแฅแแก แแแฎแกแแแ แแแแก แแแขแแแแขแฃแ แ แแแ แแแ, แแแแ แแ แแแฎแกแแแ แแแแก แแแแแแแ แแแแแช แฎแแแแ. แแแแแแ แแแแแแแแแแแก แฃแแแ แขแแแแกแ แแแแ แแแ แฃแขแแแแก แแแจแแแแ แแ แแแแ แจแแฌแงแแแขแแก แแแแแฎแกแแแ แแแ. Takeaway: แฃแงแฃแ แแ แแฅแแแแ Go แแ แแแ แแแแแแก แแแฎแกแแแ แแแแก แแแฎแแแ แแแแก. แฎแจแแ แแ แแแ แแ แแแฉแแแแแแแแแ แแแ แฃแขแแแแแแก แ แแแแแแแแ. แแ แแแแแแจแ แแ แแก แแแฃแกแ: Go-แจแ แแแ แขแแแแ แแแจแแแแแก แแแแแชแแแแแแก แแแฆแแแ - แแแฎแกแแแ แแแแก แแแฎแแแ แแแ, แแแจแแแแฃแแ แแแ แฃแขแแแแแแก แ แแแแแแแแ แแ แแ แแแแแ แกแฎแแ แแแ แแแแขแ แ.
แแกแแแ, Go แจแแแซแแแแ แแ แแงแแก แกแแฃแแแแแกแ แแ แฉแแแแแ แคแฃแแฅแชแแฃแ แ แขแแกแขแแแแกแแแแก. แแกแแแ แกแแแแแแ แแ แแแแแกแแแขแงแแแแแแ แแ แแแ แแ แกแขแแแแแ แขแฃแแ แแแแแแแ โแงแแแแแคแแ แ CI-แจแ แแแ แขแแแจแ แแแจแแแแโ แแแแแแแก แแ แช แแฃ แแกแ แจแแกแแคแแ แแกแแ. แคแแฅแขแแ, แ แแ แคแฃแแฅแชแแแแแแฃแ แ แขแแกแขแแแ แฃแคแ แ แ แแกแฃแ แกแแแแก แแแแแฎแแแแแ แแ แ แแแแฃแ แแ แแจแ แจแแคแแ แฎแแแแก แแฌแแแแก. แแแแก แแแแ, แขแแกแขแแแ แจแแแซแแแแ แฉแแแแ แแแก, แ แแแแแ CPU แแแแแแแแฃแแแ แแ แแแฃแแแก แขแแกแขแแแแ. แแแกแแแแ: แแฃ แจแแกแแซแแแแแแแ, แจแแแกแ แฃแแแ "แแซแแแ" แขแแกแขแแแ แชแแแแแฃแแ แขแแกแขแแแแกแแแ.
แแแแ แแกแแ แแแกแแก แฆแแแแกแซแแแแแก แแ แฅแแขแแฅแขแฃแ แ แฃแคแ แ แ แแฃแแแ, แแแแ แ แแแแแแแแ: แแแแแแ แกแฎแแแแแกแฎแแ แแแแ แแขแแ แแฃแ แแแแแแแก แจแแแ แแแแแ แแ แช แแฃ แแกแ แแแกแแฎแแ แฎแแแแแแ. แแแกแแแแ: แแฃ แแฅแแแ แแแแแแแ แแแแ แแกแแ แแแกแแแก, แแแฃแงแแแแแแแแ แแคแแฅแ แแ แแแแแแแแแแ.
แฉแแแแ แแแแแแแ
แฉแแแ แแแแแแแแฃแจแแแแแ แจแแแ แแแแแแกแแ แก, IPv6 แแแแแแกแแ แก, แแแแแแแขแแแ Kubernetes แกแแ แแแขแแแแก แแฎแแ แแแญแแ แแก, แแแแแแ แซแแแแแ แฉแแแแ แกแแ แแแกแแแแก แแแจแแแก (แแแแแแแ แแฎแแแแ healthcheck-node แแ healthcheck-ctrl แแ แแก แแแฎแแฎแแแ), แแแแแแแขแแแ แฏแแแแ แแแแแแแก แแฎแแ แจแแแแฌแแแแแแก แแ แแกแแแ แแแแแแฎแแ แชแแแแแแ แจแแแแฌแแแแแแแก แญแแแแแแฃแ แแแ แแแแชแแแก. แฉแแแ แแแแแแฎแแแแแ แจแแกแแซแแแแแแแแก แแแแฎแแแแ แฉแแแแ แกแแ แแแกแแแ แแแแแ แฃแคแ แ แแแแแฃแแแแแแแแ - แแกแ, แ แแ แแแ แแแฃแแแแจแแ แแแแ แแ แ แฃแจแฃแแแแ แแ แแแแแแแแแ, แแ แแแแ แจแแขแงแแแแแแแแแแก แ แแแแก แแแแแงแแแแแแ. แแฎแแแฎแแ แฆแ แฃแแแแจแ แแแแแฉแแแ SQS-แแแ แแแแกแแแแแ แกแแ แแแกแ
แแฎแแแฎแแ แแแฎแแ Yandex Load Balancer-แแก แกแแฏแแ แ แแแแแจแแแแ. แฒแแแแแแแแแ
แฌแงแแ แ: www.habr.com