AWS Builder Center
Amazon EC2 Application Status Checks: Monitor More Than Just the Instance

Amazon EC2 Application Status Checks: Monitor More Than Just the Instance

Explore how Amazon EC2 Application Status Checks monitor application endpoints directly, integrate with CloudWatch and Auto Scaling, and automatically replace instances when their applications become unhealthy.

Amazon EC2 Application Status Checks: Monitor More Than Just the Instance

An Amazon EC2 instance can be running while the application hosted on it is completely unavailable.
The operating system may be reachable. The underlying AWS infrastructure may be healthy. However, the web server might have stopped, the Docker daemon might not be running, a network configuration could be incorrect, or the application might be returning HTTP 500 errors.
Until now, organizations often needed to detect these application-level failures using load balancer health checks, custom CloudWatch metrics, monitoring agents, Lambda functions, or external monitoring platforms.
AWS has introduced a simpler native option: Amazon EC2 Application Status Checks.
The new capability allows EC2 to send HTTP or HTTPS requests to an application endpoint every 60 seconds. EC2 evaluates the response and reports whether the application is healthy or impaired.
When integrated with Amazon EC2 Auto Scaling, an impaired application can cause the affected instance to be automatically terminated and replaced.

The visibility gap in traditional EC2 monitoring

Amazon EC2 has traditionally provided multiple infrastructure-oriented status checks.

System status check

The system status check monitors the AWS infrastructure supporting the instance.
It can identify problems such as:
  • Loss of network connectivity
  • Host hardware failure
  • AWS infrastructure issues
  • Power-related problems

Instance status check

The instance status check monitors the software and network configuration of the instance.
It can identify problems such as:
  • An unreachable operating system
  • Incorrect networking configuration
  • Exhausted memory
  • A corrupted file system
  • A failed kernel

Attached EBS status check

This check identifies whether attached Amazon EBS volumes are reachable and able to complete I/O operations.
These checks are important, but they do not necessarily confirm that the application is ready to serve users.
A server might pass every infrastructure check while:
  • NGINX is stopped
  • Apache is returning HTTP 500
  • A container has crashed
  • A required application process is unavailable
  • The health endpoint is timing out
  • An upstream dependency is failing
  • The application is listening only on localhost
That is the gap EC2 Application Status Checks address.

How EC2 Application Status Checks work

An application status check sends an HTTP or HTTPS request to a configurable endpoint on an EC2 instance.
You define:
  • Protocol: HTTP or HTTPS
  • Port
  • Application path
  • Expected HTTP response code
  • Failure threshold
  • Success threshold
  • Request timeout
  • Initialization grace period
For example, a check might call:
https://10.0.1.25:443/health

If the endpoint returns the configured status code, such as HTTP 200, the check passes.
If the application times out, refuses the connection, or returns an unexpected response, the check fails.
AWS evaluates the application every 60 seconds.
By default:
Setting
Default value
Check interval
60 seconds
Failure threshold
2 consecutive failures
Success threshold
2 consecutive successes
Timeout
6 seconds
Expected status code
200
Path
/
Initialization grace period
300 seconds
IP scope
Private IPv4
With these defaults, an application is generally marked impaired after two consecutive failed checks.
The thresholds are configurable, but the 60-second check interval is fixed.

A practical failure scenario

Consider an e-commerce application running on an EC2 instance.
The instance itself is healthy:
System status: Passed
Instance status: Passed
EBS status: Passed

However, the application process has crashed and the  /health  endpoint returns HTTP 503.
With an EC2 Application Status Check:
  1. EC2 sends a request to  /health .
  1. The application returns HTTP 503.
  1. The next check also fails.
  1. EC2 marks the application status as impaired.
  1. CloudWatch reports the failure.
  1. If the instance belongs to an Auto Scaling group, Auto Scaling terminates it.
  1. Auto Scaling launches a replacement instance to restore desired capacity.
The application failure becomes part of the native EC2 health model.

Auto Scaling integration

The Auto Scaling integration is one of the most valuable parts of this release.
Amazon EC2 Auto Scaling can automatically terminate and replace an instance whose overall application status is impaired.
No additional Auto Scaling group configuration is required beyond associating an included application status check with the group’s instances.
You can associate a check using:
  • Individual instance IDs
  • Resource tags
  • The Auto Scaling group system tag
