Cisco ACI แกแแ แแแขแแก แแ แฏแแแแกแแฃแ แ แแแฌแแแแก แแแฎแแแ แแแแ แแฅแแแ แจแแแแซแแแแ แกแฌแ แแคแแ แแแแงแแแแ แฅแกแแแ.
Cisco ACI แแแแแชแแแแ แชแแแขแ แแก แฅแกแแแแก แฅแแ แฎแแแ แฃแแแ แฎแฃแแ แฌแแแแ แแ แกแแแแแก, แแแแ แแ แฐแแแ แแก แแแแแ แแแแแแแแแ แแ แแคแแ แ แฃแแฅแแแแก, แแแแขแแ แแแแแแฌแงแแแขแ แชแแขแ แแแแแแแกแฌแแ แแแแแ. แกแแแฃแแแ แ แแแแแชแแแแแแแแแ แแแขแงแแแ, แ แ แแ แแก, แ แ แกแแ แแแแแแแ แแแแฅแแก แแ แกแแ แแฅแแก แ แแแ.
แ แ แแ แแก แแ แกแแแแแ แแแฉแแแ?
แแ แแ แแแกแแแแก, แ แแแแกแแช ACI (Application Centric Infrastructure) แแแแแชแฎแแแแ 2013 แฌแแแก, แแแแแฃแ แแแขแแแ แแแแฌแแแแแแ แขแ แแแแชแแฃแ แแแแแแแแแแ แแแแแชแแแแ แชแแแขแ แแก แฅแกแแแแแแแ แแ แแแ แแฃแแแ แกแแแ แแฎแ แแแแ.
แแ แแแก แแฎแ แแ, "แแแ แแแแ แแแแแแก" SDN แแแแแฌแงแแแขแแแแแแแ OpenFlow-แแ แแแคแฃแซแแแแฃแแ แแแ แแแ แแแแ, แ แแ แฅแกแแแแแ แฃแคแ แ แแแฅแแแแ แแ แแแแแ แแ แแก แแแคแ แแฅแแแแ. แแแแ แแงแ แแแแแฌแงแแแขแแแแแแก แแแฆแแแ, แ แแแแแแช แขแ แแแแชแแฃแแแ แแแแแแแ แกแแแฃแแ แแแแก แแแแแแ แแแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แกแแจแฃแแแแแแ, แชแแแขแ แแแฃแ แแแแขแ แแแแ แแ.
แแ แแแแขแ แแแแ แก แแฅแแแแ แแ แแแแแ แฎแแแแ แงแแแแแคแ แแก แจแแกแแฎแแ, แ แแช แฎแแแแ แแ, แแแแก แกแแคแฃแซแแแแแ, แแแแ แแแ แแแแแก แงแแแแ แแแแแแ แแแแแแก แแแแ แแขแฃแ แแก แแแแแ แแขแฃแแ แแแแแแแแแก แแแแฃแจแแแแแแก แฌแแกแแแแก แแแแแแ.
แแแแ แแก แแฎแ แแ, แแแแแคแแ แแแก แฅแกแแแฃแ แ แแแแแฌแงแแแขแแแแแแแ แจแแกแแซแแแแแแก แฎแแแแ แแแแแแจแแ แแแแก แแ แฃแกแแคแ แแฎแแแแแก แแแแแขแแแแก แแแแฎแแ แชแแแแแแแก, แคแแแแแฃแ แฅแกแแแจแ แงแแแแแแแแ แ แชแแแแแแแแก แแแ แแจแ, แแแ แขแฃแแแฃแ แฐแแกแขแแแก แจแแ แแก แแ แแแ แแแฃแแ แแแแ แแแแแแก แแแแแแ. แแ แแแแแแแแก แงแแแแแแ แชแแแแแแ แแแแแแแแ แแงแ Nicira, แ แแแแแแช แแ แแ แแแกแแแแก แฃแแแ แจแแซแแแแแ แแงแ VMWare-แแก แแแแ 1,26 แแแแแแ แ แแแแแ แแ แแ แฌแแ แแแจแแ แแแแแแแแแแแ VMWare NSX. แกแแขแฃแแชแแแก แแแ แแแแฃแแ แแแแแแขแฃแ แแแ แแแแแแขแ แแ แคแแฅแขแก, แ แแ Nicira-แก แแแแแแแแคแฃแซแแแแแแแ แแงแแแแ แแแแแ แแแแแแแแแแ, แ แแแแแแแช แแแ แ OpenFlow-แแก แกแแฌแงแแกแแแแ แแแแแแ แแ แแฎแแ แแแแแแแ, แ แแ แแแแแชแแแแ แชแแแขแ แแก แฅแแ แฎแแแก แแกแแจแแแแแแแ .
แแ แแแแแก, แฆแแ แแแแแ แแ แแ แกแแแฃแแแ แฉแแแแแแ (แ แแกแแช แกแแแแญแ แ แกแแแแแแแ แฐแฅแแแ) แแแแฆแฌแแ แกแแแฌแแคแแก แแขแแแก, แกแแแแช แแกแแแ แ แแแแฃแ แกแแคแ แแฎแแ แแฅแชแแแ แขแ แแแแชแแฃแแ แแแแแ แแแแก แแฌแแ แแแแแแแแแกแแแแก. แแฃ แแแ แ แแแแแแฃแแแ แแแแงแแแแแแแ แแแแแฃแแแแแแแแ แจแแแแฃแจแแแ แฉแแแแแ แแแแแกแ แแแแชแแแขแ แแขแแ แแแแกแแแแก, แแแจแแ แแ แแแ แแแแแแแแแแแจแ, แแแกแแแ แแฎแแ แแก แแฌแแ แแแแแแแแแก แฉแแแแแแ, แแแ แแแ แ แแแจแ, Broadcomโ แแแ, แแแแฌแงแแก แแแแซแแแแก แจแแแชแแ แแแ แแแแงแแแแแแแก แฉแแแแแแแ แคแฃแแฅแชแแแแแก แแแแแกแแแ แแกแแ แแ แแแแแแญแแ แแ แแแ แคแแกแแก / แจแแกแ แฃแแแแแก แแแแแคแแ แแแแแก แแแแแกแแแ แแกแแ. แแแแขแแ, แแแแ แก แกแฏแแ แแแ, แ แแ แกแแแฃแแแ แ แแแแแแแแก แฉแแแแแแ แแแแแ แแแแก แแฆแแแแ แแแแแแแแแ.
ACI แแแฎแแ Cisco-แก โแแกแแแแขแ แแฃแแ แแแกแฃแฎแโ (แฃแคแ แ แแฃแกแขแแ, แแแกแ แแแแแแแแ Insieme, แ แแแแแแช แแแแ แกแแ แแแกแ แงแแคแแแ แแแแแแจแ แแแแแแแก แแแแ ) แงแแแแแแแ แแแแแแฅแแฃแแแ.
แ แ แแแแกแฎแแแแแแแ OpenFlow-แแแ?
แคแฃแแฅแชแแแแแก แแแแแฌแแแแแแก แแแแแกแแแ แแกแแ, ACI แกแแแแแแแแแแจแ แแ แแก OpenFlow-แแก แกแแแแ แแกแแแ แ.
OpenFlow แแ แฅแแขแแฅแขแฃแ แแจแ แแแแขแ แแแแ แ แแแกแฃแฎแแกแแแแแแแแ แแแขแแแฃแ แ แฌแแกแแแแก (แแแแแแแแแก) แแแฌแแ แแแ.
แงแแแแ แแแแแแ แแแแแแก แแแแ แแขแฃแ แแจแ, แแแฃ แแแ แฅแกแแแจแ, แแก แจแแแซแแแแ แแงแแก แแแกแฃแฎแแกแแแแแแแ แแแแแแ แแแแแแแ แฉแแแแฌแแ แแก แจแแแแ แฉแฃแแแแแแ แแ, แ แแช แแแแแแ แแ, แจแแชแแแแแ แฅแกแแแแก แแกแแแแ แฌแแ แขแแแจแ, แแกแ แ แแ, แแแกแ แจแแกแ แฃแแแแ แแ แกแแแแแแแ แฎแแแแ แแแ แแแ แ. แแแแ แแแแฎแแ แชแแแแแแ.
ACI แแงแแแแแก แกแแแแ แแกแแแ แ แแแแแแแแก: แ แ แแฅแแ แฃแแแ, แแ แแก แแกแแแ แแแแขแ แแแแ แ, แแแแ แแ แแแแชแแแขแ แแขแแ แแแ แแแกแแแ แแฆแแแแ แแแฆแแแ แแแแแก แแแแแแ แแชแแฃแ แแแแแขแแแแก แแ แแแแแ แแแแแแ แแแแแ แแกแ แฃแแแแก แแแ แแแแแชแแแแก แแแแ แแขแฃแ แแก แกแแแชแแคแแแฃแ แแแ แแแแขแ แแแจแ. แแแแขแ แแแแ แ แจแแแซแแแแ แแแแแขแแแ แแแ แแ แกแแแ แแแ แแแแแ แแแ แแ แชแฃแแ แแ แแคแแ แ แแแฎแแแแ แฅแกแแแจแ, แแแ แแ, แ แ แแฅแแ แฃแแแ, แแ แแแแแแขแจแ แแแแขแ แแแแก แแ แแ แกแแแแแแก แแแ แแ. แกแแแแขแแ แแกแแ, แ แแ แแ แแก แกแแขแฃแแชแแแแ ACI-แจแ, แ แแแแแแจแแช OpenFlow แแแแแ แแแแแแงแแแแแ, แแแแ แแ แแแแแแฃแ แแ แฐแแกแขแจแ Open vSwitch แแ แแแ แแแแ แแแแกแแแแก.
ACI แแแแแฃแแแ แแแแแแแแ VXLAN-แแ แแแคแฃแซแแแแฃแ แแแแแคแแ แแแก แขแ แแแกแแแ แขแแ, แแแแ แแ แแแแชแแแก แซแแ แแแแ IP แขแ แแแกแแแ แขแก, แ แแแแ แช แแ แแ แแแแแฌแงแแแขแแก แแแฌแแแก. Cisco-แ แแแแก แฃแฌแแแ "แแแขแแแ แแ แแแฃแแ แแแแแคแแ แแแก" แขแแ แแแแ. ACI-แจแ แแแแแฎแฃแ แแแก แแแกแแกแ แฃแแแก แแฃแแฅแขแแ, แฃแแแขแแก แจแแแแฎแแแแแจแ, แแแแแแงแแแแแ แฅแแ แฎแแฃแแ แแแแชแแแขแ แแขแแ แแแ (แแกแแแ แแแแก แแแแแแแแ แแแฃแแ แกแแฉแฅแแ แแ). แแแกแแแแซแแแแก แแ แแแแแฎแแแแแแ แแ แแคแแ แ แแชแแแแแ แฅแแ แฎแแแก, แแแแแคแกแฃแแแชแแแก แแ แ.แจ., แแฃแแชแ, แแแแแแ แ แจแแแแฎแแแแแจแ (แแแแแแแแแ, OpenStack แฐแแกแขแแแแก แแแกแแแแแจแแ แแแแแ), แแแแแแ VXLAN แขแ แแคแแแแก แแแขแแแ แจแแกแแซแแแแแแแ.
แแแแแคแแ แแแแ แแแแแแงแแแแแ ACI-แจแ แแ แ แแฎแแแแ แกแแขแ แแแกแแแ แขแ แฅแกแแแแก แแแจแแแแแแ แแแฅแแแแ แแแแจแแ แแก แฃแแ แฃแแแแแกแแงแแคแแ, แแ แแแแ แแแขแแแแคแแ แแแชแแแก แแแแแกแแชแแแแ (แแก แแแแแแงแแแแแ, แแแแแแแแแ, แฃแกแแคแ แแฎแแแแแก แแแแแขแแแแก แแแแแกแแงแแแแแแแ).
Broadcom-แแก แฉแแแแแ แแแ แ แแงแแแแแแ Cisco-แก Nexus 3000 แกแแ แแแก แแแแแแ แแแแแแแจแ. Nexus 9000 แแฏแแฎแจแ, แกแแแชแแแแฃแ แแ แแแแแจแแแแฃแแ ACI-แก แแฎแแ แแแกแแญแแ แแ, แแแแแแแแ แแแแแ แแแแแ แแแก แฐแแแ แแแฃแแ แแแแแแ, แ แแแแแกแแช แแฌแแแ Merchant +. แแแแแแ แแแแแแ แแ แแแ แแฃแแแ แแแแแแงแแแ แ แแแแ แช แแฎแแแ Broadcom Trident 2 แฉแแแ, แแกแแแ Cisco-แก แแแแ แจแแแฃแจแแแแแฃแแ แแแแแขแแแแแ แฉแแแ, แ แแแแแแช แแฎแแ แชแแแแแแก ACI-แแก แแแแ แแแแแแก. แ แแแแ แช แฉแแแก, แแแแ แจแแกแแซแแแแแแ แแแฎแแแ แแ แแแฃแฅแขแแก แแแแแจแแแแแก แแแฉแฅแแ แแแ แแ แแแแแแ แแแแแแก แคแแกแแก แจแแแชแแ แแแ แแฎแแแแ Trident 2-แแ แแแคแฃแซแแแแฃแ แแแแแแแแแแ แแฎแแแก. แแก แแแแแแแ แกแแแแแ แแกแ แแงแ ACI-แแก แแแฌแแแแแแก แแแ แแแแ แแ แ แแ แกแแแ แฌแแแก แแแแแแแแแแแจแ. แแ แแ แแแก แแแแแแแแแแแจแ, Cisco-แ แจแแแแฃแจแแแ แแ แแแแแฃแจแแ แจแแแแแแ แแแแแแก Nexus 9000 แกแแแฃแแแ แฉแแแแแแ แแแขแ แคแฃแแฅแชแแแแแ แแแแแ แแ แคแฃแแฅแชแแแแแก แแแแ แแแแ, แแแแ แแ แแแแแ แคแแกแแก แแแแแแ. แฅแแ แฎแแแแจแ แฃแ แแแแ แแฅแแแแแแแก แแแแแกแแแ แแกแแ แแแ แ แกแแแชแแคแแแแชแแแแ แแแแแแแแ แแ แแก แแแชแฃแแ. แแแแแแ แแฃแแแ, แแแแแแแแ แจแแแชแแแแ แจแแแ แจแแแกแแแ: แ แแคแแฅแขแแ แแ แแแแก แแกแแแแกแ, แแแแ แแ แ แแแแแกแแแแก.
แ แแแแ แแฃแจแแแแก Cisco ACI Architecture
แฃแแแ แขแแแแก แจแแแแฎแแแแแจแ, ACI แแแแแฃแแแ Klose แฅแกแแแแก แขแแแแแแแแแแ, แแ, แ แแแแ แช แฎแจแแ แแ แแแแแแแ, Spine-Leaf. แฎแแ แฎแแแแแก แแแแแก แแแแแแ แแแแแแแ แจแแแซแแแแ แแงแแก แแ แแแแ (แแ แแ แแ, แแฃ แแ แแแแแแขแแ แแกแแแก แจแแชแแแแแก แขแแแแ แแแขแแแ) แแฅแแกแแแแ. แจแแกแแแแแแกแแ, แ แแช แแแขแ แแแแแแแแ, แแแ แฃแคแ แ แแแฆแแแแ แฎแแ แแแแแก แขแแแแ แแแขแแแ (แแแ แฃแคแ แ แแแแแแแ แแแแขแแ แฃแแแ แแแแแแ แแ แกแแแแแแแแแแก แจแแแชแแ แแแ แแแแ แแแก แแ แแ แแ แฎแแ แฎแแแแแก แจแแแแ แฉแฃแแแแแก แจแแแแฎแแแแแจแ) แแ แแแแแแแ แจแแกแ แฃแแแแ. แงแแแแ แแแ แ แแแแจแแ แ แแแแแก แคแแแแแก แแแแแก แแแแแแ แแแแแแแแ: แแก แแ แแก แกแแ แแแ แแแ, แแแแแแจแแ แแแ แแแ แ แฅแกแแแแแแแ L2 แแ L3-แแก แกแแจแฃแแแแแแ แแ APIC แแแแขแ แแแแ แแแแก แแแแแแจแแ แแแ. แแแแแแแ, ACI-แกแแแ แแ แแแ, แแ แ แแฎแแแแ แแแแคแแแฃแ แแชแแ, แแ แแแแ แกแขแแขแแกแขแแแแก แจแแแ แแแแแ, แฌแแ แฃแแแขแแแแแแแก แแแแแขแแ แแแแ แแ แ.
แแฅแแแ แแ แแกแแแแก แแญแแ แแแแแ แแแแกแแแแ แแแแแแจแแ แแแ แแแแกแแแแ, แแฃแแแแช แฅแกแแแแก แแแกแแฌแงแแแแ: แแแแขแ แแแแ แ แแแแแ แแแแแชแแแแก แแแแแแ แแแแแแแก แแ แแฌแงแแแก แแแแแแ แฅแแ แฎแแแแก, แแแ แจแแ แแก แงแแแแ แกแแ แแแกแแก แแ แแขแแแแแแก แแแ แแแแขแ แแแก, แแแแขแแ, แกแฎแแแแ แจแแ แแก, แซแแแแแ แแแแจแแแแแแแแแแ แฉแแฌแแ แแ แแแกแขแแแแชแแแก แแ แแก แแแงแแแแแฃแแ แแฆแญแฃแ แแแแแแแก แกแแ แแฃแแ แแแแ แแแ, แ แแแ แแแแแแแแแแแ แแ แแแแญแแ แแแ แแแแแแชแแแ แ แแแแแ แแแแแแ แแแแแ แ แแแแ แแแ แแจแแ แแแแแแแกแแแฃแแ. แแ แแแแแแแแแก แแฆแแแกแแคแฎแแ แแแแ, แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ, แจแแแแซแแแแ SSH-แแก แกแแจแฃแแแแแแ แแแฃแแแแจแแ แแแ แแแแแแ แแแแแแแก: แแกแแแ แกแแแแแแ แคแ แแฎแแแแ แแฌแแ แแแแแแ Cisco แจแแฃแก แฉแแแฃแแแแ แแ แแ แซแแแแแแแก.
แจแแแแแแแแ, แฅแแ แฎแแแ แแงแแแแแก IP แขแ แแแกแแแ แขแก, แแกแ แ แแ, แแแกแจแ แแ แแ แแก Spanning Tree แแ แฌแแ แกแฃแแแก แกแฎแแ แกแแจแแแแแแแแแ: แฉแแ แแฃแแแ แงแแแแ แ แแแแ แแ แฉแแแแ แแแแก แจแแแแฎแแแแแจแ แแแแแแ แแแแชแแ แซแแแแแ แกแฌแ แแคแแ. แฅแกแแแแแจแ แแแซแ แแแแ แแแแแแชแแแ VXLAN-แแ แแแคแฃแซแแแแฃแแ แแแแ แแแแแแ. แฃแคแ แ แแฃแกแขแแ, แแแแแ Cisco แฃแฌแแแแแก iVXLAN encapsulation-แก แแ แแก แแแแกแฎแแแแแแแ แฉแแแฃแแแแ แแแ VXLAN-แแกแแแ แแแแ, แ แแ แฅแกแแแแก แกแแแแฃแ แจแ แแแชแฃแแ แแแแแแ แแแแแแงแแแแแ แกแแ แแแกแแก แแแคแแ แแแชแแแก แแแแแกแแชแแแแ, แซแแ แแแแแแ EPG แฏแแฃแคแแแ แขแ แแคแแแแก แฃแ แแแแ แแแแแก แจแแกแแฎแแ. แแก แกแแจแฃแแแแแแก แแแซแแแแ แแแแแฎแแ แชแแแแแ แแแฌแงแแแแแแแแแแก แฏแแฃแคแแแก แจแแ แแก แฃแ แแแแ แแฅแแแแแแแก แฌแแกแแแ, แแแแ แแแแ แแแแก แแแแแงแแแแแแ แแกแแแ, แ แแแแ แช แแแกแแแแ แแแแ แแแแแแงแแแแแ แฉแแแฃแแแแ แแ แฌแแแแแแก แกแแแแจแ.
แแแแ แแแแแ แกแแจแฃแแแแแแก แแซแแแแก L2 แกแแแแแแขแแแก แแ L3 แกแแแแแแขแแแก (แแแฃ VRF) แแแแญแแแแ แจแแแ IP แขแ แแแกแแแ แขแแ. แแ แจแแแแฎแแแแแจแ, แแแแฃแแแกแฎแแแแ แแแ แแแญแ แแแฌแแแแแแ. แแก แแแจแแแแก, แ แแ แแแแแแฃแแ แแแแแแ แแแแแ แแแกแฃแฎแแกแแแแแแแแ แฅแกแแแแแจแ แจแแแแแแแ แขแ แแคแแแแก แแแ แจแ แฃแขแแ. แขแ แแคแแแแก แแแแแแแก แแแแแแแก แแแแแกแแแ แแกแแ, ACI แแกแแแแกแแ VXLAN/EVPN แฅแกแแแแแแก.
แแฃ แแกแแ, แ แ แแแแกแฎแแแแแแแแแ? แฒกแฎแแ แแแแแ แฉแแแ!
แแแแแ แแแ แแแแ แแแแกแฎแแแแแแ, แ แแแแแกแแช แจแแฎแแแแแแ ACI-แกแแแ แแ แแก แแก, แแฃ แ แแแแ แฃแแแแจแแ แแแแ แกแแ แแแ แแแ แฅแกแแแก. แขแ แแแแชแแฃแ แฅแกแแแแแจแ, แ แแแแ แช แคแแแแแฃแ แ แกแแ แแแ แแแแก, แแกแแแ แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแก แฉแแ แแแ แแแแแแแก VLAN-แแแแ แแ แงแแแแแคแแ แ แแแแแ แฉแแแ แแแแแแ แชแแแแแแก: แแแแจแแ แ, แฃแกแแคแ แแฎแแแแ แแ แ.แจ. ACI-แจแ แแแแแแงแแแแแ แแแแแแแ, แ แแแแแกแแช Cisco แฃแฌแแแแแก EPG (End-point Group), แกแแแแแแแช แแ แกแแ แแ แแก แแแกแแฅแชแแแ. แจแแกแแซแแแแแแแ แแฃ แแ แ แแแกแ แแแแแแแแแ VLAN-แแแ? แแแแฎ, แแแแ แแ แแ แจแแแแฎแแแแแจแ แแ แแก แจแแแกแ แแแแแ แแแก แฃแแแขแแกแ แแแฌแแแ, แ แแกแแช ACI แแซแแแแ.
EPG-แกแแแ แแแแแแจแแ แแแแ แฉแแแแงแแแแแแแฃแแแ แฌแแแแแแก แงแแแแ แฌแแกแ, แฎแแแ ACI-แจแ แแแแฃแแแกแฎแแแแแ แแแแแแงแแแแแ โแแแแ แ แกแแแกโ แแ แแแชแแแ, แแแฃ แแแแแแแ แแฃแแแ แแฎแแแแ แขแ แแคแแแ, แ แแแแแก แแแแแแช แแแ แแแแแ แแ แแก แแแจแแแแฃแแ. แแแฃ, แฉแแแ แจแแแแแซแแแ แจแแแฅแแแแ "Web" แแ "MySQL" EPG แฏแแฃแคแแแ แแ แแแแแกแแแฆแแ แแ แฌแแกแ, แ แแแแแแช แกแแจแฃแแแแแแก แแซแแแแก แแแ แจแแ แแก แแแแฃแแแแแชแแแก แแฎแแแแ 3306 แแแ แขแแ. แแก แแแฃแจแแแแแก แฅแกแแแแก แแแกแแแแ แแแแแแ แแแแแฃแแแแแก แแแ แแจแ แแ แแฃแแแแช แแแแแ แฅแแแฅแกแแแจแ!
แฉแแแ แแแงแแแก แแแแฎแแแ แแแแแแ, แ แแแแแแแแช แแแ แฉแแแก ACI แแฃแกแขแแ แแ แคแฃแแฅแชแแแก แแแแ, แ แแแแแ แแก แกแแจแฃแแแแแแก แแแซแแแแ แจแแแฆแฃแแแ แฌแแแแแ แกแแ แแแ แแแก แจแแ แแก (แแแ แขแฃแแแฃแ แ แแฃ แคแแแแแฃแ แ - แแ แแฅแแก แแแแจแแแแแแแ) แฅแแแฅแกแแแแแก แจแแ แแก แแแแแแแแแแแแแก แแแ แแจแ, แ แแช แแแจแแแแก แแแกแแแแ แแแแแก แจแแฎแแแแก แแแ แแจแ. แแแแฎ, แแแแฎ, แฉแแแ แแแชแแ, แ แแ แแ แแแแ แแ แฌแแ แก IP แแแกแแแแ แแแแก แแแแแแแชแแแก แแแแคแแแฃแ แแชแแแจแ แฎแแแแ, แแ แ?
ACI-แจแ แแแซแ แแแแแก แฌแแกแแแก แแแแขแ แแฅแขแแแ แแฌแแแแแ. แแกแแ แแแแขแ แแฅแขแจแ, แแ แแแแแกแแคแแฎแฃแ แแแ แแแแแแแชแแแจแ แแ แแ แแ แแแขแ แฏแแฃแคแ แแ แแแแ แฎแแแแ แกแแ แแแกแแก แแ แแแแแแแ แ (แแแฅแแแ, แแแแแชแแแแ แแแแแก แกแแ แแแกแ), แกแฎแแแแ แฎแแแแ แแแแฎแแแ แแแแแ. แแแแขแ แแฅแขแก แจแแฃแซแแแ แฃแแ แแแแ แแแแแ แแก แขแ แแคแแแ, แแ แแแก แจแแฃแซแแแ แแแแแแแแก แ แแแแ แฃแคแ แ แ แแฃแแ, แแแแแแแแแ, แแแแแ แแแก แแแก Firewall-แแ แแ แแแแแแกแแ แแ แแ แแกแแแ แจแแชแแแแแก QoS แแแแจแแแแแแแ.
แ แแแแ แฎแแแแแแแ แกแแ แแแ แแแ แแ แฏแแฃแคแแแจแ? แแฃ แแก แแ แแก แคแแแแแฃแ แ แกแแ แแแ แแแ แแ แ แแแแ, แ แแแแแแช แจแแแแก แแ แกแแแฃแ แฅแกแแแจแ, แ แแแแแจแแช แฉแแแ แจแแแฅแแแแแ VLAN แกแแงแ แแแแ, แแแจแแ แแแแกแแแแแก, แ แแ แแแแแแแแแกแแ แแกแแแ EPG-แจแ, แแฅแแแ แฃแแแ แแแฃแแแแแ แแแแแแ แแแแแ แแแ แขแ แแ แแแกแแ แแแแแงแแแแแฃแแ VLAN. แ แแแแ แช แฎแแแแแ, VLAN-แแแ แฉแแแแแ แแฅ, แกแแแแช แแแ แแแ แแจแ แแ แจแแแแซแแแแ.
แแฃ แกแแ แแแ แแแ แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแ, แแแจแแ แกแแแแแ แแกแแ แแแแแ แแแ แแแแแแจแแ แแแฃแ แแแ แขแฃแแแแแแชแแแก แแแ แแแแก แแ แจแแแแแ แงแแแแแคแแ แ แแแแแกแแแแแ แแแฎแแแแ: แจแแแฅแแแแแ แแแ แขแแก แฏแแฃแคแ (VMWare-แแก แแแแแกแแแ แแกแแ) VM-แแก แแแกแแแแแจแแ แแแแแ, แกแแญแแ แ VLAN-แแแ แแ VXLAN-แแแ. แแแแแญแแแฃแแ แแฅแแแแ, แแกแแแ แแแ แแแแกแขแ แแ แแแแ แแฃแชแแแแแแ แแแแแแ แแแแ แแแ แขแแแแ แแ แ.แจ. แแกแ แ แแ, แแแฃแฎแแแแแแ แแแแกแ, แ แแ ACI แแแแแฃแแแ แคแแแแแฃแ แฅแกแแแแ, แแแ แขแฃแแแฃแ แ แกแแ แแแ แแแแกแแแแก แแแแจแแ แแแ แแแแ แแ แฃแคแ แ แแแ แขแแแ แแแแแแงแฃแ แแแ, แแแแ แ แคแแแแแฃแ แแกแแแแก. ACI-แก แฃแแแ แแฅแแก แฉแแจแแแแแฃแแ แแแแจแแ แ VMWare-แแแ แแ MS Hyper-V-แแแ, แแกแแแ แแฎแแ แแแญแแ แ OpenStack-แแกแ แแ RedHat แแแ แขแฃแแแแแแชแแแกแแแแก. แ แแฆแแช แแแแแแขแแแแ แแกแแแ แแแแแฉแแแ แแแแขแแแแแ แแแแก แแแแขแคแแ แแแแแก แฉแแจแแแแแฃแแ แแฎแแ แแแญแแ แ: Kubernetes, OpenShift, Cloud Foundry, แแแจแแ แ แแแแกแแช แแก แแฎแแแ แ แแแแ แช แแแแแขแแแแก แแแแแงแแแแแแก, แแกแแแ แแแแแขแแ แแแแก, แแแฃ แฅแกแแแแก แแแแแแแกแขแ แแขแแ แก แจแแฃแซแแแ แแแฃแงแแแแแแแแ แแแฎแแก แ แแแแ แฐแแกแขแแแแ แแฃแจแแแแก แแ. แ แแแแ แฏแแฃแคแแแจแ แแแฎแแแแแแแ แแกแแแ.
แแแ แแ แแแแกแ, แ แแ แจแแแแก แแแแแ แแขแฃแ แแแ แข แฏแแฃแคแจแ, แแแ แขแฃแแแฃแ แกแแ แแแ แแแก แแฅแแ แแแแแขแแแแแ แแแแกแแแแแ: แกแแฎแแแ, แแขแ แแแฃแขแแแ แแ แ.แจ., แ แแแแแแแช แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก, แ แแแแ แช แแ แแขแแ แแฃแแแแ แแแแ แกแฎแแ แฏแแฃแคแจแ แแแแแกแแขแแแแ, แแแแแแแแแ, แ แแแแกแแช VM-แก แกแแฎแแแ แแแแแแ แฅแแ แแ แแแแแขแแแแแ แขแแแ แแแแแฉแแแแแ แแก. Cisco แแแแก แแแแ แแกแแแแแแขแแชแแแก แฏแแฃแคแแแก แฃแฌแแแแแก, แแฃแแชแ, แแแแแแแ, แแแแแ แแแแแแแ, แ แแแแแกแแช แจแแฃแซแแแ แแ แแแแแ แฃแกแแคแ แแฎแแแแแก แกแแแแแแขแ แจแแฅแแแแก EPG-แแแแก แกแแฎแแ แแแแแ แฅแแแฅแกแแแแ, แแกแแแ แกแแแแแแ แแแแ แแกแแแแแแขแแชแแแ. แแกแ, แแแแงแแแแแแแ แฃแแแ แแชแแก.
EPG แแแแแกแแแแแ แแ แแก แฌแแแแแ แแแแแแฃแ แ แแแแกแขแ แฃแฅแชแแแแ, แ แแแแแแแช แแ แแ แแก แแแแแแจแแ แแแฃแแ แแแแแ แแขแฃแ แแแแแแ แแแแแแแแแ, แกแแ แแแ แแแแแ แแ แ.แจ., แแกแ แ แแ แแฅแแแ แจแแแแซแแแแ แแแแแแแแ แแกแแแ แ แแ แแ แแแแแ แแแคแฃแซแแแแฃแแ แแแแกแขแ แฃแฅแชแแแแ (แแแแแแแชแแแแ แแ แแแแฏแแ แแแแ), แ แแช แ แแฃแแแ แฉแแแฃแแแแ แแ แฅแกแแแแแจแ, แ แแแแ แแชแแ แแแแแแ แแแ. แจแแแแแแ, แแแฅแแแ, แซแแแแแ แแแแแแแ แกแแฌแแ แแแ แแแ แแแแก แแแแแแ แแแ, แ แแแ แแแแแฆแแ แกแแขแแกแขแ แแแ แแแ, แ แแแแแแช แแแ แแแขแแ แแแฃแแ แแฅแแแแ แฌแแ แแแแแแก แแแ แแแแก แแแแแขแฃแ แ. แแแแก แแแแแแแแ แจแแแแซแแแแ แฎแแแแ, แแแแ แแ แแก แฃแแแแแกแแ (แแ แฃแคแ แ แแแแแแแ) API-แแก แแแจแแแแแแ.
แแแแแแแ, ACI-แจแ แแแแขแ แแแแก แแแแแแ แกแแแ แแแ แแ แฐแแแแก แแแแก, แ แแกแแช แฉแแแฃแแแแ แแ แฎแแแแแแ
แแแแแ Cisco-แก แขแ แแแแชแแฃแ แฅแกแแแแแจแ: แแ แแแ แแแฃแแ แแแขแแ แคแแแกแ แแ แแก แแแ แแแแแแ, แฎแแแ GUI แแ CLI แแแแ แแแ, แ แแแแแ แแกแแแ แแฃแจแแแแแ แแแแแ API-แก แแแจแแแแแแ. แแแแขแแ, ACI-แจแ แฉแแ แแฃแแ แแแแฅแแแก แงแแแแ, แแแ แแแแฃแแ แแแ แแแแแก แจแแแแแ, แแฌแงแแแก แแแแแแแชแแแก แแแแแฅแขแแก แแแแแแแ, แ แแแแแแช แแแแแแงแแแแแ แแแ แแแแกแแแแก แแ แ แแฆแแชแแก แแแขแแแแขแแแแ แแแแก, แ แแช แจแแแกแแแแแแแ แแแ แกแแญแแ แแแแแแก. แแแแก แแแแแแแแแก แฃแแแ แขแแแแกแ แแแแ แแแแแแแแแ: แแแแกแแแแก แแ แแก แแแกแแฎแแ แฎแแแแแ แแแ แฎแแแกแแฌแงแแแแ.
แแแแแ แแแฃแแ แ แแแ
แแแแแแ แ แแ แแแแแแ แแก แแ แแก, แ แแ ACI-แจแ แแแแ แ แ แแ แแแแกแฎแแแแแแฃแแแ แแแแแแแ. แแแกแแแ แแแ แแแแฃแ แแ แแฃแจแแแแแก แแแกแแฌแงแแแแ, แกแแญแแ แแ แแแแแแแแแแแ. แแก แแแแกแแแฃแแ แแแแ แแฎแแแ แฅแกแแแแก แแแแ แแชแแแแแก แแฃแแแแแก แแกแฎแแแ แแแแฎแแแ แแแแแแจแ, แกแแแแช แแแแแแ แแแ แแแแฎแแแแแก แแแฎแแแแแ แฌแแแแแก แแแแแแแแแแแจแ โแแฌแแ แแ VLAN-แแแกโ. แแก แคแแฅแขแ, แ แแ แแฎแแ VLAN-แแแ แแฆแแ แแ แแก VLAN-แแแ แแ แแฅแแแ แแ แแญแแ แแแแแ แฎแแแแ แจแแฅแแแแ VLAN-แแแ แแแ แขแฃแแแแแแแฃแ แฐแแกแขแแแจแ แแฎแแแ แฅแกแแแแแแก แแแแกแแแแแกแแแแแ, แแแแแแแแ แแคแฃแญแแแก แกแแฎแฃแ แแแก แขแ แแแแชแแฃแ แฅแกแแแฃแ แแแก แแ แแแซแฃแแแแก แแแ แแแแฉแแแแ แแแชแแแ แแแแแแแแแก. แฃแแแ แแฆแแแแจแแแก, แ แแ Cisco-แ แกแชแแแ แแแแแแก แแแแแ แแแขแแแแแ แแ แแแแขแ แแแแ แก แแแแแแขแ โNXOS-แแก แแกแแแแกแโ CLI, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแแแ แแแแคแแแฃแ แแชแแ แขแ แแแแชแแฃแแ แแแแชแแแขแ แแขแแ แแแแก แแกแแแแกแ แแแขแแ แคแแแกแแแแ. แแแแ แแ แแแแแช, แแแแกแแแแแก, แ แแ แแแแฌแงแแ ACI แแแ แแแแฃแ แแ แแแแแงแแแแแ, แฃแแแ แแแกแแแแแ, แ แแแแ แแฃแจแแแแก แแแ.
แคแแกแแก แแแแแกแแแ แแกแแ, แแแแ แแ แกแแจแฃแแแ แแแกแจแขแแแแ, ACI แฅแกแแแแแ แคแแฅแขแแแ แแแแ แแ แแแแกแฎแแแแแแแ Cisco-แก แแฆแญแฃแ แแแแแแแก แขแ แแแแชแแฃแแ แฅแกแแแแแแกแแแ, แ แแแแแ แแแ แแกแแจแแแแแแแ แแแแแแงแแแแแ แแแแแ แแแแแแ แแแแแแแ (Nexus 9000-แก แจแแฃแซแแแ แแแฃแจแแแก ACI-แจแ แแ แขแ แแแแชแแฃแ แ แแแแแจแ แแ แแฎแแ แแแฎแแ แแแแแแ แ. โแกแแแฃแจแแ แชแฎแแแโ แแแแแชแแแแ แชแแแขแ แแก แแฎแแแ แแ แแแฅแขแแแแกแแแแก). แแแแ แแ แแ แ แแแแแแ แแแแแแก แแแแแชแแแแ แชแแแขแ แแแแกแแแแก, แแแแขแ แแแแ แแแแก แแ แกแแแแแ แแ Spine-Leaf แแ แฅแแขแแฅแขแฃแ แ, แ แ แแฅแแ แฃแแแ, แแแแก แแแ แซแแแแก. แชแแขแ แฎแแแก แฌแแ แแแแแฉแแแ Mini ACI แฅแแ แฎแแแ, แ แแแแแจแแช แกแแแ แแแแขแ แแแแ แแแแ แแ แ แจแแแชแแแแ แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแ. แแก แแแชแแ แแแก แแแแกแฎแแแแแแแก แฆแแ แแแฃแแแแแจแ, แแแแ แแ แแก แแแแแช แ แฉแแแ. แแกแ แ แแ, แแแแฎแแแ แแแแแกแแแแก แแ แฉแแแแแ แแแแแ แแแฎแแแแ แแแแ, แแฃ แ แแแแแแแ แแแแขแแ แแกแแแก แแแก แฃแกแแคแ แแฎแแแแแก แแแฎแแกแแแแแแแแแ, แแแ แขแฃแแแแแแชแแแกแแแ แแแขแแแ แแชแแ, แแแแขแ แแแแก แแ แแ แฌแแ แขแแแ แแ แ.แจ.
แฌแงแแ แ: www.habr.com