
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: PassedInstance status: PassedEBS status: Passed
However, the application process has crashed and the
/health endpoint returns HTTP 503.With an EC2 Application Status Check:
- EC2 sends a request to
/health.
- The application returns HTTP 503.
- The next check also fails.
- EC2 marks the application status as impaired.
- CloudWatch reports the failure.
- If the instance belongs to an Auto Scaling group, Auto Scaling terminates it.
- 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:
- Suppress the status check.
- Deploy or patch the application.
- Verify that the application started correctly.
- Disable suppression.
- 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:
- Create the check as
excluded.
- Associate it with a test instance.
- Confirm the expected responses.
- Expand it to a small production subset.
- Monitor for false positives.
- Change the check to
included.
- 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:
- What does “healthy” mean for this application?
- Is the health endpoint testing liveness or readiness?
- Will replacing the instance actually fix the reported problem?
- How will checks behave during deployment?
- Is the initialization grace period sufficient?
- Should Auto Scaling act on this check?
- Does the application already have an ALB health check?
- Are security groups and host firewalls correctly configured?
- Should AWS or the customer manage the network path?
- 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
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article