Skip to article
Web App Service operations

App Service health check path

An App Service health check path is the URL path App Service probes to determine whether each app instance is healthy enough to receive traffic.

Source: Microsoft Learn - Monitor App Service instances by using Health check Reviewed 2026-05-10

Exam trap
Changing app service health check path from the portal without recording the current state, owner, dependency impact, and rollback path.
Production check
Confirm subscription, resource group, app or plan name, slot, and region before interpreting any App Service output.
Practice this topic Microsoft Learn
Article details and learning context
Aliases
Azure App Service health check path, app service health check path
Difficulty
intermediate
CLI mappings
5
Last verified
2026-05-10
Review level
top250-pre130-priority
Article depth
field-manual-complete
Compare related concepts Search related resources Browse the glossary

Understand the concept

In plain English

App Service health check path is the application endpoint App Service calls to decide whether a running instance should continue receiving traffic. The path is usually something like /health or /api/health and should return a healthy HTTP response only when the app can actually serve users. It is not just a vanity page; it is an operational signal for instance health. You usually encounter it during design, deployment, troubleshooting, cost review, or security review, where the exact App Service boundary determines what Azure manages and what the application team still owns.

Why it matters

App Service health check path matters because it turns application health into a platform decision instead of leaving every instance in rotation until users complain. A weak path that always returns 200 can hide broken dependencies, while an overly strict path can remove healthy instances during a harmless downstream slowdown. The path should test enough critical functionality to protect users without performing expensive work or creating new outage pressure. When the concept is misunderstood, teams may scale the wrong resource, miss an exposure path, lose diagnostic evidence, overspend on unused capacity, or treat a dependency problem as an App Service problem. Clear understanding improves design reviews, change records, incident response, and handoffs between developers, platform engineers, security teams, and FinOps owners.

Technical context

Technically, App Service health check path is configured on an App Service app under Health check. App Service periodically sends requests to that path on each instance and can remove unhealthy instances from load balancing when they repeatedly fail. The feature is most valuable when the App Service plan has two or more instances, because traffic can move away from bad workers. Operators manage it through Azure Resource Manager, the Azure portal, Azure CLI, diagnostic settings, and deployment automation. The important boundaries are region, resource group, plan, app, slot, network path, identity, and monitoring destination.

Exam context

Compare with

App Service logs Availability test Application Insights

Where it is used

Where you see it

  1. You see it in the App Service Health check blade when operators configure a path such as /health, /ready, or /api/health for production apps.
  2. You see it during incidents when one instance fails probes, leaves rotation, and responders compare health endpoint behavior against logs, metrics, and recent deployments. during planned production operations and review.
  3. You see it in release gates when teams require a passing health endpoint before slot swaps, autoscale changes, or production traffic increases. during planned production operations and review.

Common situations

  • Configure App Service Health check to remove unhealthy instances from rotation before users experience repeated failures.
  • Point health probes at a lightweight endpoint that verifies dependencies needed for safe production traffic.
  • Separate readiness behavior from normal application routes so deployments can warm up before receiving traffic.
  • Diagnose scale-out or restart issues by comparing failed health checks with application logs and dependency telemetry.
  • Set consistent health-check paths across slots and environments so swaps do not introduce unexpected probe failures.

Illustrative Azure scenarios

These examples show how the concept can affect design and operations. They are illustrative scenarios, not customer claims.

Scenario 01 App Service health check path in action: checkout readiness signal Scenario, objectives, solution, measured impact, and takeaway.
Scenario

SummitCart, an online retailer, had checkout outages where one unhealthy App Service instance kept receiving traffic after a deployment.

Goals
  • Detect bad checkout instances before customers hit errors.
  • Remove unhealthy workers from rotation automatically.
  • Keep health checks lightweight under holiday load.
  • Cut incident detection time below five minutes.
Approach using App Service health check path

Engineers added a /health endpoint that checked process readiness, configuration loading, and a fast dependency ping to the payment gateway status cache. They enabled App Service Health check, scaled the plan to multiple instances, and documented which failures should return unhealthy responses. Deployment slots called the path before swap, and CLI checks verified the configured health path during release validation. Metrics and logs were routed to Log Analytics for after-action review. The implementation notes also captured ownership, monitoring signals, rollback steps, and validation evidence so support teams could repeat the pattern confidently. The implementation notes also captured ownership, monitoring signals, rollback steps, and validation evidence so support teams could repeat the pattern confidently.