For example, the following tag association targets instances in a particular Auto Scaling group:
aws ec2 associate-application-status-check \
--application-status-check-id asc-1234567890abcdef0 \
--target-tag-associations \
Key=aws:autoscaling:groupName,Value=my-production-asg

Using tags makes the configuration more scalable because newly launched instances matching the association can receive the same monitoring configuration.

Creating an application status check

A basic HTTPS check can be created using the AWS CLI:
aws ec2 create-application-status-check \
--protocol https \
--port 443 \
--path "/health" \
--status-code-matcher "200"

The check can then be associated with an instance:
aws ec2 associate-application-status-check \
--application-status-check-id asc-1234567890abcdef0 \
--instance-ids i-0123456789abcdef0

You can inspect the application status with:
aws ec2 describe-application-status \
--instance-ids i-0123456789abcdef0

The result includes:
  • Overall application status
  • Individual check status
  • Failure reason
  • HTTP status code returned
  • Protocol used
This helps teams distinguish between an unreachable application, incorrect endpoint, timeout, authentication problem, or server-side error.

Private VPC health checks

Application checks are performed from a private location inside the VPC.
AWS creates a managed elastic network interface in the VPC to send the health-check traffic. The request travels across the AWS internal network and does not need to traverse the public internet.
This means the application does not require:
  • A public IP address
  • An internet gateway
  • A public load balancer
  • A publicly accessible health endpoint
AWS offers two network-path options.

AWS-managed network path

AWS selects the source subnets and security groups used by the health-check network interface.
This option simplifies implementation.

Customer-managed network path

You specify the source subnets, source security groups, destination subnets, and destination security groups.
This is helpful when the VPC uses:
  • Strict network segmentation
  • Centralized firewalls
  • Compliance boundaries
  • Controlled routing
  • Inspection appliances
  • Restricted application subnets
In both cases, the destination instance’s security group must allow inbound traffic from the health-check source security group on the configured port.
Host-level firewalls must also permit the request.

CloudWatch monitoring

Amazon EC2 publishes application status information to Amazon CloudWatch.
The overall instance-level metric is:
StatusCheckFailed_Application

The metric reports whether the included application checks associated with the instance are passing or failing.
EC2 also publishes a separate metric for each individual application status check.
These metrics can be used to:
  • Create CloudWatch alarms
  • Notify operations teams
  • Trigger automated remediation
  • Visualize application health
  • Correlate failures with deployments
  • Build dashboards across an EC2 fleet
Detailed information is also available through:
describe-instance-status

and:
describe-application-status

CloudWatch is the better choice for alarms and automation, while the APIs provide more detailed status and failure information.

Application checks versus load balancer health checks

EC2 Application Status Checks do not make Elastic Load Balancing health checks obsolete. They solve overlapping but different architectural needs.
Consideration
EC2 Application Status Check
Load Balancer Health Check
Primary purpose
Monitor application health on EC2
Route traffic only to healthy targets
Requires a load balancer
No
Yes
Check location
Private ENI inside the VPC
Load balancer nodes
Auto Scaling replacement
Supported
Supported when enabled
Removes target from traffic
Not directly
Yes
Useful for non-load-balanced workloads
Yes
No
CloudWatch visibility
Yes
Yes
Configured by instance or tag
Yes
Configured through target groups
If an application already uses an Application Load Balancer, its target-group health check remains important because it controls traffic routing.
EC2 Application Status Checks can still provide a native instance-level health signal, particularly for:
  • Internal applications without a load balancer
  • Background services
  • Docker hosts
  • Administrative applications
  • Single-instance workloads
  • Private services
  • Workloads monitored across tags
  • Auto Scaling groups where direct EC2 health integration is desirable
The choice is not necessarily one or the other. Production architectures may use both for different purposes.

Designing a meaningful health endpoint

A health check is only as useful as the endpoint it monitors.
A shallow endpoint might always return HTTP 200 whenever the application process is running. That confirms process availability but says nothing about the application’s dependencies.
A deeper check might verify:
  • Database connectivity
  • Required configuration
  • Internal queues
  • Storage availability
  • Critical downstream APIs
  • Application initialization
  • Container health
However, checking every dependency can create another problem.
If a shared database experiences a temporary issue and every EC2 instance reports unhealthy, Auto Scaling could replace the entire fleet even though replacing instances will not repair the database.
A good design often separates:

Liveness

Confirms that the application process is alive and capable of responding.
Example:
/liveness


