Read a sample: 1. Think Like a Packet
A user reports that an application in Azure cannot reach a database. The virtual machines are running. The database service is available. A network security group appears to allow the database port. Yet the connection times out.
Each observation may be true, and none proves that the traffic has a usable path. The application might resolve the database name to an unexpected address. A route might send packets toward an inspection appliance that cannot forward them. The database might reject the source, or its reply might take a different path through a stateful device. Even a successful connection from an administrator’s laptop would not establish that the application has the same DNS answer, route, or permissions.
The most productive question is not “Which Azure feature is broken?” It is “What must happen, in order, for this particular connection to work?”
That change in perspective is the foundation of this book. We will follow a connection from its source to its destination and back, treating Azure resources as parts of a path rather than as isolated configuration pages. The goal is not to memorize a fixed diagram for every service. It is to develop a repeatable way to identify what the traffic is trying to do, what decisions affect it, and what evidence would distinguish one explanation from another.
“Server A cannot reach Server B” is a useful report, but it is not yet a testable network description. Before inspecting routes or rules, make the connection precise.
- Source: Which workload initiates the connection? Identify its network location and, when relevant, the actual process or service.
- Destination: Is the client connecting to an IP address or a DNS name? Which service and destination port does it intend to use?
- Protocol: Is the traffic TCP, UDP, ICMP, or something else? A test using one protocol does not necessarily prove another will work.
- Direction: Who initiates the session? Client-to-server traffic and server-to-client initiation can be subject to different rules.
- Expected result: What would success look like: a TCP handshake, an authenticated database session, or a particular application response?
- Time and scope: Does the problem affect every source, one subnet, one destination, or only intermittent attempts?
These details prevent misleading comparisons. An application might use TCP port 1433 while a troubleshooting test checks whether a host responds to ICMP. The two results answer different questions. Likewise, an HTTPS request that receives an authorization error may have crossed the network successfully even though the user’s task failed.
A connection is a chain of dependencies. DNS, routing, filtering, service availability, and application behavior all matter, but they do not all answer the same question. Keeping them separate makes it easier to interpret a symptom without jumping to a cause.
For each scenario in this book, work through six checkpoints. They are a reasoning sequence, not a promise that every packet encounters Azure services in the same order.
1. Source and intent. Establish where the connection starts, what it is trying to reach, and which protocol and port it uses.
2. Name resolution. If the client uses a name, determine the address it receives and the resolver path that produced it.
3. Forward routing. Determine where traffic toward that address is sent from the source, including any relevant intermediate hops.
4. Security and service acceptance. Examine controls along the selected path and whether the destination service is listening and willing to accept the connection.
5. Return path. Determine how replies reach the source and whether stateful devices see the traffic they need to see.
6. Evidence and result. Compare the proposed path with observations. State what the evidence proves, what remains uncertain, and what to test next.
You may move back and forth between checkpoints. For example, learning that a name resolves to a public address can change which routes and security controls matter. Discovering that a firewall sees no traffic may send you back to the source route or DNS answer. The sequence is useful because it makes those revisions explicit.
The checkpoints also apply when there is no DNS lookup. If the application connects directly to an IP address, record that fact and proceed. If the destination is a managed service, the return path may not be visible in the same way as the route table of a virtual machine. You can still ask whether the service has accepted the connection and what evidence is available on the client side.
We will use compact descriptions to make traffic paths readable without requiring a diagram for every case. Consider this fictional environment:
text
Source: app-vm, 10.20.1.4, subnet app
Destination: orders.internal.example, TCP 1433
DNS answer: 10.20.2.4
Target: db-vm, 10.20.2.4, subnet data
Expected: app-vm establishes a database session with db-vm
The addresses and names are scenario values, not recommended ranges or configuration requirements. The destination line describes what the client asks for; the DNS answer identifies the address it will attempt to contact. Separating those two facts is important. A name can be correct in an application configuration while resolving to an address the operator did not expect.
When the path itself matters, we can express it as a sequence:
text
app-vm → DNS resolver → address answer
app-vm → selected next hop → db-vm
db-vm → return path → app-vm
An arrow describes an intended or observed relationship, depending on the surrounding text. It does not automatically mean that a direct physical…