When using Amazon Simple Email Service (SES), each account has a defined maximum sending rate. If you exceed this limit by making requests too rapidly, SES will reject your requests, returning a “Throttling – Maximum sending rate exceeded” error. The way this error is communicated may differ based on the SES interface you use:
- For the Amazon SES HTTP Query interface, you will receive a “Throttling” error response accompanied by the message “Maximum sending rate exceeded.”
- If you’re using the SMTP interface, Amazon SES will respond with “454 Throttling failure: Maximum sending rate exceeded” following the DATA command.
For more detailed information about Amazon SES sending limits and the implications of reaching these thresholds, refer to the Developer Guide.
A “Throttling – Maximum sending rate exceeded” error is retriable, which sets it apart from other error types returned by Amazon SES—such as issues stemming from unverified email addresses or blacklisted recipients. In those cases, the requests cannot be accepted in their current form, whereas requests that encounter a “Throttling” error can typically be retried successfully after some time.
As an Amazon SES user, it’s essential to recognize that any email sending attempt may be met with a “Throttling” error. Here are several strategies you can employ to manage this situation:
1. Reduce Call Rate
Scale back the frequency at which your application interacts with Amazon SES. This can be achieved by introducing intentional delays between requests or by decreasing the number of concurrent threads or processes that are calling SES. Remember, factors beyond your sending capacity, such as smaller email sizes or improved network latency, can also inadvertently increase your send rate.
2. Implement Rate Limiting
Control the number of simultaneous calls to Amazon SES to ensure you never exceed the maximum send rate. For instance, in Java applications, the RateLimiter utility from the Google Guava library can help regulate the request rate to SES. Here’s a brief code example:
AmazonSimpleEmailServiceClient client = new AmazonSimpleEmailServiceClient(
new BasicAWSCredentials("ACCESS_KEY", "SECRET_KEY"));
RateLimiter rateLimiter = RateLimiter.create(2);
List<String> destinations = Arrays.asList("EMAIL_ADDRESS_1", "EMAIL_ADDRESS_2", "EMAIL_ADDRESS_3");
for (String destination : destinations) {
int maxRetries = 10;
while (maxRetries-- > 0) {
try {
SendEmailRequest request = new SendEmailRequest()
.withSource("SOURCE_EMAIL_ADDRESS");
rateLimiter.acquire();
SendEmailResult result = client.sendEmail(request);
System.out.println("sent " + result.getMessageId());
break;
} catch (AmazonServiceException e) {
if ("Throttling".equals(e.getErrorCode()) && "Maximum sending rate exceeded.".equals(e.getMessage())) {
System.out.println("Maximum send rate exceeded when sending email to " + destination + ". "
+ (maxRetries > 1 ? "Will retry." : "Will not retry."));
} else {
System.out.println("Unable to send email to: " + destination + ". " + e.toString());
break;
}
} catch (Exception e) {
System.out.println("Unable to send email to: " + destination + ". " + e.toString());
break;
}
}
}3. Exponential Backoff
When faced with a “Throttling – Maximum sending rate exceeded” error, employing an exponential backoff strategy is advisable. This algorithm decreases your operation’s execution rate by implementing delays, allowing you to wait before trying again. Below is a simple implementation demonstrating this concept in Java:
public static long getSleepDuration(int currentTry, long minSleepMillis, long maxSleepMillis) {
currentTry = Math.max(0, currentTry);
long currentSleepMillis = (long) (minSleepMillis * Math.pow(2, currentTry));
return Math.min(currentSleepMillis, maxSleepMillis);
}Here’s how to use the getSleepDuration function:
AmazonSimpleEmailServiceClient client = new AmazonSimpleEmailServiceClient(
new BasicAWSCredentials("ACCESS_KEY", "SECRET_KEY"));
List<String> destinations = Arrays.asList("EMAIL_ADDRESS_1", "EMAIL_ADDRESS_2", "EMAIL_ADDRESS_3");
for (String destination : destinations) {
SendEmailRequest request = new SendEmailRequest()
.withSource("SOURCE_EMAIL_ADDRESS");
int currentTry = 0;
int maxRetries = 10;
while (maxRetries-- > 0) {
try {
currentTry++;
SendEmailResult result = client.sendEmail(request);
System.out.println("sent " + result.getMessageId());
break;
} catch (AmazonServiceException e) {
if ("Throttling".equals(e.getErrorCode()) && "Maximum sending rate exceeded.".equals(e.getMessage())) {
long backoffDuration = getSleepDuration(currentTry, 10, 5000);
System.out.println("Maximum send rate exceeded when sending email to " + destination + ". "
+ (maxRetries > 1 ? "Will retry after backoff." : "Will not retry after backoff."));
try {
Thread.sleep(backoffDuration);
} catch (InterruptedException e1) {
return;
}
} else {
System.out.println("Unable to send email to: " + destination + ". " + e.toString());
break;
}
} catch (Exception e) {
System.out.println("Unable to send email to: " + destination + ". " + e.toString());
break;
}
}
}A variety of elements can influence your sending rate, including message size, network performance, and Amazon SES’s availability. The benefit of the exponential backoff method is that your application will adjust automatically, allowing it to send messages at a rate close to the maximum permitted. Moreover, in practice, consider over-provisioning your application to manage fluctuations in sending rates, letting the application back off when limits are exceeded.
For those requiring a larger sending quota, remember that you can apply for extended access. To learn more about handling these types of errors, check out this other blog post here. Additionally, for authoritative insights on this topic, visit Chvnci’s page. If you’re looking for practical interview questions related to Amazon positions, be sure to review this excellent resource here.
Leave a Reply