AWS S3对象软删除实现方案及最佳实践（支持控制台/.Net SDK）

Awesome question! Implementing soft delete for AWS S3 objects using versioning and tags is a really practical approach—let’s walk through exactly how to make this work, including step-by-step guides for both the AWS Console and .NET SDK, plus some best practices to keep things running smoothly.

The core idea here is to avoid permanently deleting objects immediately. Instead, we mark them as "deleted" while retaining their versions for potential recovery later. Here's the breakdown:

• Enable Version Control: Ensures that deleting an object doesn’t erase it entirely—instead, S3 creates a delete marker or preserves the existing version.
• Use Custom Tags: Add a tag (like IsDeleted=true) to flag objects as soft-deleted, making it easy to filter and manage them later.
• Post-Soft-Delete Workflows: Restore objects by updating their tags, or permanently clean up marked objects when they’re no longer needed.

1. Enable Bucket Versioning #

• Open the S3 Console, navigate to your target bucket.
• Go to the Properties tab, scroll down to the Versioning section.
• Select Enable and save your changes.

2. Perform Soft Delete (Tag Objects) #

• Navigate to the Objects tab of your bucket, find the object you want to soft-delete.
• Check the box next to the object, click Actions → Add tags.
• Add a key-value pair: Key: IsDeleted, Value: true, then save.
• Optional: To hide soft-deleted objects from regular views, you can use bucket policies or lifecycle rules to filter out objects with this tag.

3. Restore Soft-Deleted Objects #

• Locate the tagged object, click Actions → Edit tags.
• Update the IsDeleted value to false or remove the tag entirely.

4. Permanently Clean Up Soft-Deleted Objects #

• Use the Filter option to search for objects with IsDeleted=true.
• Select the objects, click Actions → Delete.
• If you want to fully erase all versions of the object, switch to the Versions view, select all versions and delete markers, then delete them.

First, make sure you have the AWSSDK.S3 NuGet package installed in your project.

1. Initialize the S3 Client #

using Amazon.S3;
using Amazon.S3.Model;

// Initialize with default credentials (or pass custom credentials if needed)
var s3Client = new AmazonS3Client();

2. Enable Bucket Versioning #

var enableVersioningRequest = new PutBucketVersioningRequest
{
    BucketName = "your-bucket-name",
    VersioningConfig = new VersioningConfig { Status = VersionStatus.Enabled }
};

await s3Client.PutBucketVersioningAsync(enableVersioningRequest);

3. Execute Soft Delete (Add Tag) #

⚠️ Note: If the object already has existing tags, you need to include them in the TagSet—otherwise, this will replace all existing tags.

var putTaggingRequest = new PutObjectTaggingRequest
{
    BucketName = "your-bucket-name",
    Key = "your-object-key",
    Tagging = new Tagging
    {
        TagSet = new List<Tag>
        {
            new Tag { Key = "IsDeleted", Value = "true" },
            // Add any existing tags here if you want to retain them
        }
    }
};

await s3Client.PutObjectTaggingAsync(putTaggingRequest);

4. Restore a Soft-Deleted Object #

var restoreTaggingRequest = new PutObjectTaggingRequest
{
    BucketName = "your-bucket-name",
    Key = "your-object-key",
    Tagging = new Tagging
    {
        TagSet = new List<Tag>
        {
            new Tag { Key = "IsDeleted", Value = "false" },
            // Keep existing tags here to avoid overwriting
        }
    }
};

await s3Client.PutObjectTaggingAsync(restoreTaggingRequest);

5. Filter Soft-Deleted Objects #

var listObjectsRequest = new ListObjectsV2Request
{
    BucketName = "your-bucket-name",
    TaggingFilter = new TaggingFilter
    {
        TagSet = new List<Tag>
        {
            new Tag { Key = "IsDeleted", Value = "true" }
        }
    }
};

var response = await s3Client.ListObjectsV2Async(listObjectsRequest);
foreach (var obj in response.S3Objects)
{
    Console.WriteLine($"Soft-deleted object found: {obj.Key}");
}

6. Permanently Delete Soft-Deleted Objects #

// First, get all versions and delete markers for the object
var listVersionsRequest = new ListVersionsRequest
{
    BucketName = "your-bucket-name",
    Prefix = "your-object-key" // Use this to target specific objects, or loop through filtered objects
};

var versionsResponse = await s3Client.ListVersionsAsync(listVersionsRequest);

// Delete all object versions
foreach (var version in versionsResponse.Versions)
{
    var deleteRequest = new DeleteObjectRequest
    {
        BucketName = "your-bucket-name",
        Key = version.Key,
        VersionId = version.VersionId
    };
    await s3Client.DeleteObjectAsync(deleteRequest);
}

// Delete any existing delete markers
foreach (var marker in versionsResponse.DeleteMarkers)
{
    var deleteMarkerRequest = new DeleteObjectRequest
    {
        BucketName = "your-bucket-name",
        Key = marker.Key,
        VersionId = marker.VersionId
    };
    await s3Client.DeleteObjectAsync(deleteMarkerRequest);
}

• Standardize Tag Naming: Stick to a consistent tag key (like IsDeleted) and values (true/false) to avoid confusion across your team.
• Lifecycle Rules for Cost Savings: Set up S3 lifecycle rules to automatically move soft-deleted objects to Glacier (for cheaper long-term storage) or permanently delete them after a set retention period.
• Restrict Tag Modification Permissions: Use IAM policies to limit who can add/modify the IsDeleted tag—only allow authorized roles to perform soft delete/restore actions to prevent accidental changes.
• Manage Versioning Costs: Versioning increases storage usage, so regularly archive or delete old versions that aren’t needed for recovery.
• Audit and Monitor: Enable S3 access logs to track all soft delete/restore operations, which helps with compliance and troubleshooting.
• Be Cautious with Delete Markers: Don’t delete delete markers unless you’re certain you won’t need to restore the original object version.

内容的提问来源于stack exchange，提问作者Enes Ays.