AWS S3 Data Consistency Model

• S3 Data Consistency provides strong read-after-write consistency for PUT and DELETE requests of objects in the S3 bucket in all AWS Regions
• This behavior applies to both writes to new objects as well as PUT requests that overwrite existing objects and DELETE requests.
• Read operations on S3 Select, S3 ACLs, S3 Object Tags, and object metadata (for example, the HEAD object) are strongly consistent.
• Updates to a single key are atomic. for e.g., if you PUT to an existing key, a subsequent read might return the old data or the updated data, but it will never write corrupted or partial data.
• S3 achieves high availability by replicating data across multiple servers within Amazon’s data centers. If a PUT request is successful, the data is safely stored. Any read (GET or LIST request) that is initiated following the receipt of a successful PUT response will return the data written by the PUT request.
• S3 Data Consistency behavior examples
  • A process writes a new object to S3 and immediately lists keys within its bucket. The new object appears in the list.
  • A process replaces an existing object and immediately tries to read it. S3 returns the new data.
  • A process deletes an existing object and immediately tries to read it. S3 does not return any data because the object has been deleted.
  • A process deletes an existing object and immediately lists keys within its bucket. The object does not appear in the listing.
• S3 does not currently support object locking for concurrent writes. for e.g. If two PUT requests are simultaneously made to the same key, the request with the latest timestamp wins. If this is an issue, you will need to build an object-locking mechanism into your application.
• Updates are key-based; there is no way to make atomic updates across keys. for e.g, an update of one key cannot be dependent on the update of another key unless you design this functionality into the application.
• S3 Object Lock is different as it allows to store objects using a write-once-read-many (WORM) model, which prevents an object from being deleted or overwritten for a fixed amount of time or indefinitely.
• S3 provides strong Read-after-Write consistency for PUTS of new objects
  • For a PUT request, S3 synchronously stores data across multiple facilities before returning SUCCESS
  • A process writes a new object to S3 and will be immediately able to read the Object i.e. PUT 200 -> GET 200
  • A process writes a new object to S3 and immediately lists keys within its bucket. Until the change is fully propagated, the object might not appear in the list.
  • However, if a HEAD or GET request to a key name is made before the object is created, then create the object shortly after that, a subsequent GET might not return the object due to eventual consistency. i.e. GET 404 -> PUT 200 -> GET 404
• S3 provides Eventual Consistency for overwrite PUTS and DELETES in all regions.
  • For updates and deletes to Objects, the changes are eventually reflected and not available immediately i.e. PUT 200 -> PUT 200 -> GET 200 (might be older version) OR DELETE 200 -> GET 200
  • if a process replaces an existing object and immediately attempts to read it, S3 might return the prior data till the change is fully propagated
  • if a process deletes an existing object and immediately attempts to read it, S3 might return the deleted data until the deletion is fully propagated
  • if a process deletes an existing object and immediately lists keys within its bucket. Until the deletion is fully propagated, S3 might list the deleted object.

AWS Certification Exam Practice Questions

• Questions are collected from Internet and the answers are marked as per my knowledge and understanding (which might differ with yours).
• AWS services are updated everyday and both the answers and questions might be outdated soon, so research accordingly.
• AWS exam questions are not updated to keep up the pace with AWS updates, so even if the underlying feature has changed the question might not be updated
• Open to further feedback, discussion and correction.

1. Which of the following are valid statements about Amazon S3? Choose 2 answers
   1. S3 provides read-after-write consistency for any type of PUT or DELETE. (S3 now provides strong read-after-write consistency)
      
   2. Consistency is not guaranteed for any type of PUT or DELETE.
   3. A successful response to a PUT request only occurs when a complete object is saved
   4. Partially saved objects are immediately readable with a GET after an overwrite PUT.
   5. S3 provides eventual consistency for overwrite PUTS and DELETES
2. A customer is leveraging Amazon Simple Storage Service in eu-west-1 to store static content for web-based property. The customer is storing objects using the Standard Storage class. Where are the customers’ objects replicated?
   1. Single facility in eu-west-1 and a single facility in eu-central-1
   2. Single facility in eu-west-1 and a single facility in us-east-1
   3. Multiple facilities in eu-west-1
   4. A single facility in eu-west-1
3. A user has an S3 object in the US Standard region with the content “color=red”. The user updates the object with the content as “color=”white”. If the user tries to read the value 1 minute after it was uploaded, what will S3 return?
   1. It will return “color=white” (strong read-after-write consistency)
   2. It will return “color=red”
   3. It will return an error saying that the object was not found
   4. It may return either “color=red” or “color=white” i.e. any of the value (Eventual Consistency)

References

AWS_S3_Data_Consistency