Free AWS SOA-C03 Actual Exam Questions - Question 8 Discussion
A company uses an Amazon Simple Queue Service (Amazon SQS) queue and Amazon EC2 instances
in an Auto Scaling group with target tracking for a web application. The company collects the
ASGAverageNetworkIn metric but notices that instances do not scale fast enough during peak traffic.
There are a large number of SQS messages accumulating in the queue.
A CloudOps engineer must reduce the number of SQS messages during peak periods.
Which solution will meet this requirement?
I’m thinking that option C might help since step scaling reacts more dynamically to changes in load by adjusting capacity in steps, which could speed up scaling when the queue backlog spikes. Target tracking can be a bit slow because it tries to maintain a steady state, but step scaling can respond in bigger jumps. But I wonder if that alone is enough without focusing on the right metric to trigger the scaling. Anyone know if changing to step scaling alone will really reduce the message buildup faster?
A The ApproximateNumberOfMessagesDelayed metric focuses on delayed messages, which might better reflect the queue’s buildup than network traffic. Using it in target tracking could trigger faster scaling during peaks.
Probably B makes the most sense here. Using metric math to calculate the backlog per instance directly ties the scaling to the actual queue size, which should trigger faster scaling when messages pile up. The current metric (ASGAverageNetworkIn) isn’t really reflecting the queue pressure.
Options C and D focus on step or simple scaling, but those rely on predefined thresholds and won’t react instantly to sudden queue build-ups. And A suggests a delayed messages metric, which might not represent the real backlog causing the lag. So B feels like the best shot to improve responsiveness.
A imo seems less direct since ApproximateNumberOfMessagesDelayed only tracks delayed messages, not total backlog, so it might miss the real load causing slow scaling.
B Using metric math to measure queue backlog per instance seems like a solid way to tie scaling directly to workload, which should help with faster scaling during spikes. Definitely more targeted than just network traffic.
B Using metric math to calculate queue backlog per instance sounds more precise for scaling than just raw network in; it should help the ASG respond quicker to actual message load.
Good point about targeting the backlog directly. I think B is better because it adjusts scaling based on actual queue length per instance, which should react faster than delayed message metrics alone. B
B/C? Using metric math (B) to figure out queue backlog per instance seems like it could fine-tune scaling better than just simple or step scaling alone (C/D), which might just increase capacity without directly addressing queue size.
A, since delayed messages indicate queue hold-ups causing slow scale-up response.
A/B? A looks good since delayed messages directly show queue hold-ups, which might cause slow scaling. But B’s approach with metric math to break down backlog per instance could give a more precise trigger for scaling, especially if ASGAverageNetworkIn isn't reflecting the real workload. Step scaling (C) might speed things up but won’t fix the root measurement issue. Simple scaling (D) feels too basic here since it doesn’t adapt well to sudden load spikes. So between A and B, I’d say B’s method seems more aligned with directly managing the queue backlog causing the lag.
B/C since backlog per instance directly links load to scaling speed, more precise than delayed msgs.
A imo, focusing on delayed messages targets the real queue bottleneck causing slow scaling.
Option C could work better here since step scaling reacts faster to sudden traffic spikes by increasing capacity in bigger steps, reducing the backlog quicker than target tracking alone.
C might help trigger scaling faster by changing capacity based on load jumps.
B imo, using metric math to get the backlog per instance seems more precise for scaling decisions compared to just delayed messages. It could help scale out faster during high load.
Good point on metric math possibly causing delays. I think option A could work better since ApproximateNumberOfMessagesDelayed directly reflects how many messages are waiting, potentially triggering scale-out faster. A
C imo, step scaling reacts more quickly to sudden changes since it adjusts capacity in response to specific thresholds instead of waiting for target tracking to stabilize like B might.
B seems like the solid pick here. Using metric math to calculate the backlog per instance aligns scaling directly with the actual queue pressure, so instances should spin up faster to handle the load. A focuses on delayed messages, which might not reflect the real-time surge causing the backlog. Step or simple scaling (C and D) don't inherently tie scaling to queue size, so might be slower or less precise during spikes.
Does step scaling (C) react faster than target tracking for sudden spikes?
B vs A: B uses backlog per instance, which feels more precise for scaling than just delayed messages.