Potential outcomes
  • Unhealthy instances were drained before broad customer impact.
  • Checkout incident detection dropped from 22 minutes to four minutes.
  • Holiday health probes added negligible CPU overhead.
  • Rollback decisions used endpoint evidence instead of user complaints.
What to learn

A good health check path turns application readiness into a platform signal that protects users.

Scenario 02 App Service health check path in action: hospital scheduling portal Scenario, objectives, solution, measured impact, and takeaway.
Scenario

Valence Care operated a patient scheduling portal where intermittent database connection failures caused some instances to serve blank appointment pages.

Goals
  • Verify instance readiness before accepting patient traffic.
  • Avoid expensive database checks on every probe.
  • Support slot swaps with measurable health evidence.
  • Reduce failed appointment sessions by 25 percent.
Approach using App Service health check path

The team implemented /api/health/readiness with cached dependency status, configuration checks, and a short database connectivity test that avoided heavy queries. App Service Health check was enabled only after the plan scaled to three instances. The release pipeline called the endpoint in staging, and operators used CLI to confirm the path, app settings, and instance count. Alerts tracked unhealthy instances and correlated failures with deployment history. The implementation notes also captured ownership, monitoring signals, rollback steps, and validation evidence so support teams could repeat the pattern confidently. The implementation notes also captured ownership, monitoring signals, rollback steps, and validation evidence so support teams could repeat the pattern confidently.

Potential outcomes
  • Failed appointment sessions fell 32 percent in the first month.
  • Health evidence prevented two unsafe slot swaps.
  • Probe execution stayed under 80 milliseconds at peak.
  • Operators isolated one bad instance without restarting the full app.
What to learn

Health check paths work best when they test readiness without becoming another production dependency bottleneck.

Scenario 03 App Service health check path in action: manufacturing supplier API Scenario, objectives, solution, measured impact, and takeaway.
Scenario

VectorForge Manufacturing ran supplier APIs on App Service and needed a safer way to remove bad instances during ERP maintenance windows.

Goals
  • Identify workers that could not reach required ERP endpoints.
  • Keep optional analytics outages from failing the health path.
  • Document readiness criteria for supplier-facing APIs.
  • Reduce support tickets during monthly ERP maintenance.
Approach using App Service health check path

Developers created a health path that checked app startup, required configuration, and a quick ERP gateway probe, while excluding optional analytics and reporting services. App Service Health check used that path for all production instances. Runbooks defined what each status meant, and CLI commands exported the health configuration before maintenance. Logs captured each unhealthy response reason without exposing internal credentials or ERP details. The implementation notes also captured ownership, monitoring signals, rollback steps, and validation evidence so support teams could repeat the pattern confidently. The implementation notes also captured ownership, monitoring signals, rollback steps, and validation evidence so support teams could repeat the pattern confidently. The implementation notes also captured ownership, monitoring signals, rollback steps, and validation evidence so support teams could repeat the pattern confidently.

Potential outcomes
  • Supplier API tickets during maintenance dropped 41 percent.
  • Optional analytics failures no longer removed healthy API instances.
  • Readiness criteria became part of the release checklist.
  • Instance restarts were targeted instead of plan-wide.
What to learn

A health check path is an operational contract between the application and the App Service platform.

Azure CLI

Azure CLI is useful because health-check settings can be inspected and changed alongside other app configuration. Operators can confirm the configured path, compare slots, export settings, and prove whether Health check is enabled before blaming the load balancer. CLI also supports repeatable pre-release checks across many apps.

Useful for

  • Inventory app service health check path across a resource group or subscription before a migration, incident review, or architecture audit.
  • Show current app service health check path settings and compare them with deployment templates, runbook expectations, or production change records.
  • Export app service health check path state as JSON so responders can attach repeatable evidence to tickets, reviews, or compliance findings.

Before you run a command

  • Confirm the active tenant and subscription because App Service resources often use similar names across development, test, and production.
  • Verify the resource group, app name, plan name, slot name, and permission level before changing live platform configuration.
  • Start with read-only show or list commands, use JSON output for evidence, and avoid printing secrets into shared terminals.

What the output tells you

  • Resource IDs and names confirm whether you are inspecting the intended App Service object instead of a similarly named environment.
  • Configuration fields show whether the running platform state matches the expected template, portal setting, or operational baseline.
  • Null values, warnings, and unexpected properties often reveal unsupported tiers, disabled features, drift, or environment-specific differences.

