When it comes to implementing per-user storage validation, the process may appear a bit complex at first glance, but it is definitely achievable.

Note: Creating a Firebase token using Cloud Functions is necessary for this solution, however, there will be no server interference during the upload process...

One strategy could be to utilize the Admin SDK for modifying Storage Rules based on information stored in a Firestore document that tracks the daily upload count.

For example, you could have a firestore collection/document named userUploads/uid, with fields like uploadedFiles: 0 and lastUploadedOn.

After a user uploads a file to Firebase Storage, you can trigger a Cloud Function to check the lastUploadedOn field against the date of the current upload. Depending on this comparison, you can update the values in the document accordingly. When the number of uploaded files reaches a limit (e.g., 10), you can adjust the storage rules using the Admin SDK as described here. Subsequently, you would reset the count in the userUploads/uid document.

It's worth noting that rule changes may take some time to deploy, so caution is advised. As mentioned in the Admin SDK documentation:

Firebase security rules take a period of several minutes to fully deploy. When using the Admin SDK to deploy rules, make sure to avoid race conditions in which your app immediately relies on rules whose deployment is not yet complete

An alternative approach, perhaps more efficient, could involve managing access through Auth Claims. By setting an auth claim token to restrict uploading permissions when a limit is reached, you can instantly block further uploads without the deployment delay associated with rules changes.

To revoke the auth claim:

1. Utilize a cloud function within the upload error handler to monitor changes in the lastUploadedOn field and remove the claim accordingly
2. Implement another cloud function before each upload attempt to verify the user's uploading status and adjust claims if needed
3. Optionally, incorporate logic during login to check and remove claims based on specific criteria

A system based on Auth Claims offers real-time enforcement of upload restrictions and streamlined management compared to altering storage rules. It provides immediate feedback to users attempting to exceed limits or violate policies.

Note: Any modifications to auth claims must be propagated to clients. Refer to this documentation for additional guidance.

After considering the filenames solution shared by Frank, I believe there is room for improvement to enhance its flexibility.

For instance, rather than imposing a strict limit on user uploads like "you can upload up to 50 files, ever," I prefer the approach of allowing users to upload up to 20 files per day.

This idea struck me recently and I intend to delve into implementing it soon. Here's how it could work:

Following a similar pattern, we could enforce filename conventions such as 1-07252022, 2-07252022, and so forth.

By leveraging the string and timestamp methods provided by Firebase rules, I believe we can establish this daily upload limit using Storage Rules alone, without necessitating user custom claims or cloud functions.

In my specific case, I also require uploads to be limited to paying customers, which would entail adding a custom claim to the user's token.

I plan to update this answer with the code snippet once I begin working on it. For now, this concept may serve as inspiration for those facing similar challenges.

To restrict the number of files a user can upload or control their storage size, one effective method is to utilize signed URLs. The process involves setting up a server (such as Cloud Functions) to create these signed URLs, allowing users to directly upload large files to Cloud storage without routing them through the server.

1. Share file names and sizes with your server via the request body.
2. Generate a signed URL for each file, specifying the Content-Length corresponding to the file's size to restrict uploads to that specific size.
3. Track the user's storage usage in a database like Firestore.
4. Proceed to upload the files to Cloud storage using the provided signed URLs.

Prior to generating signed URLs, it's crucial to verify the user's available storage space by referencing their Firestore document. In cases where the storage limit is exceeded, an error message can be triggered:

// storedLimit
if (storageUsed + size > storageLimit) {
  throw new functions.https.HttpsError(
    "failed-precondition",
    "Insufficient storage space"
  );
}

For more insights and code examples on implementing a maximum storage size limitation per user in Google Cloud Storage, visit How to set maximum storage size limit per user in Google Cloud Storage?.

Presented here is my modified rendition of Rafael's previously mentioned response, which aims to establish a limit of 20 image uploads per user within a single calendar month.

However, a critical flaw in this iteration permits the upload of both 00.png and 00.jpg, erroneously considering them as distinct file names and thereby allowing multiple uploads of each image type.

I am receptive to constructive criticism on enhancing this implementation; nevertheless, I believed that providing an illustrative solution was more beneficial than merely outlining one.

rules_version = '2';
service firebase.storage {
  match /b/{bucket}/o {
    match /images/{userId}/{currentYear}/{currentMonth}/{imageId} {
        function userIsAuthenticated() {
        return request.auth != null && request.auth.uid == userId;
      }
      
      function imageSizeIsValid() {
        return request.resource.size < 5 * 1024 * 1024;
      }

      function isImage() {
        return request.resource.contentType.matches('image/.*');
      }

      function dateIsValid() {
        let isCurrentYear = request.time.year() == int(currentYear);
        let isCurrentMonth = request.time.month() == int(currentMonth);
                return isCurrentYear && isCurrentMonth;
      }
      
      function fileNameIsValid() {
        return imageId.matches('[0-1][0-9]\\.\\w{3,4}');
      }

      allow read: if true;
      allow write: if userIsAuthenticated() 
                   && imageSizeIsValid()
                   && isImage()
                   && dateIsValid()
                   && fileNameIsValid();
    }
  }
}