What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
For an Amazon ECS service that runs GPU workloads, tune two separate control planes: the container health check that measures whether the application is usable, and the instance-health signal that can identify an impaired GPU where ECS Managed Instances support accelerated-compute monitoring. Then set minimumHealthyPercent and maximumPercent so ECS can replace failed tasks without demanding more compatible GPU capacity than the cluster actually has.
There is no AWS-prescribed universal threshold for model loading, probe intervals, or deployment percentages. The correct values depend on startup time, probe cost, failure tolerance, desired task count, and the number of free GPU slots that can run the replacement.
As an Amazon Associate I earn from qualifying purchases.
Start with the two different failure signals
A GPU service can be unhealthy in two fundamentally different ways. The process may be running but the application is not ready to serve inference, or the underlying GPU may be impaired even though the process has not exited. ECS treats those conditions differently.
Application and container health
ECS evaluates the healthCheck in the task definition’s container definition. The check executes inside the container. It should test the condition that represents useful service—for example, an internal readiness endpoint, a model-serving status command, or a lightweight operation that confirms the application can accept work.
#1 Best Overall
- High Efficiency: The computer graphics card tester can quickly detect faults such as no display, blurry display, and unstable display without the need for individual measurements of the PCI bus interface between the graphics card and motherboard using a multimeter. It can accurately identify issues like short circuits and CPU failures with rate, making it an essential tool for graphics card repairs.
- Versatile Testing Capabilities: The graphics card tester diagnostic tool is specifically designed to test the data bus connections between the graphics card CPU and the computer motherboard's PCI interface for open circuits and short circuits.
- Comprehensive Fault Diagnosis: When troubleshooting computer graphics card issues, the graphics card diagnostic analyzer tester allows technicians to inspect for burn marks, broken PCB traces, and abnormal voltages before conducting further tests. This comprehensive approach helps in identifying underlying problems accurately and efficiently.
- User Friendly Operating: The display video graphics card tester is designed for ease of use, with a simple setup process involving inserting the faulty card into the corresponding slot, applying a 12V power supply, and pressing the push buttons switch. The indicator lights on the tester provide clear feedback on the status of the graphics card, allowing for quick and accurate fault diagnosis.
- Accurate Fault Localization: The graphics card tester with Light's indicator lights offer quick feedback on the condition of the graphics card, helping technicians pinpoint issues with the main CPU chip such as open circuits or short circuits. In case of any anomalies in the indicator lights, further confirmation using a multimeter can be done to accurately locate the fault points, ensuring thorough troubleshooting and repair.
An image can contain a Docker HEALTHCHECK, but ECS does not monitor that embedded check when it is omitted from the ECS container definition. Put the check in the task definition if ECS is expected to use it for service health and replacement decisions.
GPU device and instance health
On ECS Managed Instances, accelerated-compute health monitoring can report an impaired GPU at the container-instance level. An event or health-change record can include an NVIDIA Xid code in statusReason. This is a device or instance signal, not proof that an application endpoint is ready.
Use the two signals together: the container check answers “can this task serve?” while accelerated-compute health answers “is the host’s GPU functioning?” The cited ECS documentation describes this GPU signal for Managed Instances, so do not assume the same signal exists for every ECS launch type.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Configure the ECS container health check
Place the check in the task definition
Define healthCheck under the relevant container definition. Use CMD when the command should execute directly with an argument array. Use CMD-SHELL only when shell parsing, pipelines, variable expansion, or another shell feature is actually required.
The command must exist in the runtime image. A check that calls curl, a GPU utility, or a custom script fails if that executable was not installed in the image. Such a failure measures image contents rather than application health.
Rank #2
- [Quick Fault Detection] The graphics card tester quickly identifies no display, blurry display, and unstable display issues without the need for complex measurements, making it essential for precision repairs.
- [ Design] The graphics card tester with indicator lights offers quick feedback on main cpu chip issues, ensuring thorough troubleshooting and repair for optimal performance.
- [Comprehensive Testing] Specifically designed to test data bus connections for open circuits and short circuits, the diagnostic tool ensures accurate fault detection in graphics cards and motherboards.
- [Efficient Troubleshooting] Technicians can inspect burn marks, broken traces, and abnormal voltages with ease, helping to efficiently identify underlying problems in graphics cards.
- [Ease of Use] With a simple setup process involving a 12v power supply and indicator lights for clear feedback, testing and diagnosing graphics card faults is quick and accurate.
{
"name": "inference",
"image": "example/inference:stable",
"healthCheck": {
"command": ["CMD", "./healthcheck", "--ready"],
"interval": 30,
"timeout": 5,
"retries": 3,
"startPeriod": 120
}
}This is an illustrative configuration, not an AWS recommendation. The values are within the documented parameter ranges. Replace the command with a check that is present in your image and reflects the readiness condition your service requires.
Understand the timing controls
| Setting | Documented range or default | What it controls | Tuning question |
|---|---|---|---|
interval |
5–300 seconds; default 30 seconds | Time between health-check attempts | How quickly must a newly failed task be detected, and how much probe load can the service tolerate? |
timeout |
2–60 seconds; default 5 seconds | How long ECS waits for one attempt to finish | What is the longest normal response time for the probe under load? |
retries |
1–10; default 3 | Consecutive failures needed after startup before the container is unhealthy | How many transient failures should be tolerated? |
startPeriod |
0–300 seconds; disabled by default | Startup grace period before failures count normally | How long can image initialization, model loading, CUDA setup, and warm-up take? |
These are supported values and documented defaults, not performance-study results or universal production thresholds. A shorter interval can detect a failed task sooner but increases probe frequency. A longer timeout avoids false failures for a legitimately slow probe but delays detection. More retries absorb transient errors while extending the time before ECS declares the task unhealthy.
Recommended Free Tools
Choose a startup grace period based on real initialization
GPU containers often spend their early lifetime downloading or loading a model, creating a CUDA context, compiling kernels, allocating memory, or warming caches. Set startPeriod long enough to cover the expected initialization path rather than making the readiness command so permissive that it reports success before the service can accept traffic.
During the start period, early failures do not count in the normal failure tally. A successful check during that period makes the container healthy; subsequent failures are then evaluated against retries. The grace period is not a permanent shield. If the task becomes unhealthy after it has passed startup, ECS can act on the later failures.
Probe readiness, not merely process existence
A process-presence test can pass while the model server is still loading, the GPU is out of memory, or the request path is returning errors. Prefer a cheap readiness check that exercises the condition users depend on. Keep it bounded: a health probe should not perform a full production inference for every interval unless that cost is intentional and safe.
Rank #3
- [Quick Fault Detection] Identify no display, blurry display, and unstable display fast without measuring pins. Use in a computer repair shop or a home build bench for quick card checks.
- [Bus Circuit Testing] Test data bus connections for open circuits and short circuits to pinpoint faults. Use in an electronics lab or a technician workbench for board level repair.
- [Visual PCB Inspection] Check burn marks, broken traces, and abnormal voltages before deeper tests. Use in a hardware repair shop or a circuit board inspection station.
- [Simple Push Button Use] Insert the card, apply 12V power, and press the switch for light feedback. Use in a PC repair store or a DIY computer upgrade table.
- [CPU Fault Location] Indicator lights help locate main CPU chip faults for accurate diagnosis. Use in a graphics card repair station or an electronics recycling center.
If your application exposes separate liveness and readiness states, make the ECS check reflect the state that should cause traffic to stop or a task to be replaced. Document any authentication, local socket, or environment-variable requirements inside the image so an image rebuild does not silently invalidate the check.
Free tools Windows power users keep installed
One-click scans. No signup required.
Use accelerated-compute health as a complementary GPU signal
For a service on ECS Managed Instances, inspect container-instance health and health-change events for the ACCELERATED_COMPUTE signal. An impaired device may be accompanied by an NVIDIA Xid code in the reason. Record that reason with the task and instance identifiers so responders can distinguish a host fault from an application regression.
A GPU impairment can affect multiple tasks on one instance. Replacing only the task that first failed its application check may not solve the problem if the replacement is placed on the same impaired device. Conversely, an instance-health event does not prove that every task on the host is serving incorrectly. Use the event to drive instance remediation or placement decisions while retaining application-level checks for task readiness.
Because the cited documentation limits this accelerated-compute check to Managed Instances, verify the launch type and the health events available in your environment before building an automated response around it.
Tune service replacement with minimum and maximum percentages
What the two percentages mean
| Setting | Operational meaning | GPU-specific concern |
|---|---|---|
minimumHealthyPercent |
The minimum proportion of the desired service count that ECS should keep healthy during deployment or reconciliation. The documented default for a replica service is 100%. | Lowering it permits more old capacity to be taken out before replacements are ready, which may reduce availability during a GPU rollout. |
maximumPercent |
The upper proportion of the desired count that ECS may run during deployment or replacement. | Raising it creates task-count headroom, but a new task still needs a compatible, available GPU slot. |
Set the minimum according to the smallest service capacity your users can tolerate. Set the maximum high enough for replacement-first operation when the cluster has spare compatible GPU capacity. Percentages govern task counts; they do not reserve GPU memory, device IDs, instance families, or placement slots.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Repair Windows errors before they cause bigger problems3Fix the driver behind crashes, sound loss and screen glitchesRank #4
- High Efficiency: The computer graphics card tester can quickly detect faults such as no display, blurry display, and unstable display without the need for individual measurements of the PCI bus interface between the graphics card and motherboard using a multimeter. It can accurately identify issues like short circuits and CPU failures with rate, making it an essential tool for graphics card repairs.
- Versatile Testing Capabilities: The graphics card tester diagnostic tool is specifically designed to test the data bus connections between the graphics card CPU and the computer motherboard's PCI interface for open circuits and short circuits.
- Comprehensive Fault Diagnosis: When troubleshooting computer graphics card issues, the graphics card diagnostic analyzer tester allows technicians to inspect for burn marks, broken PCB traces, and abnormal voltages before conducting further tests. This comprehensive approach helps in identifying underlying problems accurately and efficiently.
- User Friendly Operating: The display video graphics card tester is designed for ease of use, with a simple setup process involving inserting the faulty card into the corresponding slot, applying a 12V power supply, and pressing the push buttons switch. The indicator lights on the tester provide clear feedback on the status of the graphics card, allowing for quick and accurate fault diagnosis.
- Accurate Fault Localization: The graphics card tester with Light's indicator lights offer quick feedback on the condition of the graphics card, helping technicians pinpoint issues with the main CPU chip such as open circuits or short circuits. In case of any anomalies in the indicator lights, further confirmation using a multimeter can be done to accurately locate the fault points, ensuring thorough troubleshooting and repair.
How ECS handles an unhealthy task
- Detect the failure. ECS receives an unhealthy container result, and any applicable load-balancer target-group health also participates in deployment health accounting.
- Try to launch a healthy replacement first. The scheduler generally attempts to start a replacement before stopping the unhealthy task.
- Check the service maximum. If
maximumPercentprevents the extra task from running, ECS can stop an unhealthy task to release room and then launch the replacement. - Reconcile to the desired count. If the replacement is also unhealthy, ECS may stop either unhealthy task while it works back toward
desiredCount.
This fallback behavior means a restrictive maximum can turn a replacement-first rollout into a stop-then-start sequence. That may be unavoidable on a tightly packed GPU cluster, but it creates a service-capacity gap that should be reflected in the availability objective.
Account for load-balancer health and startup latency
When a service uses a load balancer, ECS may wait for the required target-group health status as well as container health before counting a task healthy. Model loading and GPU warm-up therefore affect the time a deployment occupies replacement capacity. Do not shorten the health-check grace period merely to make deployment dashboards change faster; doing so can create replacement churn during normal initialization.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Verify GPU placement capacity before changing percentages
ECS task definitions can declare GPU requirements. Placement then depends on the correct GPU resource type, compatible instance family, available device capacity, and any placement constraints or strategies. A service can be below its maximumPercent and still be unable to start a replacement because no eligible GPU instance has a free device.
- Check the number of free compatible GPUs, not only the number of running tasks.
- Confirm that the replacement task’s declared GPU requirement fits the available device count and memory on candidate instances.
- Review placement constraints, availability-zone requirements, and capacity-provider behavior that may exclude otherwise suitable instances.
- Check whether an impaired instance is still being considered for placement; a device-health event may require instance replacement or draining rather than another task restart.
For GPU services, deployment headroom is therefore a two-part calculation: task-count headroom from maximumPercent, and physical placement headroom from free, healthy, compatible GPU resources.
A practical tuning workflow for SREs
- Measure initialization. Capture the time from container start until the model is loaded, the GPU context is usable, and the readiness endpoint can serve a representative request. Use a value above the normal startup envelope for
startPeriod, within the documented 0–300-second range. - Define the failure condition. Decide what should trigger replacement: an unavailable endpoint, a failed local readiness command, a persistent GPU allocation error, or an instance-health event. Do not substitute a process check for a service-readiness requirement.
- Validate the command in the image. Run the exact command with the production image and permissions. Confirm that every executable and path exists in the deployed architecture.
- Set detection timing. Choose
interval,timeout, andretriesto balance detection delay, probe cost, and transient-failure tolerance. Stay within 5–300 seconds, 2–60 seconds, and 1–10 respectively. - Inspect both health streams. Correlate container-health transitions with container-instance accelerated-compute events and NVIDIA Xid reasons where Managed Instances provide them.
- Calculate deployment capacity. Set
minimumHealthyPercentfrom the service’s tolerated loss of capacity. SetmaximumPercentfor the desired replacement headroom, then verify that the cluster can supply the required healthy GPUs. - Test failure paths deliberately. Exercise an application failure, a slow startup, and—where your operational policy permits—an impaired-device response. Verify whether ECS replaces the task, drains the instance, or becomes blocked by placement capacity.
- Alert on the cause, not just the symptom. A failed readiness check, a target-group failure, and an accelerated-compute impairment should produce different runbook paths even if all eventually reduce the service’s healthy count.
Common failure modes and corrections
| Symptom | Likely cause | Correction |
|---|---|---|
| Task is immediately unhealthy after launch | Model or CUDA initialization exceeds the startup grace period | Measure startup and adjust startPeriod; keep the readiness command meaningful. |
| Every probe fails with “command not found” | The health-check executable is absent from the image | Install the tool, use an existing executable, or ship a purpose-built check. |
| Tasks flap during brief latency spikes | Timeout is too short or retries are too low for normal variance | Compare probe latency with timeout and increase tolerance within the supported limits. |
| ECS cannot start the replacement | No compatible healthy GPU capacity is free, even though task-count maximum allows it | Add or recover suitable GPU capacity, adjust placement constraints, or accept stop-before-start behavior. |
| Replacement starts but fails again on one host | The underlying device or instance is impaired | Inspect Managed Instances accelerated-compute health and Xid details; remediate the instance rather than repeatedly restarting tasks. |
| Deployment appears healthy late | Container or target-group health waits for model warm-up and load-balancer checks | Include those delays in rollout timing and alarms instead of making probes falsely permissive. |
How to choose settings without a universal “best” number
A useful policy is to derive values from service behavior. Let the startup grace cover the normal upper tail of model and GPU initialization. Let the probe timeout exceed the normal local readiness response while remaining short enough to detect a genuinely hung process. Let retries cover the briefest transient interruption you are willing to tolerate, and use the interval to set the maximum detection cadence you can afford.
For replacement, first decide the minimum number of healthy serving tasks required for the user-facing objective. Encode that floor in minimumHealthyPercent. Then determine whether at least one replacement can run concurrently with the current desired set on healthy, compatible GPUs. If so, configure maximumPercent to permit that overlap. If not, no percentage alone can create capacity; the runbook must address GPU supply or accept a temporary reduction while ECS recovers.
Revisit these settings when model size, initialization behavior, instance family, task GPU requirement, load-balancer configuration, or desired count changes. AWS documents the mechanics and supported ranges, but the service owner must supply the availability and latency objectives that turn those mechanics into thresholds.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →
