{"id":2684,"date":"2026-10-08T18:04:35","date_gmt":"2026-10-08T18:04:35","guid":{"rendered":"https:\/\/www.exam-topics.net\/blog\/?p=2684"},"modified":"2026-10-12T20:47:27","modified_gmt":"2026-10-12T20:47:27","slug":"az-104-load-balancing-and-application-delivery","status":"publish","type":"post","link":"https:\/\/www.exam-topics.net\/blog\/az-104-load-balancing-and-application-delivery\/","title":{"rendered":"Microsoft AZ-104: Load Balancing and Application Delivery"},"content":{"rendered":"

Load balancing appears in the current AZ-104 networking objectives under name resolution and load balancing. Microsoft specifically expects Azure administrators to configure an internal or public load balancer and troubleshoot load-balancing behavior. That makes the topic narrower than a full application-delivery architecture course, but it still requires understanding front ends, backend pools, health probes, rules, and the difference between network-level distribution and higher-layer application decisions. The AZ-104 exam<\/a> often tests which control matches the availability and reachability requirement.<\/p>\n

The easiest way to reason about these scenarios is to start with the client. Where does the client connect? Which front-end address receives the connection? Which healthy backend should process it? What probe determines health? Which rule maps the front end to the backend? If any of those elements is missing or inconsistent, a seemingly healthy application can still be unreachable.<\/p>\n

Separate distribution from application intelligence<\/h2>\n

Azure Load Balancer operates at the transport layer and distributes supported TCP or UDP flows. It is appropriate when the requirement is to balance network traffic across virtual machines or other supported backends without requiring application-layer inspection. This is different from an HTTP-aware gateway or reverse proxy that can make decisions based on host names, paths, certificates, or web-application rules.<\/p>\n

This distinction matters on the exam because \u201cload balancing\u201d is sometimes used casually in a scenario that actually describes Layer 7 behavior. Read the requirement rather than anchoring on the phrase. If the task is simply to expose a service on a front-end IP and distribute connections across healthy backend instances, Azure Load Balancer fits naturally.<\/p>\n

The broader concept is similar to other forms of redundancy described in NIC teaming and load balancing<\/a>: multiple resources are used to improve availability or capacity, but the mechanism and failure boundary determine what the design actually protects.<\/p>\n

Choose between public and internal front ends<\/h2>\n

A public load balancer uses a public front-end IP for traffic that must be reachable from outside the virtual network. An internal load balancer uses a private front-end address for services intended to remain inside private network boundaries. That choice should follow the client location and exposure requirement, not a preference for one product variant.<\/p>\n

An internal application tier behind a web tier usually does not need a public front end merely because multiple backends exist. Conversely, an internet-facing service needs a reachable front-end design and the surrounding security controls to permit the intended traffic. The least-exposure principle is useful: give the service only the reachability it requires.<\/p>\n

Remember that load balancing does not replace authentication or application authorization. It determines where a connection is sent. The backend application still needs its own identity and data-security controls.<\/p>\n

Understand backend pools, health probes, and rules<\/h2>\n

The backend pool identifies the instances that can receive traffic. A health probe determines whether a backend is considered available. A load-balancing rule connects the front-end IP and port to the backend pool and defines how the traffic is processed. If the probe tests the wrong port or path, a healthy server can be marked unavailable. If the application listens on a different port than the rule expects, the connection can fail even though every resource is running.<\/p>\n

Health is therefore an application-delivery signal, not merely a virtual-machine power state. A VM that is \u201crunning\u201d may still have a failed service. When troubleshooting, verify that the probe reflects the service users actually depend on and that the backend can respond to it.<\/p>\n

Backend membership also matters during scaling and maintenance. Adding capacity only helps if the new instances are in the correct pool and pass the configured health check. Removing an instance safely means considering in-flight connections and how the application handles state.<\/p>\n

Do not ignore network security and return traffic<\/h2>\n

A load balancer can be configured correctly while an NSG blocks the data path. Administrators should verify security rules on the relevant subnets and NICs, along with any required Azure platform probe traffic. This is a recurring AZ-104 pattern: one service is not a substitute for another control plane.<\/p>\n

Routing also matters. If backend responses follow an unexpected path through a network virtual appliance, stateful inspection can break the session. Troubleshooting should therefore include the effective route as well as the load-balancer configuration. The network must support both the inbound and return paths.<\/p>\n

When security appliances are part of the design, it can help to review the distinction between firewall deployment models<\/a>, but AZ-104 questions should still be answered with the specific Azure configuration required by the scenario.<\/p>\n

Know where Application Gateway fits without overstudying it<\/h2>\n

Application Gateway is a useful adjacent Azure service because it provides application-layer delivery features. Microsoft lists it among AZ-104 study resources, but the April 2026 measured-skill bullet under this area specifically names internal or public load balancers and troubleshooting load balancing. Candidates should understand the architectural distinction without allowing a broader Application Gateway feature set to displace the exact objective.<\/p>\n

If a scenario describes URL path routing, HTTP host-based behavior, TLS termination at an application proxy, or web application firewall capabilities, that points toward a Layer 7 service. If the requirement is transport-level distribution across backend VMs, Azure Load Balancer is the cleaner answer. This is a scope discipline question as much as a product question.<\/p>\n

Architecture-oriented study for AZ-305<\/a> goes further into selecting application-delivery patterns. AZ-104 is more concerned with deploying, configuring, and troubleshooting the operational component.<\/p>\n

Troubleshoot the service chain, not one screen<\/h2>\n

Start with the front end: does it have the expected address and exposure? Then inspect the rule: are protocol and ports correct? Check the backend pool and confirm the expected instances are members. Validate the health probe and determine why a backend is marked healthy or unhealthy. Next inspect NSGs, effective routes, and the application listener itself.<\/p>\n

If some backends work and others fail, compare their health responses and local service configuration. If no backends work, inspect the shared front-end, rule, and probe definitions first. If only external clients fail while internal tests succeed, review public reachability and security controls. This symptom-based approach narrows the search faster than recreating the load balancer.<\/p>\n

Azure networking questions are often designed so that one misconfigured layer explains the entire scenario. Treat every detail as evidence rather than assuming that \u201cload balancer problem\u201d means the load balancer object itself is wrong.<\/p>\n

Practice with availability scenarios<\/h2>\n

Create small decision exercises. An internal API needs one private address while three VMs provide the service: choose an internal load balancer. An internet-facing TCP service requires a stable public entry point and multiple healthy backends: choose a public front end. A probe reports every backend unhealthy even though administrators can log into the VMs: inspect the service and probe target rather than the VM power state.<\/p>\n

Then add failure conditions. What happens if an NSG blocks the application port? What if the route sends return traffic through an unexpected appliance? What if the health probe checks a port that no process listens on? These are the kinds of operational interactions AZ-104 expects administrators to diagnose.<\/p>\n

The goal is not to memorize a configuration wizard. It is to understand the flow from client to front end to healthy backend and back again. Once that flow is clear, Azure Load Balancer questions become a structured troubleshooting exercise rather than a list of settings.<\/p>\n

Plan for state, scaling, and backend change<\/h2>\n

Load distribution is simplest when backend instances are interchangeable. If an application stores session state only in local memory, sending later requests to a different backend can break the user experience unless the application or delivery design handles that state. AZ-104 does not require deep application engineering, but administrators should understand that infrastructure availability can expose application design assumptions.<\/p>\n

Scaling also changes the backend pool over time. New instances must be added correctly and become healthy before they carry production traffic. Instances being removed should stop receiving new work in a controlled way where the application requires graceful shutdown. A load balancer increases the value of horizontal scale only when pool membership and health accurately reflect the application\u2019s real capacity.<\/p>\n

For troubleshooting, compare a failing backend with a working one. Check listener configuration, local firewall settings, route behavior, NSG rules, and probe response. If every backend fails at once, investigate shared elements such as the front end, rule, probe definition, or upstream network. This comparison method helps distinguish a single-server problem from a load-balancer design problem.<\/p>\n

Keep load balancing separate from fault-tolerant application design<\/h2>\n

Distributing connections across several backends improves service availability only when the application and its dependencies can tolerate individual instance loss. A database single point of failure, shared storage dependency, or external service outage can still take down every healthy web server. Azure Load Balancer protects the front-end path to its backends; it does not automatically make the entire application highly available.<\/p>\n

This distinction matters when reading architecture-heavy scenarios. If the requirement is to survive a VM failure, multiple healthy backends behind a load balancer can help. If the requirement is regional resilience or data-layer continuity, additional architecture is required. Keep the scope of the component aligned with the failure it can actually mitigate.<\/p>\n","protected":false},"excerpt":{"rendered":"

Load balancing appears in the current AZ-104 networking objectives under name resolution and load balancing. Microsoft specifically expects Azure administrators to configure an internal or public load balancer and troubleshoot load-balancing behavior. That makes the topic narrower than a full application-delivery architecture course, but it still requires understanding front ends, backend pools, health probes, rules, […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[10,1],"tags":[],"class_list":["post-2684","post","type-post","status-publish","format-standard","hentry","category-microsoft","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/www.exam-topics.net\/blog\/wp-json\/wp\/v2\/posts\/2684","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.exam-topics.net\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.exam-topics.net\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.exam-topics.net\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.exam-topics.net\/blog\/wp-json\/wp\/v2\/comments?post=2684"}],"version-history":[{"count":3,"href":"https:\/\/www.exam-topics.net\/blog\/wp-json\/wp\/v2\/posts\/2684\/revisions"}],"predecessor-version":[{"id":3933,"href":"https:\/\/www.exam-topics.net\/blog\/wp-json\/wp\/v2\/posts\/2684\/revisions\/3933"}],"wp:attachment":[{"href":"https:\/\/www.exam-topics.net\/blog\/wp-json\/wp\/v2\/media?parent=2684"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.exam-topics.net\/blog\/wp-json\/wp\/v2\/categories?post=2684"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.exam-topics.net\/blog\/wp-json\/wp\/v2\/tags?post=2684"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}