Readiness

Confirms that the application is ready to serve requests.
Example:
/readiness


Dependency health

Reports the condition of downstream services without necessarily causing immediate instance replacement.
Example:
/health/details

For Auto Scaling replacement, use an endpoint that indicates an instance-specific failure that a replacement can reasonably solve.

Deployment and maintenance considerations

Deployments, patching, and reboots may temporarily stop the application.
During that period, the status check can fail and Auto Scaling may replace an instance even though the interruption was expected.
AWS provides suppression for these situations.
Before maintenance:
aws ec2 enable-application-status-check-suppression \
--instance-ids i-0123456789abcdef0 \
--duration-seconds 3600

After maintenance:
aws ec2 disable-application-status-check-suppression \
--instance-ids i-0123456789abcdef0

This pattern can be integrated into CI/CD:
  1. Suppress the status check.
  1. Deploy or patch the application.
  1. Verify that the application started correctly.
  1. Disable suppression.
  1. Confirm that the health check passes.
The initialization grace period must also be long enough for new instances to become ready. The default is 300 seconds and the configurable range is 1–600 seconds.
A grace period that is too short can create a replacement loop where Auto Scaling continuously terminates instances before the application finishes starting.

Safe production rollout

AWS supports an  excluded  aggregation mode for testing.
When excluded, a check reports its results but does not contribute to the instance’s overall application status or drive Auto Scaling replacement.
A safe rollout would be:
  1. Create the check as  excluded .
  1. Associate it with a test instance.
  1. Confirm the expected responses.
  1. Expand it to a small production subset.
  1. Monitor for false positives.
  1. Change the check to  included .
  1. Enable alarms and automated replacement.
This reduces the risk of an incorrect path, security-group rule, timeout, or response-code matcher causing unnecessary instance replacement.

Pricing

Application status checks have two main cost components:
  • $0.01 per managed ENI per hour in each Availability Zone
  • Standard CloudWatch pricing for application status metrics
AWS creates managed ENIs based on the source subnet and security-group combinations required for the checks.
Architects should calculate the cost across:
  • Accounts
  • Regions
  • Availability Zones
  • VPCs
  • Network-path combinations
  • CloudWatch metrics and alarms
The feature is available in all commercial AWS Regions and AWS GovCloud (US) Regions.

Common implementation mistakes

Watch for these common problems:
  • The security group does not allow the health-check source.
  • A host firewall blocks the configured port.
  • The application listens only on  127.0.0.1 .
  • HTTP is configured while the endpoint expects HTTPS.
  • The health path returns a redirect rather than the expected code.
  • Authentication protects the health endpoint.
  • The application startup time exceeds the grace period.
  • A deep health check causes replacement during a shared dependency failure.
  • Deployment pipelines do not suppress checks during planned restarts.
For HTTPS checks, it is also important to understand that the application status check does not validate the server certificate.

Solution architect’s perspective

This feature reduces the gap between infrastructure availability and application availability.
When designing the solution, I would ask:
  1. What does “healthy” mean for this application?
  1. Is the health endpoint testing liveness or readiness?
  1. Will replacing the instance actually fix the reported problem?
  1. How will checks behave during deployment?
  1. Is the initialization grace period sufficient?
  1. Should Auto Scaling act on this check?
  1. Does the application already have an ALB health check?
  1. Are security groups and host firewalls correctly configured?
  1. Should AWS or the customer manage the network path?
  1. How will failures be alarmed, logged, and investigated?
The goal is not simply to create another HTTP check. It is to connect a meaningful application signal to an appropriate operational response.

Final thoughts

For years, infrastructure teams have understood an important reality:
A running server does not guarantee a working application.
Amazon EC2 Application Status Checks bring application-level monitoring directly into the EC2 health model.
By monitoring configurable HTTP or HTTPS endpoints, publishing CloudWatch metrics, operating through private VPC paths, and integrating with Auto Scaling, the feature provides a simpler way to detect and respond to application failures.
It will not replace every load balancer, observability platform, or synthetic monitoring solution.
But for many EC2 workloads, it removes custom monitoring components and creates a direct path from:
Application failure
↓
EC2 impaired status
↓
CloudWatch visibility
↓
Auto Scaling replacement

That makes EC2 health monitoring more representative of what users actually care about: not whether the virtual machine is running, but whether the application is working.

References

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article