Mapped commands

Webapp operations

adjacent 
az webapp list --resource-group <resource-group>
az webappdiscoverWeb
read-only Microsoft Learn 
az webapp show --name <app-name> --resource-group <resource-group>
az webappdiscoverWeb
read-only Microsoft Learn 
az webapp config appsettings list --name <app-name> --resource-group <resource-group>
az webapp config appsettingsdiscoverWeb
read-only Microsoft Learn 
az webapp config appsettings set --name <app-name> --resource-group <resource-group> --settings <key>=<value>
az webapp config appsettingsconfigureWeb
mutating Microsoft Learn 
az webapp restart --name <app-name> --resource-group <resource-group>
az webappoperateWeb
mutating Microsoft Learn

Architecture context

An App Service health check path is part of the runtime availability design, not a cosmetic monitoring endpoint. It tells App Service which URL to probe on each instance before keeping that instance in traffic rotation. A good path checks the application process and critical lightweight dependencies without turning every transient backend issue into a full instance removal. Architects should place it beside scale-out rules, deployment slots, readiness behavior, and alerting because it directly affects traffic routing during incidents and releases. The path should be versioned, predictable, unauthenticated or safely probeable, and fast enough to avoid false failures. Poor health checks hide bad instances or drain healthy capacity unnecessarily.

Security
Security for App Service health check path requires care because the endpoint may be reachable through the same network path as the app. It should not expose secrets, database details, dependency names, stack traces, or internal diagnostics. If the app is private, the health path should respect the same access model. Teams should avoid requiring interactive authentication for the probe while still preventing public disclosure of sensitive operational information. The practical control is to know who can read, modify, deploy, scale, or diagnose the resource and which identities are used at runtime. Review role assignments, publishing profiles, app settings, certificate bindings, DNS, network access, and diagnostic destinations before production changes.
Cost
Cost for App Service health check path is indirect, but still real. Good health checks can reduce incident time and prevent over-scaling around a few bad instances. Poor checks can create churn, trigger unnecessary restarts, or force teams to add capacity while the real problem is application readiness. The endpoint should be lightweight because every instance receives repeated probes that add small but continuous processing work. FinOps review should look at plan tier, worker count, storage, logging, network services, unused slots, retained diagnostics, and whether several apps share the same capacity. Cost decisions should be paired with reliability and performance evidence.
Reliability
Reliability for App Service health check path depends on designing the path to reflect real readiness. The endpoint should verify the app process, configuration, and critical dependencies that determine whether the instance can safely serve traffic. It should not fail because of optional services, analytics calls, or long-running checks. Operators should test behavior during deployments, slot swaps, dependency failures, warm-up, and scale-out events. The safest approach is to test failure behavior before production pressure. Review what happens during restart, deployment, slot swap, scale-out, dependency failure, DNS change, and regional maintenance. Metrics, logs, health signals, and rollback steps should be known before the change window.
Performance
Performance for App Service health check path should be lightweight and fast. The path should not run expensive queries, call many downstream services, allocate large objects, or perform remote writes. A slow health endpoint can make healthy instances look unhealthy and add noise during scale-out. Measure response time, dependency timing, and error rates so the probe protects users without becoming a performance problem itself. Operators should compare platform metrics with application traces before making changes. Important signals include request duration, CPU, memory, HTTP queue length, restarts, dependency latency, connection counts, log volume, and instance distribution. Use App Service health check path decisions as part of the production design, not as a casual portal setting.
Operations
Operations for App Service health check path includes choosing the path, implementing the endpoint, enabling Health check, watching unhealthy-instance metrics, and documenting what each result means. Operators should know how many failures remove an instance, which dependencies the endpoint checks, and when to restart, scale, roll back, or ignore a transient warning. The path should be part of deployment acceptance, not an afterthought. Good operations also means standardizing tags, naming, monitoring, diagnostic routing, and evidence collection. Teams should prefer repeatable CLI or IaC checks for state that matters during incidents. After any change, verify user traffic, logs, metrics, and dependency behavior.

Common mistakes

  • Changing app service health check path from the portal without recording the current state, owner, dependency impact, and rollback path.
  • Assuming a successful platform update means the application works, instead of validating traffic, logs, metrics, and dependencies.
  • Troubleshooting only the app code while ignoring plan capacity, networking, identity, DNS, certificates, and recent configuration changes.