Understanding Software-Defined Architecture
Today's lesson is Understanding Software-Defined Architecture. This lesson keeps durable reasoning in the narration and exact notation in the companion reference. Begin with one principle: The underlay provides physical routed transport. Connect that principle to evidence, then use the reference or a lab to verify the detailed implementation.
Build the episode around three ideas: the underlay provides physical routed transport, the overlay expresses logical connectivity and policy, and northbound and southbound interfaces connect different layers. At each stage, ask what should be true, what observation would represent that state, and what a mismatch would justify changing. Build the foundation first. Imagine that an application has submitted a network policy through a controller.
The controller reports that the request was accepted, but traffic between two endpoints still fails. Before changing a link, resubmitting the policy, or touching a network device, what should you expect to be working? More importantly, what evidence would tell you which part isn’t working? A controller-based software-defined network gives you several distinct places to investigate.
The physical and routed network may be unable to carry traffic. The logical connectivity may not represent the intended endpoint relationship. The controller may know the desired policy but may not have communicated it successfully to the infrastructure. The infrastructure may have received the necessary state but may not be forwarding packets as expected.
These aren’t different names for one problem. They’re different parts of the architecture. That word foundation matters. An overlay can’t carry useful traffic by ignoring a broken underlay.
If the required physical connection is down or routed transport can’t reach the needed destination, logical policy doesn’t repair that missing transport. You can have a correct policy request and a controller that understands it, yet still have failed endpoint communication because the foundation beneath the logical service isn’t functioning. The overlay is the logical connectivity layer built over that underlay. It represents relationships among endpoints and policies without requiring those relationships to mirror every exact physical hop.
Two endpoints can have a logical relationship defined by the software-defined architecture even though packets still cross multiple physical and routed devices underneath. The overlay describes the connectivity and policy view that the architecture intends to provide. The underlay supplies the transport needed to make that view operational. The word fabric refers to the integrated software-defined network domain that brings these mechanisms together.
It isn’t merely another synonym for overlay. The fabric includes the transport foundation and the mechanisms used to express and apply logical connectivity and policy. When you describe a fabric, you’re describing a coordinated system rather than a single cable, route, policy, or controller request. Now consider how decisions and packets move through that system.
The control plane is concerned with the information and decisions that determine how traffic should be handled. The data plane performs the actual forwarding of packets according to the operational state available to the infrastructure. Both influence the same traffic, but they perform different jobs. When you are ready to work the example, open the companion reference for source-derived detail related to underlay/overlay/control/data-plane architecture diagram.
Do not treat it as a second narration script. Use it to perform the calculation, configuration, or interpretation while applying the reasoning developed here. Move from the concept to the observable path. This is why separating the planes doesn’t mean separating them beyond interaction.
A control-plane decision has practical value only when it can influence the state used for forwarding. The data plane, in turn, doesn’t need to ask an application to reconsider the complete policy for every packet. It uses the state that has already been established for packet handling. The architecture separates responsibilities while connecting their outcomes.
It also doesn’t mean that every packet travels through the controller. A controller can coordinate intent, policy, and state without becoming the path through which all endpoint traffic must flow. The infrastructure data plane still forwards the packets. That distinction prevents a common misunderstanding in which centralized control is mistaken for centralized packet forwarding.
Return to the two endpoints. First, predict the required state. The underlay must provide routed transport among the infrastructure components that need to participate. The overlay must represent the intended logical relationship between the endpoints.
The control side must establish the information needed to realize that relationship. Finally, the data plane must forward the actual packets according to the resulting operational state. Notice that a successful request answers only part of this chain. If an application submits a policy and receives an acceptance response, you have evidence about the interaction with the controller.
You don’t yet have proof that the infrastructure received the resulting state, that the underlay can carry the traffic, or that the data plane is forwarding as intended. Command acceptance or request acceptance is an input result. Operational behavior is the outcome you still need to verify. Applications and controllers need defined ways to exchange information.
A northbound application programming interface, or northbound AP I, exposes controller capabilities toward applications and automation. From the controller’s point of view, northbound is the application-facing direction. An application can use that interface to express a request, retrieve information, or interact with capabilities that the controller makes available. Northbound and southbound are therefore relative to the controller.
An application sits on the northbound side. The infrastructure sits on the southbound side. The controller occupies the coordinating position between them. These labels describe interface direction and responsibility.
They don’t mean that user packets enter from the north and leave through the south. Keep the neighboring concepts separate. Trace a policy request through those relationships. An automation application asks the controller for an endpoint-to-endpoint policy through a northbound AP I. The controller interprets that request within the software-defined system.
It then uses its southbound relationship with the infrastructure to communicate the state or intent needed by managed components. The infrastructure data plane forwards packets according to the operational state that results. Beneath all of this, the underlay supplies the routed transport on which the fabric and overlay depend. Suppose the controller correctly shows the intended logical relationship, but the infrastructure components needed for that relationship can’t communicate over the routed foundation.
The overlay’s intended state may be correct, yet the service still fails because the underlay is unavailable. Repeatedly editing the logical policy would target the wrong layer. The evidence points first toward the transport foundation. Now suppose the underlay provides the required transport, but the controller doesn’t represent the policy requested by the application.
In that case, the physical and routed foundation isn’t the first suspect. You’d examine the northbound interaction and the controller’s interpretation of the requested state. The packet failure looks similar to the user, but the location of the mismatch is different. Finally, the required underlay transport may be available, the overlay relationship may be represented correctly, and the controller-to-infrastructure communication may appear consistent, yet packets still don’t receive the expected treatment.
At that point, data-plane behavior becomes the crucial evidence. You compare actual forwarding with the state that should drive forwarding instead of assuming that correct-looking control information proves successful packet handling. Troubleshooting becomes much cleaner when you preserve these distinctions. Start by stating the expected behavior.
Then collect evidence from the part of the architecture that directly represents that behavior. Compare the observation with the prediction, isolate the smallest mismatch that explains the symptom, and correct one supported cause. Afterward, repeat the same check. A disappearing symptom is encouraging, but repeating the verification shows whether the predicted state and actual behavior now agree.
Avoid making several speculative changes at once. If you alter the underlay, resubmit the policy, and restart the logical relationship before checking the result, you may restore service without learning which condition was wrong. You also risk disturbing parts that were already correct. One evidence-backed correction preserves the relationship between cause, change, and result.
Use the final comparison to justify the next action. Picture a routed path through several infrastructure devices. That path is part of the underlay’s transport function. Now consider a policy relationship between an employee endpoint and an application endpoint.
That logical relationship belongs to the overlay view. The policy doesn’t have to describe every physical hop. Still, packets realizing that relationship must use working transport. The logical view can be abstracted from the exact path without becoming independent of transport altogether.
This also explains why a physical path change and a policy change have different meanings. If routed transport moves to another available physical path while preserving the necessary reachability, the overlay relationship may continue unchanged. If the endpoint policy changes while the transport stays healthy, the logical relationship may change without requiring a new physical design. Decoupled means the relationships can be managed separately.
It doesn’t mean they have no dependency. For interfaces, use the controller as your reference point. Communication between an application or automation system and the controller is northbound. Communication between the controller and managed infrastructure is southbound.
If an answer reverses those directions, follow the participants rather than relying on the ordinary geographic meaning of north and south. You can apply the complete model before touching a device. Begin with the requirement. Two endpoints should communicate according to an intended policy.
Predict that the controller should represent that intent, the infrastructure should receive the corresponding state, the underlay should provide routed transport, and the data plane should forward packets in a way consistent with the policy. Then choose evidence for each prediction. For the CCNA objective, the expected emphasis here is description and explanation. You should be able to describe the underlay, overlay, and fabric, explain the separation of control and data planes, and identify the directions served by northbound and southbound APIs.
That doesn’t require treating every software-defined product as identical or inventing implementation details that aren’t given. The architecture may look abstract when its terms are memorized in isolation. It becomes practical when you follow one policy from application request to controller decision, from controller communication to infrastructure state, and from infrastructure state to packet forwarding. At every stage, the underlay remains the transport foundation, while the overlay expresses the logical relationship the fabric is intended to deliver.
End with the practical judgment. A software-defined fabric works because several distinct responsibilities cooperate. The underlay supplies routed physical transport, while the overlay expresses logical connectivity and policy without having to mirror every physical hop. Control-plane decisions establish how traffic should be handled, and the data plane performs the packet forwarding that makes those decisions operational.
Applications reach controller capabilities through northbound APIs, while southbound interfaces connect the controller’s intent and state with managed infrastructure. When communication fails, don’t treat the whole fabric as one indistinct system. Predict what each part should provide, check the evidence at that boundary, and correct the smallest mismatch that explains the result. Knowledge check: Which layer would you investigate first when physical transport between fabric nodes is failing?
Stop for retrieval. Give the answer without notes, then check whether you included both the technical relationship and the evidence needed to verify it. Thanks for listening. This lesson was produced by Bare Metal Cyber dot com.