EX294 Coordinate rolling updates Practice Question
You are performing a rolling update on a 5-node application cluster using an Ansible playbook with `serial: 1`. The playbook includes a task that uses the `uri` module to check the application health endpoint after each node is updated. The health check must wait until the application returns HTTP 200 before proceeding to the next node. Which approach ensures that the playbook waits for the health check to succeed before moving to the next host?
⚠ Common exam trap
The trap here is assuming that the wait_for module can check HTTP responses, but it is designed for files, ports, or conditions, not HTTP status codes.
Answer choices
Why each option matters
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
Use the uri module with retries and until to repeatedly check the endpoint until it returns HTTP 200.
To ensure the playbook waits for the application to become healthy after each node update, you should use the uri module with retries and until. This combination repeatedly polls the health endpoint until it returns HTTP 200 or the retries are exhausted. This approach is reliable and ensures that the application is ready before proceeding to the next node in the rolling update.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
Use the wait_for module with the host and port parameters to wait for the application to start listening.
Why it's wrong here
The wait_for module can wait for a port to be open, but it does not verify the application's HTTP response. A port could be open while the application is not yet ready to serve traffic. Therefore, it does not guarantee that the health check returns HTTP 200.
- ✗
Use the uri module with the status_code parameter set to 200 and register the result, then use a wait_for condition on the result.
Why it's wrong here
The uri module does not have a status_code parameter; it uses status_code to define expected status codes. However, it does not automatically wait; it fails if the status code does not match. To wait, you need to use retries and until. Simply registering the result and using wait_for does not work because wait_for is for files or ports, not HTTP responses.
- ✗
Use the pause module to wait for a fixed amount of time after updating each node.
Why it's wrong here
The pause module simply delays execution for a specified duration, regardless of the application's actual state. This is unreliable because the application might take longer to become healthy, or it might already be healthy, causing unnecessary delays. It does not verify the health endpoint.
- ✓
Use the uri module with retries and until to repeatedly check the endpoint until it returns HTTP 200.
Why this is correct
The uri module can be used with retries and until to poll the health endpoint until it returns the desired status code. This ensures that the playbook waits for the application to become healthy before proceeding to the next host, which is essential for a safe rolling update.
Go deeper
Related to this question
About these practice questions
One of 392 original EX294 practice questions on Courseiva, each with a full explanation and wrong-answer analysis — not exam dumps or protected exam content. Learn why practice questions differ from exam dumps →
JA
Written and reviewed by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
Last reviewed September 2026 · checked against the official Red Hat exam blueprint
This EX294 practice question is part of Courseiva's free Red Hat certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the EX294 exam.