PIM แแ แแขแแแแแ แแ แแก แแ แแขแแแแแแแแก แแแแ แแแ แ แแฃแขแแ แแแก แจแแ แแก แฅแกแแแจแ แแฃแแขแแแแกแขแแก แแแแแชแแแแกแแแแก. แกแแแแแแแแ แฃแ แแแแ แแแแแแ แแแแแฃแแแ แแกแแแ, แ แแแแ แช แแแแแแแฃแ แ แแแ แจแ แฃแขแแแแชแแแก แแ แแขแแแแแแแแก แจแแแแฎแแแแแจแ. PIMv2 แแแแแแแแก Hello แจแแขแงแแแแแแแแแก แงแแแแ 30 แฌแแแจแ แแแฏแแแจแแแ แแฃแแขแแแแกแขแแก แแแกแแแแ แแแ 224.0.0.13 (All-PIM-Routers). แจแแขแงแแแแแแแ แจแแแชแแแก Hold Timers - แฉแแแฃแแแแ แแ แฃแแ แแก 3.5*Hello Timer-แก, แแแฃ แกแขแแแแแ แขแฃแแแ 105 แฌแแแก.
PIM แแงแแแแแก แแ แซแแ แแแแ แแแแ แแชแแฃแ แ แแแแแก - แแแแ แแแ แแ แแจแแแแแ แ แแแแแ. แแแแแฌแงแแ แแแแ แแแ แ แแแแแแ.
แฌแงแแ แแแ แแแคแฃแซแแแแฃแแ แแแแแฌแแแแแแก แฎแแแแ.
แแแแ แแแ แ แแแแแแก แ แแแแแ แแแแแแจแแฌแแแแแแ แแแแแแงแแแแ แกแฎแแแแแกแฎแแ แแฃแแขแแแแกแขแแก แฏแแฃแคแแก แแแแแแขแแแแก แแแแ แ แแแแแแแแแก แจแแแแฎแแแแแจแ. แ แแแแกแแช แ แแฃแขแแ แ แแฆแแแก แแฃแแขแแแแกแข แขแ แแคแแแก, แแแ แแแแ, แ แแกแแช แแแแแแแก, แแ แแก แแแกแ แจแแแแฌแแแแ RPF แฌแแกแแกแแแแก. RPF - แแก แฌแแกแ แแแแแแงแแแแแ แแฃแแขแแแแกแขแแก แฌแงแแ แแก แจแแกแแแแฌแแแแแแ unicast แแแ แจแ แฃแขแแแแชแแแก แชแฎแ แแแแ. แแฃแชแแแแแแแแ, แ แแ แขแ แแคแแแ แแแแแแแก แแแขแแ แคแแแกแจแ, แ แแแแแก แฃแแแแแช แแก แฐแแกแขแ แแแแแแแ unicast แแแ แจแ แฃแขแแแแชแแแก แชแฎแ แแแแก แแแ แกแแแก แแแฎแแแแแ. แแก แแแฅแแแแแแ แฌแงแแแขแก แชแแแแแก แแ แแแแแแแก, แ แแแแแแช แฌแแ แแแแฅแแแแแ แแฃแแขแแแแกแขแแก แแแแแชแแแแก แแ แแก.
R3 แแแแแชแแแแก multicast แฌแงแแ แแก (Source IP) แแฃแแขแแแแกแขแแก แแแแแแแแแแแ แแ แจแแแแแฌแแแแก แแ แแแแแแก R1-แแแ แแ R2-แแแ แแแกแ unicast แชแฎแ แแแแก แแแแแงแแแแแแ. แชแฎแ แแแแก แแแแ แแแแแแแแฃแแ แแแขแแ แคแแแกแแก แแแแแแ (R1-แแแ R3-แแแ) แแแแแแชแแแ แจแแแแแแ, แฎแแแ แแแแแแ R2-แแแ แฉแแแแแจแแแแ, แ แแแแแ แแฃแแขแแแแกแขแแก แฌแงแแ แแแแ แแแกแแกแแแแแแ, แแฅแแแ แฃแแแ แแแแแแแแแ แแแแแขแแแ S0/1-แแก แกแแจแฃแแแแแแ.
แกแแแแแฎแแแแ, แ แ แแแฎแแแแ, แแฃ แแฅแแแ แแแฅแแ แแ แ แแแแแแแแแแขแฃแ แ แแแ แจแ แฃแขแ แแ แแ แแ แแแแแ แแแขแ แแแแ? แแ แจแแแแฎแแแแแจแ, แ แแฃแขแแ แ แแ แแแ แจแ แฃแขแแแแแแ แจแแแ แฉแแแก แจแแแแแ แฐแแแก. แแแกแแช แแฅแแก แฃแคแ แ แแแฆแแแ IP แแแกแแแแ แแ, แแแแ แฏแแแแก. แแฃ แแ แฅแชแแแแก แจแแชแแแ แแญแแ แแแแแ, แจแแแแซแแแแ แแแแแแงแแแแ ECMP. แฒฃแคแ แ แแ แชแแแ
RPF แฌแแกแแก แจแแแแฌแแแแแก แจแแแแแ, แ แแฃแขแแ แ แแแแแแแแก แแฃแแขแแแแกแขแแก แแแแแขแก แงแแแแ PIM แแแแแแแแแแ, แแแ แแ แแแแกแ, แแแกแแแแแช แแก แแแแแขแ แแแแฆแ. แกแฎแแ PIM แแแ แจแ แฃแขแแแแขแแ แแแ แแแแแ แแแแ แแ แแ แแชแแกแก. แแแ, แ แแแแแแช Multicast แแแแแขแแ แแแแแ แ แฌแงแแ แแแแ แกแแแแแแ แแแแฆแแแแแแ, แฅแแแแก แฎแแก, แ แแแแแกแแช แแฌแแแแแ แฌแงแแ แแแ แแแคแฃแซแแแแฃแแ แแแแแฌแแแแแแก แฎแ, แฃแแแแแแกแ แแแแแแแก แฎแ (SPT), แฌแงแแ แแก แฎแ. แกแแแ แแแแกแฎแแแแแแฃแแ แกแแฎแแแ, แแแ แฉแแแ แ แแแแแแแ.
แ แแแแ แแแแแแแแ แแ แแ แแแแแแ, แ แแ แแแแแแ แแแ แแแ แจแ แฃแขแแแแขแแ แแ แแ แแฅแแ แฃแแ แ แแแแแแ แ แแฃแแขแแแแกแขแแก แแแแแแแ แแ แแ แแแแก แแฅแแก แแก, แ แแแแแแแช แแแก แแแฃแแแแแแแก, แแแแ แแ แแแแ แแแแแแแก แ แแฃแขแแ แ แฃแแแแแแแก แแแก. แแแแกแแแแก แแแแแแแแแแก Prune แแแฅแแแแแแ.
Prune แจแแขแงแแแแแแแ.
แแแแแแแแแ, R2 แแแแแ แซแแแแแก แแฃแแขแแแแกแขแแก แแแแแแแแแก R3-แแ, แแฃแแชแ R3, RPF แฌแแกแแก แแแฎแแแแแ, แฉแแแแแแแแแก แแแก. แ แแขแแ แแขแแแ แแแแ แแ แฎแ? R3 แแแแแแแแก PIM Prune แจแแขแงแแแแแแแแก แแ R2, แแ แจแแขแงแแแแแแแแก แแแฆแแแแกแแแแแแ, แแแแแฆแแแก แแแขแแ แคแแแกแก S0/1 แแ แแแแแแแก แแแแแแแแ แแแขแแ แคแแแกแแก แกแแแแแ, แแแขแแ แคแแแกแแแแก แกแแแแแ, แกแแแแแแแช แแก แขแ แแคแแแ แฃแแแ แแแแแแแแแแก.
แฅแแแแแ แแแชแแแฃแแแ PIM Prune แจแแขแงแแแแแแแแก แฃแคแ แ แแคแแชแแแแฃแ แ แแแแแแ แขแแแ:
PIM Prune แจแแขแงแแแแแแแ แแแแแแแแแ แแ แแ แ แแฃแขแแ แแก แแแแ แแแแ แ แ แแฃแขแแ แแ, แ แแแ แแแแ แ แ แแฃแขแแ แแ แฌแแจแแแแก แแแฃแแ, แ แแแแแแแช Prune แแแฆแแแฃแแแ แแแแแ แแขแฃแแ (S,G) SPT-แแแ.
Prune แจแแขแงแแแแแแแแก แแแฆแแแแก แจแแแแแ, R2 แแงแแแแแก Prune แขแแแแแ แก 3 แฌแฃแแแ. แกแแแ แฌแฃแแแก แจแแแแแ, แแก แแแแแ แแแแฌแงแแแก แขแ แแคแแแแก แแแแแแแแแก, แกแแแแ แแ แแแแฆแแแก แกแฎแแ Prune แจแแขแงแแแแแแแแก. แแก แแ แแก PIMv1-แจแ.
แแ PIMv2-แจแ แแแแแขแแแฃแแแ State Refresh แขแแแแแ แ (แแแแฃแแแกแฎแแแแแ 60 แฌแแแ). แ แแแแ แช แแ Prune แจแแขแงแแแแแแแ แแแแแแแแแแแ R3-แแแ, แแก แขแแแแแ แ แแฌแงแแแ R3-แแ. แแ แขแแแแแ แแก แแแแแก แแแกแแแแก แจแแแแแ, R3 แแแแแแแแแแแแแ State Refresh แจแแขแงแแแแแแแแก, แ แแแแแแช แแฆแแแแแแก 3-แฌแฃแแแแ Prune Timer-แก R2-แแ แแ แฏแแฃแคแแกแแแแก.
Prune แจแแขแงแแแแแแแแก แแแแแแแแแก แแแแแแแแ:
- แ แแแแกแแช Multicast แแแแแขแ แแแ แแฎแแ แฎแแแก RPF แจแแแแฌแแแแแก.
- แ แแแแกแแช แแ แแ แกแแแแแก แแแแแแฃแ แแ แแแแแแจแแ แแแฃแแ แแแแแแขแแแ, แ แแแแแแแแช แแแแแฎแแแแก แแฃแแขแcast แฏแแฃแคแ (IGMP Join) แแ แแ แแ แกแแแแแแ PIM แแแแแแแแแ, แ แแแแแแแแช แจแแแซแแแแ แแแแแแแแแแก แแฃแแขแแแแกแขแแก แขแ แแคแแแ (แแ แ-แแ แฃแแ แแแขแแ แคแแแกแ).
แแ แแคแขแแก แจแแขแงแแแแแแแ.
แฌแแ แแแแแแแแแแ, แ แแ R3-แก แแ แกแฃแ แแ แขแ แแคแแแ R2-แแแ, แแแแแแแแ Prune แแ แแแแฆแ multicast R1-แแแ. แแแแ แแ แแแฃแแแแแแแแ แแ แฎแ R1-R3-แก แจแแ แแก แแแแชแ แแ R3 แแแ แฉแ แแฃแแขแแแแกแขแแก แแแ แแจแ. แจแแแแซแแแแ แแแแแแแแ 3 แฌแฃแแ, แกแแแแ R2-แแ Prune Timer แแแแแฌแฃแ แแแ. 3 แฌแฃแแ แแแแ แแแแแแแ, แแกแ แ แแ แแ แแแแแแแแ, แฃแแแ แแแแแแแแแแแแ แจแแขแงแแแแแแแ, แ แแแแแแช แแงแแกแแแ แแ แแแแแแงแแแแก แแ S0/1 แแแขแแ แคแแแกแก R2-แแ แแแกแฎแแแแก แแแแแแแ แแแแแแแ. แแก แจแแขแงแแแแแแแ แแฅแแแแ Graft แจแแขแงแแแแแแแ. Graft แจแแขแงแแแแแแแแก แแแฆแแแแก แจแแแแแ, R2 แฃแแแกแฃแฎแแแก Graft-ACK-แแ.
Prune Override.
แแแแแ แจแแแฎแแแแ แแ แแแแแ แแแแก. R1 แแแ แชแแแแแก แแฃแแขแแแแกแขแก แกแแแแแแขแแ แแ แ แ แแฃแขแแ แแ. R3 แแฆแแแก แแ แแแ แชแแแแแก แขแ แแคแแแก, R2 แแฆแแแก, แแแแ แแ แแ แแแแก แฐแงแแแก แขแ แแคแแแแก แแแแแชแแแ. แแก แแแแแแแแก Prune แจแแขแงแแแแแแแแก R1-แก แแ แกแแแแแแขแจแ. R1-แแ แฃแแแ แแแแแฆแแก Fa0/0 แกแแแแแ แแ แจแแฌแงแแแขแแก แแแฃแฌแงแแแแแแ แแ แกแแแแแแขแจแ, แแแแ แแ แ แ แแแแ แแฌแแแ R3-แก? แแ R3 แแ แแก แแแแแ แกแแแแแแขแจแ, แแกแแแ แแแแฆแ แแก แจแแขแงแแแแแแแ แแ แฃแแแกแแแ แแ แแแฎแแแ แกแแขแฃแแชแแแก แขแ แแแแแแแก. แกแแแแ R1 แจแแฌแงแแแขแก แแแฃแฌแงแแแแแแแก, แแก แแแแแแก แขแแแแแ แก 3 แฌแแแแก แแแแแแแแแแแจแ แแ แจแแฌแงแแแขแก แแแฃแฌแงแแแแแแแก 3 แฌแแแแก แจแแแแแ. 3 แฌแแแ - แแก แแ แแก แแฃแกแขแแ แ แแแแแแ แแ แ แแฅแแก R3-แก, แ แแแ แแ แแแแแ แแแก แแแแแกแ แแฃแแขแแแแกแขแ. แแแแขแแ R3 แฃแแแแแแแก Pim Join แจแแขแงแแแแแแแแก แแ แฏแแฃแคแแกแแแแก แ แแช แจแแแซแแแแ แแแแ แแ R1 แแฆแแ แคแแฅแ แแแก แแแฃแฌแงแแแแแแแก แจแแฌแงแแแขแแแ. แฅแแแแแ แจแแขแงแแแแแแแแแแก แจแแกแแฎแแ.
แจแแขแงแแแแแแแแก แแแแแแแแ.
แฌแแ แแแแแแแแแแ แแก แกแแขแฃแแชแแ: แแ แ แ แแฃแขแแ แ แแ แแแ แแฃแแแ แแแแแแชแแแ แแ แ แฅแกแแแจแ. แแกแแแ แแฆแแแแ แแ แแกแ แแ แแแแแ แแแแแแก แฌแงแแ แแแแ แแ แแ แแแ แแแแแกแชแแแก แแแก แแแแแ แฅแกแแแจแ e0 แแแขแแ แคแแแกแแก แฃแแแ. แแแแขแแ แแแ แฃแแแ แแแแแแแแแ, แแแ แแฅแแแแ แแ แฅแกแแแแก แแ แแ แแ แแ แแแแแ แแ แแแฃแฌแงแแแแแ. แแแแกแแแแก แแแแแแงแแแแแ แแแแแแแกแขแฃแ แแแแแ แจแแขแงแแแแแแแแแ. แ แแแแกแแช R2 แแ R3 แแฆแแแแฉแแแแ แแฃแแขแแแแกแขแแก แขแ แแคแแแแก แแฃแแแแ แแแแก, แแแฃ R2 แแ R3 แแฆแแแแ แแฃแแขแแแแกแขแก, แ แแแแแกแแช แแแแแ แแแ แชแแแแแแ, แแแ แจแ แฃแขแแแแขแแ แแแ แแกแแแ, แ แแ แแฅ แ แแฆแแช แแ แแกแฌแแ แแ. แแ แจแแแแฎแแแแแจแ, แแแ แจแ แฃแขแแแแขแแ แแแ แแแแแแแแแ Assert แจแแขแงแแแแแแแแแก, แ แแแแแแแช แแแแชแแแก แแแแแแแกแขแ แแชแแฃแ แแแกแขแแแชแแแก แแ แแแ แจแ แฃแขแแก แแแขแ แแแแก, แ แแแแแแแช แแแแฆแฌแแแ แแฃแแขแแแแกแขแแก แฌแงแแ แ - 10.1.1.10. แแแแแ แฏแแแแฃแแ แแแแแแแแแแแแ แจแแแแแแแแแ แแ:
- แแ แแ แฅแแแแ AD.
- แแฃ AD แขแแแแ, แแแจแแ แแแก แแฅแแก แฅแแแแ แแแขแ แแแ.
- แแฃ แแฅ แแแแแกแฌแแ แแแแ, แแแจแแ แแแก, แแแกแแช แแฅแแก แฃแคแ แ แแแฆแแแ IP แฅแกแแแจแ, แ แแแแแแแแแช แแกแแแ แแแ แชแแแแแแ แแ แแฃแแขแแแแกแขแก.
แแ แฎแแแก แแแแแ แฏแแแแฃแแ แฎแแแแ แแแแแจแแฃแแ แ แแฃแขแแ แ. Pim Hello แแกแแแ แแแแแแงแแแแแ DR-แแแแก แจแแกแแ แฉแแแแ. แกแขแแขแแแก แแแกแแฌแงแแกแจแ แแแฉแแแแแแ แแงแ PIM Hello แแแแแแแแ, แแฅ แจแแแแซแแแแ แแแฎแแ DR แแแแ. แแ แแแฃแแแ แงแแแแแแ แแแฆแแแ IP แแแกแแแแ แแแก แแฅแแแ แแแแ แฏแแแแก.
แกแแกแแ แแแแแ แแแจแแแ:
MROUTE แแแแแแ.
PIM แแ แแขแแแแแแก แแฃแจแแแแแก แแแ แแแแแแ แจแแกแฌแแแแแก แจแแแแแ, แฉแแแ แฃแแแ แแแแแแแ, แ แแแแ แแแแฃแจแแแ multicast แแแ แจแ แฃแขแแแแชแแแก แแแแแแแกแแแ. mroute แชแฎแ แแแ แแแแฎแแแก แแแคแแ แแแชแแแก แแแแก แจแแกแแฎแแ, แแฃ แ แแแแแ แแแแแแแแ แแงแ แแแแฎแแแแแแ แแแแแแขแแแแกแแแ แแ แ แแแแแ แแแแแแแแ แแแแแแแแแ แแฃแแขแแแแกแขแแก แกแแ แแแ แแแแแแ.
แแแแแแแแแ, แ แแแแกแแช IGMP แฌแแแ แแแแก แแแแแ แแจแ แแ PIM Join แแแแฆแแแ แ แแแแแแแ แแแขแแ แคแแแกแแ, แขแแแแก แฉแแแแฌแแ แ ( *, G ) แแแแขแแแ แแแ แจแ แฃแขแแแแชแแแก แชแฎแ แแแจแ:
แแก แฉแแแแฌแแ แ แแแจแแแแก, แ แแ แแแฆแแแฃแ แแฅแแ แขแ แแคแแแแก แแแแฎแแแแ แแแกแแแแ แแแ 238.38.38.38. DC แแ แแจแ แแแจแแแแก, แ แแ multicast แแแฃแจแแแแแก Dense แ แแแแแจแ แแ C แแแจแแแแก, แ แแ แแแแฆแแแ แแแ แแแแแ แแ แแก แแแแแแจแแ แแแฃแแ แ แแฃแขแแ แแแ, แแแฃ แ แแฃแขแแ แแ แแแแฆแ IGMP Membership Report แแ PIM Join.
แแฃ แแ แแก แฉแแแแฌแแ แ แขแแแแก (S,G), แแก แแแจแแแแก, แ แแ แฉแแแ แแแแฅแแก แแฃแแขแแแแกแขแแก แแแแแแ:
S แแแแจแ - 192.168.1.11, แฉแแแ แแแแแ แแแแกแขแ แแ แแ multicast แฌแงแแ แแก IP แแแกแแแแ แแ, แกแฌแแ แแ แแก แจแแแแฌแแแแแ RPF แฌแแกแแ. แแ แแแแแแแแแก แแ แกแแแแแแก แจแแแแฎแแแแแจแ, แแแ แแแแ, แ แแช แฃแแแ แแแแแแแแ, แจแแแแแฌแแแ แฃแแแแแกแขแแก แชแฎแ แแแ แฌแงแแ แแแแ แแแ แจแ แฃแขแแกแแแแก. Incoming Interface แแแแจแ แแแฃแแแแแแก แแแขแแ แคแแแกแ, แ แแแแแแแช แแแแฆแแแ แแฃแแขแแแแกแขแ. แฃแแแแแกแขแแก แแแ แจแ แฃแขแแแแชแแแก แชแฎแ แแแจแ, แแแ แจแ แฃแขแ แฌแงแแ แแแแ แฃแแแ แแฎแแแแแแก แแฅ แแแแแแแแฃแ แแแขแแ แคแแแกแก. แแแแแแแแ แแแขแแ แคแแแกแ แแแฃแกแขแแแก แกแแ แแแแแแแกแแแแ แแแแแ แแฃแแขแแแแกแขแ. แแฃ แแก แชแแ แแแแแ, แแแจแแ แ แแฃแขแแ แก แแ แแแฃแฆแแ แ แแแแ แแแแฎแแแแ แแ แขแ แแคแแแแกแแแแก. แแแแแขแแแแแ แแแคแแ แแแชแแ แงแแแแ แแ แแจแแก แจแแกแแฎแแ แจแแแแซแแแแ แแฎแแแแ
PIM แแจแแแแแ แ แแแแแ.
Sparse-mode-แแก แกแขแ แแขแแแแ แแแแ แแแ แ แแแแแแก แกแแแแ แแกแแแ แแ. แ แแแแกแแช Sparse-mode แแฆแแแก แแฃแแขแแแแกแข แขแ แแคแแแก, แแก แแแแแแแแแก แขแ แแคแแแก แแฎแแแแ แแ แแแขแแ แคแแแกแแแแ, แกแแแแช แแงแ แแแแฎแแแแแแ แแ แแแแแแแกแแแแก, แแแแแแแแแ Pim Join แแ IGMP Report แจแแขแงแแแแแแแแแ, แ แแแแแแแช แแแฎแแแแ แแ แขแ แแคแแแก.
แแกแแแแกแ แแแแแแแขแแแ SM แแ DM-แกแแแแก:
- แกแแแแแแแแ แฃแ แแแแ แแแแแแ แแแแแฃแแแ แแกแแแ, แ แแแแ แช PIM DM-แจแ.
- RPF แฌแแกแ แแฃแจแแแแก.
- DR แแ แฉแแแแแ แแกแแแแกแแ.
- Prune Overrides แแ Assert แจแแขแงแแแแแแแแแแก แแแฅแแแแแแ แแกแแแแกแแ.
แแแแก แแแกแแแแแขแ แแแแแแแ, แแฃ แแแ, แกแแ แแ แ แ แกแแฎแแก แแฃแแขแcast แขแ แแคแแแแ แกแแญแแ แ แฅแกแแแจแ, แกแแญแแ แแ แกแแแ แแ แกแแแแคแแ แแแชแแ แชแแแขแ แ. แฉแแแแ แชแแแขแ แ แแฅแแแแ Rendezvous Point (RP). แแแกแแช แกแฃแ แก แ แแแแ แกแแฎแแก แแฃแแขแแแแกแขแแก แขแ แแคแแแ แแ แแแแแแ แแแแฌแงแ แแฃแแขแแแแกแขแแก แขแ แแคแแแแก แแแฆแแแ แฌแงแแ แแแแ, แจแแแแแ แแก แแแแแแแแก แแแก RP-แแ.
แ แแแแกแแช RP แแแแฆแแแก แแฃแแขแcast แขแ แแคแแแก, แแก แแแฃแแแแแแแก แแแก แแ แแแ แจแ แฃแขแแแแขแแ แแแก, แ แแแแแแแแช แแแ แ แแแแแฎแแแแก แแก แขแ แแคแแแ.
แฌแแ แแแแแแแแแแ แขแแแแแแแแ, แกแแแแช RP แแ แแก R3. แ แแแแ แช แแ R1 แแแแฆแแแก แขแ แแคแแแก S1-แแแ, แแก แแแแแกแแแก แแ แแ แแแแแแแแก แแแแแขแก unicast PIM Register แจแแขแงแแแแแแแแจแ แแ แแแแแแแแก แแแก RP-แแ. แกแแแแแ แแชแแก, แแแ แแ แแก RP? แแ แจแแแแฎแแแแแจแ, แแก แแแแคแแแฃแ แแ แแแฃแแแ แกแขแแขแแแฃแ แแ, แฎแแแ แแแแแแแฃแ แ RP แแแแคแแแฃแ แแชแแแก แจแแกแแฎแแ แแแแแแแแแแแ แแแกแแฃแแ แแแ.
ip pim rp-แแแกแแแแ แแ 3.3.3.3
RP แแแแแแงแฃแ แแแ - แแงแ แแแคแแ แแแชแแ แแแแแแกแแแ, แแแกแแช แกแฃแ แก แแ แขแ แแคแแแแก แแแฆแแแ? แแแแฃแจแแแ, แ แแ แแก แแ แแงแ. แจแแแแแ RP แแแฃแแแแแแแก R1-แก PIM Register-Stop แจแแขแงแแแแแแแแก, แ แแช แแแจแแแแก, แ แแ แแ แแแแก แกแญแแ แแแแ แแก multicast, แ แแแแกแขแ แแชแแ แฃแแ แงแแคแแแแ. R1 แแ แแแแแแแแแก แแฃแแขแแแแกแขแก. แแแแ แแ Multicast แฌแงแแ แแก แฐแแกแขแ แแแแแแแแแแแแก แแแก, แแกแ แ แแ R1, Register-Stop-แแก แแแฆแแแแก แจแแแแแ, แแแแฌแงแแแก Register-Suppression แขแแแแแ แแก แขแแแคแแกแ 60 แฌแแแ. แแ แขแแแแแ แแก แแแแแก แแแแฌแฃแ แแแแแ 5 แฌแแแแ แแแ แ, R1 แแแแแแแแแแแแแ แชแแ แแแ แ แแแแกแขแ แแชแแแก แจแแขแงแแแแแแแแก Null-Register แแแขแแ (แแแฃ, แแแแแคแกแฃแแแ แแแฃแแ แแฃแแขแcast แแแแแขแแก แแแ แแจแ) RP-แกแแแ. RP, แแแแแก แแฎแ แแ, แแแแฅแแแแแแก แแกแ:
- แแฃ แแ แแงแ แแแแฆแแแ, แแแจแแ แแก แฃแแแกแฃแฎแแแก แ แแแแกแขแ แแชแแ-แกแขแแ แจแแขแงแแแแแแแแ.
- แแฃ แแแแฆแแแแแ แแแแแฉแแแแแแแ, แแก แแ แแแแแ แแ แแ แฃแแแกแฃแฎแแแก แแแก. R1, แ แแแแแแแช แแ แแแแฆแ แฃแแ แ แ แแแแกแขแ แแชแแแแ 5 แฌแแแแก แแแแแแแแแแแจแ, แแแฎแแ แฃแแ แแฅแแแแ แแ RP-แก แแแฃแแแแแแแก แจแแขแงแแแแแแแแก แ แแแแกแขแ แแชแแแแ แฉแแกแแฃแแ แแฃแแขแแแแกแขแฃแ แแ.
แฉแแแ, แ แแแแ แช แฉแแแก, แแแแแ แแแแแ, แแฃ แ แแแแ แแฆแฌแแแก multicast RP-แก, แแฎแแ แจแแแแชแแแแ แแฃแแแกแฃแฎแแ แแแแฎแแแก, แแฃ แ แแแแ แแฌแแแแก RP แขแ แแคแแแก แแแแฆแแแแแก. แแฅ แแฃแชแแแแแแแแ แแฎแแแ แแแแชแแคแชแแแก - root-path tree (RPT) แจแแแแฆแแแ. RPT แแ แแก RP-แจแ แแแคแฃแซแแแแฃแแ แฎแ, แ แแแแแแช แแแ แแแแ แแแแฆแแแแแแกแแแ แแ แแแแจแขแแแแฃแแแ แแแแแแฃแ PIM-SM แ แแฃแขแแ แแ. RP แฅแแแแก แแแก PIM Join แจแแขแงแแแแแแแแแแก แแแฆแแแแ แแ แแแแขแแแก แแฎแแ แขแแขแก แฎแแก. แแกแ แ แแ, แงแแแแ แฅแแแแ แแแแแแแก แ แแฃแขแแ แ แแแแแแแก. แแแแแแ แฌแแกแ แแกแ แแแแแแงแฃแ แแแ:
- แ แแแแกแแช PIM-SM แ แแฃแขแแ แ แแฆแแแก PIM Join แจแแขแงแแแแแแแแก แแแแแกแแแแ แแแขแแ แคแแแกแแ, แแแ แแ แแ แแแขแแ แคแแแกแแกแ, แ แแแแแก แแแฆแแแช แแแแแแแ RP, แแก แแแแขแแแก แแฎแแ แขแแขแก แฎแแก.
- แคแแแแแแ แแกแแแ แแแแขแแแ, แ แแแแกแแช PIM-SM แ แแฃแขแแ แ แแแแฆแแแก IGMP แฌแแแ แแแแก แแแแแ แแจแก แแแ แแแแแ แแแแแแจแแ แแแฃแแ แฐแแกแขแแแแ.
แฌแแ แแแแแแแแแแ, แ แแ แฉแแแ แแแงแแแก Multicast แแแแแแขแ R5 แ แแฃแขแแ แแ 228.8.8.8 แฏแแฃแคแแกแแแแก. แ แแแแ แช แแ R5 แแแแฆแแแก IGMP แฌแแแ แแแแก แแแแแ แแจแก แฐแแกแขแแกแแแ, R5 แแแแแแแแก PIM Join-แก RP-แแก แแแแแ แแฃแแแแแ แแ แแแแแ แแแแขแแแก แแแขแแ แคแแแกแก แฎแแก, แ แแแแแแช แฃแงแฃแ แแแก แแแกแแแแซแแแก. แจแแแแแแ, R4 แแฆแแแก PIM Join-แก R5-แแแ, แแแแขแแแก แแแขแแ แคแแแกแก Gi0/1 แฎแแก แแ แแแแแแแแก PIM Join-แก RP-แแก แแแแแ แแฃแแแแแ. แกแแแแแแแ, RP (R3) แแฆแแแก PIM Join-แก แแ แแแแขแแแก Gi0/0 แฎแแก. แแแ แแแแ, แแฃแแขแแแแกแขแแก แแแแฆแแแ แ แแแแกแขแ แแ แแแฃแแแ. แแแจแแแแแ แฎแแก R3-Gi0/0 โ R4-Gi0/1 โ R5-Gi0/0 แคแแกแแแ.
แแแแก แจแแแแแ, PIM Join แแแแแแแแแแแ R1-แแ แแ R1 แแแแฌแงแแแก แแฃแแขแแแแกแขแแก แขแ แแคแแแแก แแแแแแแแแก. แแแแจแแแแแแแแแแ แแฆแแแแจแแแก, แ แแ แแฃ แแแกแแแแซแแแแ แแแแแฎแแแ แขแ แแคแแแ แแฃแแขแแแแกแขแแก แแแฃแฌแงแแแแแแแก แแแฌแงแแแแแแ, แแแจแแ RP แแ แแแฃแแแแแแแก PIM Join-แก แแ แกแแแ แแแ แแ แแแฃแแแแแแแก แแ แแคแแ แก R1-แแ.
แแฃ แแแฃแแแแแแแแ แแฃแแขแแแแกแขแแก แแแแแแแแแกแแก, แฐแแกแขแก แจแแฌแงแแแขแก แแแกแ แแแฆแแแแก แกแฃแ แแแแ, แ แแแแ แช แแ RP แแแแฆแแแก PIM Prune-แก Gi0/0 แแแขแแ แคแแแกแแ, แแก แแแฃแงแแแแแแแแ แแแแแแแแแก PIM Register-Stop-แก แแแ แแแแแ R1-แแ, แจแแแแแ แแ PIM Prune-แก. แจแแขแงแแแแแแแ Gi0/1 แแแขแแ แคแแแกแแก แกแแจแฃแแแแแแ. PIM Register-stop แแแแแแแแแ unicast-แแก แกแแจแฃแแแแแแ แแ แแแกแแแแ แแแ, แกแแแแแแแช แแแแแแ PIM แ แแแแกแขแ แแชแแ.
แ แแแแ แช แแแ แ แแแฅแแแ, แ แแแแ แช แแ แ แแฃแขแแ แ แแแแแแแแก PIM Join-แก แกแฎแแแก, แแแแแแแแแ R5-แก R4-แจแ, แแแจแแ แฉแแแแฌแแ แ แแแแขแแแ R4-แก:
แแ แแแฌแงแแแฃแแแ แขแแแแแ แ, แ แแ R5 แแฃแแแแแแ แฃแแแ แแฆแแแแแแแก แแก แขแแแแแ แ PIM แจแแฃแแ แแแแก แจแแขแงแแแแแแแแแก แแฃแแแแแแ, แฌแแแแแฆแแแแ แจแแแแฎแแแแแจแ R4 แแแแแแ แแชแฎแแแ แแแแแแแแ แกแแแแแ. R5 แแแแแแแแแแแแแ แงแแแแ 60 PIM Join แจแแขแงแแแแแแแแก.
แฃแแแแแแกแ แแแแแแแก แฎแแก แแแแแ แแแ.
แฉแแแ แแแแแแแขแแแ แแแขแแ แคแแแกแก R1-แกแ แแ R5-แก แจแแ แแก แแ แแแแฎแแ, แ แแแแ แแแแแแแแแ แขแ แแคแแแ แแ แขแแแแแแแแแ.
แแแแฃแจแแแ, แ แแ แขแ แแคแแแ แแแแแแแแแแ แแ แแแฆแแแฃแแ แแงแ แซแแแแ แกแฅแแแแก แแแฎแแแแแ R1-R2-R3-R4-R5 แแ แแฅ แฉแแแ แแแแแแแแจแแ แแ แแ แแแแแแแแคแแแฃแ แแ แแ แแแขแแ แคแแแกแ R1-แกแ แแ R5-แก แจแแ แแก.
แฃแแแ แแแแแก แงแแแแแกแ, แฉแแแ แฃแแแ แแฆแแแแแแแแ unicast แแแ แจแ แฃแขแแแแชแแแก แชแฎแ แแแ R5-แแ แแ แแฎแแ แฅแกแแแจแ 192.168.1.0/24 แแแแฆแฌแแแ R5 Gi0/2 แแแขแแ แคแแแกแแก แแแจแแแแแแ. แแฎแแ R5, แ แแแแแแช แแฆแแแก Multicast แแแขแแ แคแแแกแแ Gi0/1, แแกแแแก, แ แแ RPF แฌแแกแ แแ แแ แแก แแแแแแงแแคแแแแแฃแแ แแ แฃแคแ แ แแแแแแฃแ แ แแฅแแแแ Gi0/2-แแ แแฃแแขแแแแกแขแแก แแแฆแแแ. แแแ แฃแแแ แแแแแจแแก RPT-แแแ แแ แจแแฅแแแแก แฃแคแ แ แแแแแ แฎแ, แกแแฎแแแฌแแแแแแ แฃแแแแแแกแ แแแแแแแก แฎแ (SPT). แแแแกแแแแแก แแก แแแแแแแแก PIM Join-แก R0-แแ Gi2/1-แแก แแแจแแแแแแ แแ R1 แแฌแงแแแก แแฃแแขแแแแกแขแแก แแแแแแแแแก แแกแแแ Gi0/2-แแก แแแจแแแแแแ. แแฎแแ R5 แฃแแแ แแแแฃแฅแแแก RPT-แแก แแแแแฌแแ แ, แ แแแ แแ แแแแฆแแก แแ แ แแกแแ. แแแแกแแแแแก แแก Prune-แก แฃแแแแแแแก แจแแขแงแแแแแแแแก, แ แแแแแจแแช แแแแแแแแฃแแแ แฌแงแแ แแก IP แแแกแแแแ แแ แแ แฉแแกแแฃแแแ แกแแแชแแแแฃแ แ แแแขแ - RPT-bit. แแก แแแจแแแแก, แ แแ แแฅแแแ แแ แแญแแ แแแแแ แขแ แแคแแแแก แแแแแแแแ, แแ แแฅ แฃแแแแแกแ แฎแ แแแฅแแก. RP แแกแแแ แแแแแแแแก PIM Prune แจแแขแงแแแแแแแแแก R1-แแ, แแแแ แแ แแ แแแแแแแแก แจแแขแงแแแแแแแแก Register-Stop. แแแแแ แแ แแ แคแฃแแฅแชแแ: R5 แแฎแแ แแฃแแแแแแ แแแแแแแแก PIM Prune-แก RP-แแ, แ แแแแแ R1 แแแ แซแแแแแก PIM Register-แแก แแแแแแแแแก RP-แแ แงแแแแ แฌแฃแแก. แกแแแแ แแ แแฅแแแแ แแฎแแแ แฎแแแฎแ, แแแกแแช แแก แขแ แแคแแแ แกแฃแ แก, RP แฃแแ แก แแขแงแแแก แแแกแแ. R5 แแชแแแแแแก RP-แก, แ แแ แแก แแแ แซแแแแแก แแฃแแขแแแแกแขแแก แแแฆแแแแก SPT-แแก แกแแจแฃแแแแแแ.
แแแแแแแฃแ แ RP แซแแแแ.
แแแขแ-RP.
แแก แขแแฅแแแแแแแ แแ แแก Cisco-แก แกแแแฃแแ แแแ แแ แแ แแ แแก แแแแกแแแฃแแ แแแแ แแแแฃแแแ แฃแแ, แแแแ แแ แฏแแ แแแแแ แชแแชแฎแแแแ. Auto-RP แแแแ แแชแแ แจแแแแแแ แแ แ แซแแ แแแแแ แแขแแแแกแแแ:
1) RP แแแแแแแแก RP-Announce แจแแขแงแแแแแแแแแก แแแฏแแแจแแแ แแแกแแแแ แแแ - 224.0.1.39, แแชแฎแแแแแก แแแแก RP แแ แงแแแแแกแแแแก แแ แแแแแ แแขแฃแแ แฏแแฃแคแแกแแแแก. แแก แจแแขแงแแแแแแแ แงแแแแ แฌแฃแแก แแแแแแแแแ.
2) แกแแญแแ แแ RP แ แฃแแแแแก แแแแแขแ, แ แแแแแแช แแแแแแแแแแแแแ RP-Discovery แจแแขแงแแแแแแแแแก, แกแแแแช แแแแแแแแฃแแแ, แแฃ แ แแแแแ แฏแแฃแคแแแแกแแแแก แฃแแแ แแแแกแแแแแก RP. แกแฌแแ แแ แแ แแแแแแแแแแแแแ, แ แแ แฉแแแฃแแแแ แแแ PIM แแแ แจแ แฃแขแแแแขแแ แแแ แแแแแ แแแแกแแแฆแแ แแแแ RP-แก. Mapping Agent แจแแแซแแแแ แแงแแก แแ แแแแแ RP แ แแฃแขแแ แ แแ แชแแแแ PIM แ แแฃแขแแ แ. RP-Discovery แแแแแแแแแ 224.0.1.40 แแแกแแแแ แแแ แแ แแ แฌแฃแแแก แขแแแแแ แแ.
แแแแแ แจแแแฎแแแแ แแ แแชแแกแก แฃแคแ แ แแแขแแแฃแ แแ:
แแแแแ แแแแแแแแคแแแฃแ แแ แแ R3 แ แแแแ แช RP:
ip pim แแแแแแแแ-rp-แแชแฎแแแแแก loopback 0 แกแคแแ แ 10
R2, แ แแแแ แช แ แฃแแแแแก แแแแแขแ:
ip pim send-rp-discovery loopback 0 แกแคแแ แ 10
แแ แงแแแแ แแแแแ แฉแแแแ แฉแแแ แแแแแ RP-แก Auto-RP-แแก แแแจแแแแแแ:
ip pim autorp แแกแแแแแแ
R3-แแก แแแแคแแแฃแ แแชแแแก แจแแแแแ, แแก แแแแฌแงแแแก RP-Announce-แแก แแแแแแแแแก:
แแ R2, แ แฃแแแแแก แแแแแขแแก แแแงแแแแแแก แจแแแแแ, แแแแฌแงแแแก RP-Announce แจแแขแงแแแแแแแแก แแแแแแแแก. แแฎแแแแ แแแจแแ, แ แแแแกแแช แแก แแฆแแแแฉแแแก แแแแแแฃแ แแ แ RP-แก, แแก แแแแฌแงแแแก RP-Discovery-แแก แแแแแแแแแก:
แแ แแแแ, แ แแแแ แช แแ แฉแแแฃแแแแ แแแ แแแ แจแ แฃแขแแแแขแแ แแแ (PIM RP แแกแแแแแแ) แแแแฆแแแแ แแ แจแแขแงแแแแแแแแก, แแแ แแชแแแแแแแแ, แกแแ แแแแซแแแ RP.
Auto-RP-แแก แแ แ-แแ แแ แแแแแแ แ แแ แแแแแแ แแก แแ แแก, แ แแ RP-Announce แแ RP-Discovery แจแแขแงแแแแแแแแแแก แแแกแแฆแแแแ, แแฅแแแ แฃแแแ แแแแแแแแแ PIM Join แแแกแแแแ แแแแแ 224.0.1.39-40, แฎแแแ แแแกแแแแแแแแ, แแฅแแแ แฃแแแ แแชแแแแ แกแแ แแ แแก RP แแแแแแ แแแแก. แแแแกแแแฃแ แ แฅแแแแแก แแ แแแแ แชแฎแแก แแ แแแแแแ. แแ แแ แแแแแแแก แแแแแกแแญแ แแแแ แแแแแแแแแแก PIM Sparse-Dense-Mode. แแฃ แ แแฃแขแแ แแ แแ แแชแแก RP, แแแจแแ แแก แแฃแจแแแแก Dense-แ แแแแแจแ, แแฃ แแชแแก, แแแจแแ Sparse-แ แแแแแจแ. แ แแแแกแแช PIM Sparse-mode แแ ip pim autorp listener แแ แซแแแแแ แแแแคแแแฃแ แแ แแแฃแแแ แฉแแแฃแแแแ แแแ แแแ แจแ แฃแขแแแแขแแ แแแแก แแแขแแ แคแแแกแแแแ, แ แแฃแขแแ แ แแแฃแจแแแแแก แแแแ แแ แ แแแแแจแ แแฎแแแแ แแฃแแขแแแแกแขแแแแแกแแแแก แแแ แแแแแ Auto-RP แแ แแขแแแแแแแแ (224.0.1.39-40).
BootStrap แ แแฃแขแแ แ (BSR).
แแก แคแฃแแฅแชแแ แแฃแจแแแแก Auto-RP-แแก แแกแแแแกแแ. แแแแแแฃแแ RP แฃแแแแแแแก แจแแขแงแแแแแแแแก แ แฃแแแแแก แแแแแขแก, แ แแแแแแช แแแ แแแแแก แ แฃแแแแแก แจแแกแแฎแแ แแแคแแ แแแชแแแก แแ แจแแแแแ แแฃแแแแแ แงแแแแ แกแฎแแ แแแ แจแ แฃแขแแแแขแแ แก. แแแแแ แแฆแแฌแแ แแ แแ แแชแแกแ Auto-RP-แแก แแกแแแแกแแ:
1) แแแก แจแแแแแ แ แแช R3-แแก แแแแคแแแฃแ แแชแแแก แแแแแแแแ, แ แแแแ แช แแแแแแแแขแแ RP, แแ แซแแแแแแ:
ip pim rp-candidate loopback 0
แแแจแแ R3 แแ แแคแแ แก แแแแแแแแแก; แแแแกแแแแแก, แ แแ แแแแฌแงแแก แกแแแชแแแแฃแ แ แจแแขแงแแแแแแแแแแก แแแแแแแแ, แแแ แฏแแ แฃแแแ แแแซแแแแแก แ แฃแแแแแก แแแแแขแ. แแแ แแแแ, แฉแแแ แแแแแแแแแแ แ แแแแ แ แกแแคแแฎแฃแ แแ.
2) แแแแแแแคแแแฃแ แแ แแ R2, แ แแแแ แช แ แฃแแแแแก แแแแแขแ:
ip pim bsr-candidate loopback 0
R2 แแฌแงแแแก PIM Bootstrap แจแแขแงแแแแแแแแแแก แแแแแแแแแก, แกแแแแช แแก แแแฃแแแแแแก แแแแก แ แฃแแแแแก แแแแแขแแ:
แแก แจแแขแงแแแแแแแ แแแแแแแแแ แแแกแแแแ แแแ 224.0.013, แ แแแแแกแแช PIM แแ แแขแแแแแ แแกแแแ แแงแแแแแก แกแฎแแ แจแแขแงแแแแแแแแแแกแแแแก. แแก แแแแแแแแก แแแ แงแแแแ แแแแแ แแฃแแแแแ แแ, แจแแกแแแแแแกแแ, แแ แแ แแก แฅแแแแแกแ แแ แแแแ แชแฎแแก แแ แแแแแแ, แ แแแแ แช แแก แแงแ Auto-RP-แจแ.
3) แ แแแแ แช แแ RP แแแแฆแแแก แจแแขแงแแแแแแแแก BSR แ แแฃแขแแ แแแแ, แแก แแแฃแงแแแแแแแแ แแแฃแแแแแแแก unicast แจแแขแงแแแแแแแแก BSR แ แแฃแขแแ แแก แแแกแแแแ แแแ:
แ แแก แจแแแแแแแช, BSR, แ แแแแแแแช แแแแฆแ แแแคแแ แแแชแแ RP-แแแแก แจแแกแแฎแแ, แแแแแแแแแแก แแแ แแฃแแขแแแแกแขแแก แกแแจแฃแแแแแแ 224.0.0.13 แแแกแแแแ แแแ, แ แแแแแกแแช แฃแกแแแแก แงแแแแ PIM แแแ แจแ แฃแขแแแแขแแ แ. แแแแขแแ, แแ แซแแแแแแก แแแแแแแ ip pim autorp แแกแแแแแแ แฉแแแฃแแแแ แแแ แแแ แจแ แฃแขแแแแขแแ แแแแกแแแแก, แ แแแแแแแช แแ แแ แแแ BSR-แจแ.
Anycast RP Multicast Source Discovery Protocol-แแ (MSDP).
Auto-RP แแ BSR แกแแจแฃแแแแแแก แแแแซแแแแก แแแแแแแฌแแแแ แแแขแแแ แแแ RP-แแ แจแแแแแแแแแ แแ: แแแแแแฃแ แแฃแแขแแแแกแข แฏแแฃแคแก แแฅแแก แแฎแแแแ แแ แแ แแฅแขแแฃแ แ RP. แจแแฃแซแแแแแแ แแฅแแแแ แแแขแแแ แแแแก แแแแแฌแแแแแ แแ แแ แแฃแแขแcast แฏแแฃแคแแกแแแแก แ แแแแแแแแ RP-แแ. MSDP แแแแก แแแแแแแก RP แแแ แจแ แฃแขแแแแขแแ แแแแก แแแชแแแแ แแแแแ IP แแแกแแแแ แแแ 255.255.255.255 แแแฆแแแ. MSDP แกแฌแแแแแแก แแแคแแ แแแชแแแก แแ แ-แแ แแ แแแแแแแก แแแแแงแแแแแแ: แกแขแแขแแแฃแ แ, Auto-RP แแ BSR.
แกแฃแ แแแแ แแแแฅแแก Auto-RP แแแแคแแแฃแ แแชแแ MSDP-แแ. แแ แแแ RP แแแแคแแแฃแ แแ แแแฃแแแ IP แแแกแแแแ แแแ 172.16.1.1/32 Loopback 1 แแแขแแ แคแแแกแแ แแ แแแแแแงแแแแแ แงแแแแ แฏแแฃแคแแกแแแแก. RP-Announce-แแ แแ แแแ แแแ แจแ แฃแขแแแแขแแ แ แแชแฎแแแแแก แแแแก แแ แแแกแแแแ แแแก แแแแแแแแแ. Auto-RP แ แฃแแแแแก แแแแแขแ, แแแคแแ แแแชแแแก แแแฆแแแแก แจแแแแแ, แแแแแแแแก RP-Discovery-แก RP-แแก แจแแกแแฎแแ แแแกแแแแ แแแ 172.16.1.1/32. แฉแแแ แแแฃแแแแแแ แแแ แจแ แฃแขแแแแขแแ แแแก แฅแกแแแแก แจแแกแแฎแแ 172.16.1.1/32 IGP-แแก แแแแแงแแแแแแ แแ แจแแกแแแแแแกแแ. แแแ แแแแ, PIM แแแ แจแ แฃแขแแแแขแแ แแแ แแแฎแแแแ แแ แแ แแแแกแขแ แแ แแแแ แแแแแแแแก RP-แแแ, แ แแแแแแช แแแแแแแแฃแแแ, แ แแแแ แช แจแแแแแแ แฐแแ แแแ แจแ แฃแขแแ 172.16.1.1/32 แฅแกแแแจแ. แแแแแ MSDP แแ แแขแแแแแ แจแแฅแแแแแแ แแแแกแแแแก, แ แแ แแแแแ RP-แแแแ แแแชแแแแแ แจแแขแงแแแแแแแแแ แแฃแแขแแแแกแขแแก แแแคแแ แแแชแแแก แจแแกแแฎแแ.
แแแแแแฎแแแแ แแก แขแแแแแแแแ:
Switch6 แแแ แชแแแแแก แขแ แแคแแแก 238.38.38.38 แแแกแแแแ แแแ แแ แฏแแ แฏแแ แแแแ แแฎแแแแ RP-R1-แแ แแชแแก แแแแก แจแแกแแฎแแ. Switch7-แแ แแ Switch8-แแ แแแแแฎแแแแก แแก แฏแแฃแคแ. แแแ แจแ แฃแขแแแแขแแ แแแ R5 แแ R4 แแแฃแแแแแแแแ PIM Join-แก R1 แแ R3-แแ, แจแแกแแแแแแกแแ. แ แแขแแ? แแแ แจแ แฃแขแ 13.13.13.13-แแแ R5-แแกแแแแก แแแแแ แแแแก R1-แก IGP แแแขแ แแแแก แแแแแงแแแแแแ, แแกแแแ แ แแแแ แช R4-แแกแแแแก.
RP-R1-แแ แแชแแก แแแแแแแก แจแแกแแฎแแ แแ แแแแฌแงแแแก แแแก แแแฃแฌแงแแแแแแแก R5-แแก แแแแแ แแฃแแแแแ, แแแแ แแ R4-แแ แแ แแคแแ แ แแชแแก แแแแก แจแแกแแฎแแ, แ แแแแแ R1 แฃแแ แแแแ แแ แแแแแแแแแก แแแก. แแแแขแแ MSDP แแฃแชแแแแแแแแ. แฉแแแ แแแแแแคแแแฃแ แแ แแแ R1 แแ R5-แแ:
ip msdp peer 3.3.3.3 connect-source Loopback1 R1-แแ
ip msdp peer 1.1.1.1 connect-source Loopback3 R3-แแ
แแกแแแ แแแแแ แแแแแ แกแแกแแแก แแ แแแแแแแก แจแแ แแก แแ แ แแแแกแแช แแแแฆแแแแ แ แแแแ แแแแแแก, แแกแแแ แจแแแขแงแแแแแแแแ แแแแก แแแแแแแ RP แแแแแแแแก.
แ แแแแ แช แแ RP-R1 แแแแฆแแแก แกแขแ แแแแแแก Switch6-แแแ, แแก แแแฃแงแแแแแแแแ แแแแแแแแแก unicast MSDP Source-Active แจแแขแงแแแแแแแแก, แ แแแแแแช แจแแแชแแแก แแแคแแ แแแชแแแก, แ แแแแ แแชแแ (S, G) - แแแคแแ แแแชแแ แแฃแแขแแแแกแขแแก แฌแงแแ แแกแ แแ แแแแแจแแฃแแแแแก แจแแกแแฎแแ. แแฎแแ, แ แแแแกแแช RP-R3-แแ แแชแแก, แ แแ แฌแงแแ แ, แ แแแแ แแชแแ Switch6, R4-แแกแแแ แแ แแแแแแแก แแแแฎแแแแแก แแแฆแแแแกแแก, แแก แแแแแแแแแก PIM Join-แก Switch6-แแกแแแ, แแแ แจแ แฃแขแแแแชแแแก แชแฎแ แแแแก แฎแแแแซแฆแแแแแแแแแ. แจแแกแแแแแแกแแ, R1-แแ, แ แแแแแแแช แแแแฆแ แแกแแแ PIM Join, แแแแฌแงแแแก แขแ แแคแแแแก แแแแแแแแแก RP-R3-แแกแแแ.
MSDP แแแแแก TCP-แแ, RP-แแแ แฃแแแแแแแแ แแ แแแแแแแก แจแแแแฎแฃแ แจแแขแงแแแแแแแแแก แกแแชแแชแฎแแแกแฃแแแ แแแแแแแก แจแแกแแแแฌแแแแแแ. แขแแแแแ แ แแ แแก 60 แฌแแแ.
MSDP peers-แแก แกแฎแแแแแกแฎแแ แแแแแแแแแ แแแงแแคแแก แคแฃแแฅแชแแ แแแฃแ แแแแแแแแ, แ แแแแแ Keepalive แแ SA แจแแขแงแแแแแแแแแ แแ แแแฃแแแแแแก แ แแแแแแแ แแแแแแจแ แฌแแแ แแแแแ. แแกแแแ, แแ แขแแแแแแแแแจแ, แฉแแแ แแแแแแชแแแแ แแแแคแแแฃแ แแชแแ, แ แแแแแแช แแแฃแแแแแแก แกแฎแแแแแกแฎแแ แแแแแแแแแ - แแ แแงแ แแแแกแฎแแแแแแ แจแแกแ แฃแแแแแจแ.
แแฃ แแแแแแก แจแแฃแซแแแ แแแ แแแแแ, แกแแแแแแแแแแ แฌแแแแแแแฎแแ แแแแแแขแแ แแแจแ.
แฌแงแแ แ: www.habr.com