# MinIO Server Limits Per Tenant

For optimal production setup MinIO recommends Linux kernel version 4.x and later.

## Erasure Code (Multiple Drives / Servers)

| Item                                                            | Specification |
|:----------------------------------------------------------------|:--------------|
| Maximum number of servers per cluster                           | no-limit      |

        // When both are enabled, batch limits should be available
        int limit = config.getBatchLimit("TreeConnectAndX.QueryInformation");
        assertTrue(limit >= 0, "Batch limit should be non-negative when Unicode and batching enabled");
    }

    /**
     * Test configuration when batching is disabled
     */
    @Test
    @DisplayName("Batch limit configuration with batching disabled")

        .build(),
    )
    val call = client.newCall(Request(url = server.url("/")))
    assertFailsWith<IOException> {
      call.execute()
    }
  }

  /** Use a header that exceeds the limits on its own. */
  @Test
  fun largeResponseHeader() {
    server.enqueue(
      MockResponse
        .Builder()
        .addHeader("Set-Cookie", "a=${"A".repeat(256 * 1024)}")

		return 0
	}
	if limit >= 100*humanize.TiByte {
		// No limit set, or unreasonably high. Ignore
		return 0
	}
	return limit
}

func availableMemory() (available uint64) {
	available = 2048 * blockSizeV2 * 2 // Default to 4 GiB when we can't find the limits.

	if runtime.GOOS == "linux" {
		// Honor cgroup limits if set.
		limit := cgroupMemLimit()
		if limit > 0 {

    }

    /**
     * Set the key rotation bytes limit
     *
     * @param limit number of bytes to encrypt before rotating keys
     */
    public void setKeyRotationBytesLimit(long limit) {
        this.keyRotationBytesLimit = limit;
    }

    /**
     * Set the key rotation time limit
     *
     * @param limit time in milliseconds before rotating keys
     */

// This will ensure that at most n bytes are returned and EOF is reached.
func HardLimitReader(r io.Reader, n int64) io.Reader { return &HardLimitedReader{r, n} }

// A HardLimitedReader reads from R but limits the amount of
// data returned to just N bytes. Each call to Read
// updates N to reflect the new amount remaining.
// Read returns EOF when N <= 0 or when the underlying R returns EOF.
type HardLimitedReader struct {

import java.lang.annotation.Target;

import org.codelibs.core.lang.StringUtil;

import jakarta.validation.Constraint;
import jakarta.validation.Payload;

/**
 * Validation constraint for custom size limits based on configuration keys.
 */
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = CustomSizeValidator.class)
public @interface CustomSize {

Go 1.25 added a new `containermaxprocs` setting that controls whether the Go
runtime will consider cgroup CPU limits when setting the default GOMAXPROCS.
The default value `containermaxprocs=1` will use cgroup limits in addition to
the total logical CPU count and CPU affinity. `containermaxprocs=0` will
disable consideration of cgroup limits. This setting only affects Linux.

Go 1.25 added a new `updatemaxprocs` setting that controls whether the Go

        // Make many attempts to trigger global rate limit
        for (int i = 1; i <= 20; i++) {
            assertTrue(rateLimiter.checkAttempt("user" + i, "192.168.1." + i), "Attempt " + i + " should be allowed");
        }

        // 21st attempt should be blocked by global rate limit
        assertFalse(rateLimiter.checkAttempt("user21", "192.168.1.21"), "Should block after global rate limit");
    }

    @Test

            return "Free up disk space or use a different location";
        case QUOTA:
            return "Contact administrator to increase quota limits";
        case LOCK:
            return "Release existing locks or wait for them to be released";
        case BUFFER:
            return "Reduce buffer usage or increase buffer pool size";
        case THREAD_POOL:
            return "Reduce concurrent operations or increase thread pool size";