rate-limit | General purpose rate limiter implementation | Identity Management library

That's a lot of questions in one question, you'll get a high level answer.

DynamoDB scales by increasing the number of partitions. Each item is stored on a partition. Each partition can handle:

• up to 3000 Read Capacity Units
• up to 1000 Write Capacity Units
• up to 10 GB of data

As soon as any of these limits is reached, the partition is split into two and the items are redistributed. This happens until there is sufficient capacity available to meet demand. You don't control how that happens, it's a managed service that does this in the background.

The number of partitions only ever grows.

Based on this information we can address your questions:

1. Does intensive writing affects reading in the case of on-demand tables? Does autoscaling work independently for reading/writing?

   The scaling mechanism is the same for read and write activity, but the scaling point differs as mentioned above. In an on-demand table AutoScaling is not involved, that's only for tables with provisioned throughput. You shouldn't notice an impact on your reads here.

2. Is it fine to set large throughput for a short period of time? As far as I see the cost is the same in the case of on-demand tables. What are the potential issues?

   I assume you set the throughput that spark can use as a budget for writing, it won't have that much of an impact on on-demand tables. It's information, it can use internally to decide how much parallelization is possible.

3. I observe some throttled requests but eventually, all the data is successfully uploaded. How can this be explained? I suggest that the client I use has advanced rate-limiting logic and I didn't manage to find a clear answer so far.

   If the client uses BatchWriteItem, it will get a list of items that couldn't be written for each request and can enqueue them again. Exponential backoff may be involved but that is an implementation detail. It's not magic, you just have to keep track of which items you've successfully written and enqueue those that you haven't again until the "to-write" queue is empty.

Trace your request with Fiddler, also client side client credentials is not supported by Okta from browser, has to be at server level. Check this - https://support.okta.com/help/s/article/Browser-requests-to-the-token-endpoint-must-use-Proof-Key-for-Code-Exchange?language=en_US

The reason I said to trace with Fiddler is so that you can confirm if origin header is being sent or not when using postman vs from ajax and therefore, confirm that you are running into the issue mentioned in the link I pasted.

Docker Hub limits the number of Docker image downloads (“pulls”) based on the account type of the user pulling the image. Pull rates limits are based on individual IP address. For anonymous users, the rate limit is set to 100 pulls per 6 hours per IP address. For authenticated users, it is 200 pulls per 6 hour period. There are no limits for users with a paid Docker subscription.

Docker Pro and Docker Team accounts enable 5,000 pulls in a 24 hour period from Docker Hub.

Please read:

• https://docs.docker.com/docker-hub/download-rate-limit/#:~:text=Docker%20Hub%20limits%20the%20number,pulls%20per%206%20hour%20period.
• https://www.docker.com/increase-rate-limits

I would propose to take a look in the RateLimiter direction. Maybe it does not work as expected, depending on the number of requests your application does over time. From the Javadoc for Ratelimiter: "It is important to note that the number of permits requested never affects the throttling of the request itself ... but it affects the throttling of the next request. I.e., if an expensive task arrives at an idle RateLimiter, it will be granted immediately, but it is the next request that will experience extra throttling, thus paying for the cost of the expensive task." Also helpful might be this discussion: github or github

I could imaginge there is some throttling adding up or other effect in the RateLimiter, i would try to play around with it and make sure this thing really works the way you want. Alternatively, consider using Spring @Scheduled to read from your queue. You might want to spice it up using embedded JMS for further goodies (message persistence etc).

1.The subscription key based approach is below.

You can define a subscription key on each of the environmen. In the below example i am creating a subscrption named dev on dev environment and prod on prod environment. You can check this link to understand how to create a subscription key. Once you creaete subscription keys on all three environment. You can add the following policy to your inbound policies.

That composer.json file is a bit of a mess. Some Symfony packages on 5.3, some even on 5.1, and many on 6.

Also you are controlling Symfony versioning from extra.symfony.require, and at the same time from the discrete version constraints. You include some packages that no longer exist on 6.0 (symfony/security-guard), and are missing some that should be installed on a 6.0 version.

It's simply not on an installable state.

I've managed to make it installable changing it like this:

If I'm understanding your requirements then something like this will work. It effectively combines the iter unordered with a channel to allow a mapping instead.

I just solve this issue by correcting the RxJS version to 7.4.0. I hope this can solve others issue as well.

You can use