MINIO Provider
The MINIO provider uses MinIO, a high-performance S3-compatible object storage system, for storing files. MinIO is ideal for cluster deployments where multiple webPDF Server nodes need to share file storage.
Overview
- Provider Name:
MINIO - Supports: File Storage only
- Configuration File:
provider-minio.yaml - Use Case: Cluster deployments, scalable file storage, S3-compatible storage
- Protocol: S3 API compatible
Features
- ✓ S3-compatible API
- ✓ High-performance object storage
- ✓ Cluster-ready with shared file access
- ✓ Scalable and distributed
- ✓ Support for versioning and encryption
- ✓ Multi-tenant with bucket isolation
- ✓ ETag-based local caching for improved performance
- ✓ Automatic retry with exponential backoff
- ✓ Batch deletion for efficient cleanup
- ✓ Configurable connection pooling
- ✓ Event Manager support for notifications
- ✗ Requires external MinIO server or S3-compatible service
- ✗ Higher latency compared to local filesystem
Prerequisites
- MinIO server or S3-compatible service
- Network connectivity from webPDF Server to MinIO
- MinIO access credentials (access key, secret key)
- Bucket created or automatic bucket creation enabled
Configuration
provider.json
{
"fileStorage": {
"name": "MINIO",
"checks": {
"enabled": true,
"interval": 10000
}
}
}
provider-minio.yaml
Configuration file for MinIO file storage (YAML format):
url: http://minio.example.com:9000
username: minioadmin
password: minioadmin-secret
bucketName: webpdf-files
settings:
region: us-east-1
Configuration Attributes
Required Attributes
| Attribute | Type | Description | Example |
|---|---|---|---|
url | string | MinIO server endpoint URL | http://minio.example.com:9000 |
username | string | MinIO access key | minioadmin |
password | string | MinIO secret key | minioadmin-secret |
Optional Attributes
| Attribute | Type | Description | Default |
|---|---|---|---|
bucketName | string | S3 bucket name for file storage | Auto-generated |
settings | object | Additional MinIO/S3 client settings | {} |
Settings Object
The settings object supports S3 client configuration options:
| Setting | Type | Description | Default |
|---|---|---|---|
region | string | AWS/MinIO region. When neither this setting nor the endpoint specifies a region, the region of the bucket is determined with a GetBucketLocation request (see WEBPDF_MINIO_CLIENT_STREAMING_REGION_CACHE). | - |
Bucket Naming
If bucketName is not specified, or empty in the file, the name of the bucket is the namespace prefix (default webpdf). A configured name always takes precedence.
Example: with the prefix webpdf-prod, the bucket is webpdf-prod.
The derived name does not contain a version and is used by the server only; it is not written into the provider configuration. webPDF stores the objects below the path of its namespace in the bucket, <prefix>/v<main>.<minor>-r<revision>/<sessionId>/<documentId>-<revision>, and reads, changes and deletes only there (see Namespace).
In production, especially on AWS S3, create the bucket in advance and set bucketName to its name. S3 bucket names are unique worldwide, so a derived name such as webpdf may already belong to someone else. Give every installation a prefix of its own and use lifecycle rules of the bucket only with a filter for the prefix (see Existing Buckets and Containers).
Environment Variables
# MinIO file storage
WEBPDF_MINIO_FILE_STORAGE_SETTINGS_URL=http://minio.example.com:9000
WEBPDF_MINIO_FILE_STORAGE_SETTINGS_USERNAME=minioadmin
WEBPDF_MINIO_FILE_STORAGE_SETTINGS_PASSWORD=minioadmin-secret
WEBPDF_MINIO_FILE_STORAGE_SETTINGS_BUCKET_NAME=webpdf-files
Health Checks
Health checks verify connectivity to MinIO and bucket accessibility:
{
"fileStorage": {
"name": "MINIO",
"checks": {
"enabled": true,
"interval": 10000
}
}
}
enabled: Enable health checks (recommended:true)interval: Check interval in milliseconds (recommended:10000-30000)
Health Check Implementation
The health check performs a lightweight connectivity test:
- Bucket Existence Check - Uses a HEAD request to check if the bucket exists
- Connection Validation - Verifies network connectivity to MinIO endpoint
- SSL Validation - Ensures SSL/TLS configuration is correct (for HTTPS endpoints)
What is checked:
- Network connectivity to MinIO service
- Bucket accessibility
- SSL/TLS configuration validity
Health Status Results:
UP- Connection established, bucket accessibleDOWN- Connection failed, bucket not accessible or does not exist, or SSL error
Note: The health check does not create the bucket. A missing bucket is created only once, during storage initialization at startup. If the bucket does not exist later, the health check reports DOWN with the reason Bucket '<name>' does not exist at '<endpoint>'.
Two Separate Status Checks
webPDF evaluates the storage status in two independent ways:
- Continuous status check of the storage client. The server checks the connection to the storage every 5 seconds, regardless of the
checkssetting. The result appears in the server log only. If the bucket does not exist, it reportsDOWNwith the reasonBucket '<name>' does not exist at '<endpoint>', and reportsUPagain once the bucket exists. If the storage does not answer at all (for example because it is paused or unreachable), the status changes toDOWNafter 15 seconds with the reasonHealth check did not answer within 15 seconds; the status line keeps appearing in the server log during the outage. Requests are not affected by this limit: they keep waiting for the retries of the storage client. - Readiness check of the provider. The
checkssection ofprovider.json(enabled, defaultfalse) controls whether the provider reports its status to the readiness endpoint (/health/ready). It is evaluated only whenenabledistrue, and it also reportsDOWNif the bucket does not exist.
Security Considerations
Authentication
MinIO uses access key and secret key authentication:
username: access-key-id
password: secret-access-key
TLS/SSL Configuration
For HTTPS connections:
url: https://minio.example.com:9000
username: access-key
password: secret-key
settings:
region: us-east-1
IAM Policies
Configure MinIO IAM policies for least privilege access. The example below is for a bucket that one installation uses alone; for a bucket that several installations share, see Restricted Access Rights.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject",
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::webpdf-files/*",
"arn:aws:s3:::webpdf-files"
]
}
]
}
s3:GetBucketLocation can be omitted if region is set; without a region, the server does not start with a policy that lacks it (the request GET ?location= is answered with AccessDenied). If the bucket does not exist yet, the access additionally needs s3:CreateBucket. The validation in the Admin Portal does not list the buckets of the account, so s3:ListAllMyBuckets is not needed. It checks only the bucket the node uses: the configured name or, if none is configured, the namespace prefix (see Namespace Configuration). If that bucket exists, the validation succeeds without any further request and needs no permission beyond access to the bucket. Only if the bucket does not exist does it check the permission to create it, with a probe bucket named <bucket>-probe-<8 characters> that it removes again; this needs s3:CreateBucket and s3:DeleteBucket on arn:aws:s3:::<bucket>-probe-*. The live bucket is never created or deleted by the validation. If the probe bucket cannot be created or removed, the validation reports an error.
Never store MinIO credentials in configuration files. Use environment variables or secure configuration management.
Bucket Management
Automatic Bucket Creation
If the specified bucket doesn't exist, webPDF will attempt to create it automatically during storage initialization. The bucket name is automatically converted to lowercase and trimmed. If the access has no permission to create buckets (s3:CreateBucket) and the bucket does not exist, the storage answers AccessDenied, and the start fails at once with a file storage error instead of retrying; create the bucket externally or grant the permission, then restart the node. Other failed requests are still retried as described under Automatic Retry Policy.
An existing bucket is used as it is, whatever it holds; webPDF works only below the path of its namespace and never deletes the bucket. See Existing Buckets and Containers; give every installation a prefix of its own.
Bucket Naming Rules:
- Must be lowercase (automatically converted)
- Can contain letters, numbers, and hyphens
- Must be between 3 and 63 characters
- Must start and end with a letter or number
- Follows AWS S3 bucket naming rules
Missing Bucket at Runtime
During startup, webPDF creates a missing bucket (see above). While the server is running, it does not create a bucket that has disappeared. The bucket may be managed by the operator with its own settings such as encryption, access policies, or lifecycle rules, and an automatically created replacement would silently lack them.
If the bucket no longer exists while the server is running:
- Requests fail immediately, without retries, with
FILE_STORAGE_STORE_CONTENT(-21003) when storing,FILE_STORAGE_RETRIEVE_CONTENT(-21001) when reading, orFILE_STORAGE_REMOVE_CONTENT(-21002) when removing content. The error description containsThe bucket of the file storage does not exist. - The server log contains an
ERRORline with the bucket name, at most once per minute together with the number of further failures since the last report. - The continuous status check reports
DOWN(see Two Separate Status Checks). - Documents that were stored in the lost bucket are gone. Reading them fails with
-21001.
Create the bucket again with the configured name (for example with mc mb, see below). The nodes resume working without a restart.
Manual Bucket Creation
Using MinIO Client (mc):
mc alias set myminio http://minio.example.com:9000 accesskey secretkey
mc mb myminio/webpdf-files
mc policy set download myminio/webpdf-files
Bucket Lifecycle Policies
Configure lifecycle policies for automatic cleanup:
<LifecycleConfiguration>
<Rule>
<ID>DeleteOldFiles</ID>
<Status>Enabled</Status>
<Expiration>
<Days>30</Days>
</Expiration>
</Rule>
</LifecycleConfiguration>
High Availability
For production deployments:
- Distributed MinIO – Multi-node MinIO cluster with erasure coding
- Load Balancing – Distribute requests across MinIO nodes
- Replication – Site-to-site bucket replication
- Backup – Regular bucket snapshots
Distributed Setup Example
# 4-node distributed MinIO
minio server http://minio{1...4}.example.com/data{1...4}
Performance Tuning
MinIO Server Optimization
# Environment variables
export MINIO_CACHE_SIZE=10GB
export MINIO_CACHE_DRIVES="/mnt/cache1,/mnt/cache2"
Built-in Connection Management
The MinIO provider includes two optimized HTTP client configurations:
Default Client (Standard Operations)
- Connection Pool: 50 connections, 5-minute keep-alive
- Connect Timeout: 5 seconds
- Read/Write Timeout: 10 seconds
- Call Timeout: 15 seconds
- Retry on Failure: Enabled
- Keepalive Ping: 15 seconds (detects and evicts half-open connections; configurable)
- Use Case: Regular file operations (get, put, delete)
Streaming Client (Large File Operations)
- Connection Pool: Isolated (no connection reuse)
- Connect Timeout: 10 seconds
- Read/Write Timeout: 5 minutes
- Call Timeout: 10 minutes
- Retry on Failure: Disabled (handled by retry policy)
- Use Case: Long-running uploads/downloads
- Bucket Region: Determined once and reused when no
regionis configured (WEBPDF_MINIO_CLIENT_STREAMING_REGION_CACHE)
Connection Resilience and Self-Healing
After a short network or storage disruption (for example a load balancer failover, a firewall idle-timeout, or a brief MinIO/S3 outage), pooled HTTP connections can be left in a broken or half-open state. Reusing such connections would otherwise cause every retry to fail on the same poisoned pool, and recovery would require restarting the affected node.
The MinIO provider recovers from these situations automatically:
- Keepalive ping — The default client sends periodic HTTP pings (default 15 seconds). Half-open connections are detected and evicted from the pool instead of being reused under load.
- Connection-pool rebuild on transient failures — When a retry is triggered by a transient transport failure (connection reset, broken pipe, socket timeout, premature end of stream), the client rebuilds its connection pool once before retrying. The next attempt uses fresh connections, so the node recovers without a restart.
- Connection-pool rebuild on TLS trust changes — The same rebuild mechanism applies when the external TLS certificate material changes (see TLS/SSL configuration above).
- Rebuild throttling — A cooldown prevents a rebuild storm when many threads fail at the same time; only one rebuild happens per cooldown window.
After such an event, the server log records a connection refresh (for example Refreshed client state after standard failure ... and Rebuilt MinIO client ...), confirming the self-healing without manual intervention.
A genuine application-level error such as a real Object does not exist (HTTP 404) is not treated as a transient transport failure and does not trigger a pool rebuild.
Client Runtime Settings
These settings tune the MinIO HTTP client behavior. They are configured as webPDF environment settings under the webpdf.minio.client.* namespace and apply across all MinIO operations. The defaults are suitable for most deployments.
| Environment variable | System property | Default | Description |
|---|---|---|---|
WEBPDF_MINIO_CLIENT_PING_INTERVAL | webpdf.minio.client.ping.interval | 15000 | Keepalive ping interval in milliseconds for the default client. A value > 0 enables active probes that detect and evict half-open connections; 0 disables pings. |
WEBPDF_MINIO_CLIENT_FORCED_REFRESH_COOLDOWN | webpdf.minio.client.forced.refresh.cooldown | 5000 | Minimum interval in milliseconds between forced connection-pool rebuilds (transient transport failures and TLS trust changes). Prevents rebuild storms under concurrent failures. |
WEBPDF_MINIO_CLIENT_CERTIFICATE_POLL_INTERVAL | webpdf.minio.client.certificate.poll.interval | 60000 | Polling interval in milliseconds for detecting changes to the external TLS certificate file. |
WEBPDF_MINIO_CLIENT_TLS_CERT_FILE | webpdf.minio.client.tls.cert.file | - | Path to an external certificate file used for TLS trust material. When unset, the JVM truststore is used. |
WEBPDF_MINIO_CLIENT_PART_SIZE | webpdf.minio.client.part.size | 5242880 | Multipart transfer part size in bytes (default 5 MiB) for streaming uploads. |
WEBPDF_MINIO_CLIENT_SHUTDOWN_TIMEOUT | webpdf.minio.client.shutdown.timeout | 20000 | Timeout in milliseconds for releasing client resources during shutdown or a pool rebuild. |
WEBPDF_MINIO_CLIENT_REBUILD_ON_RECOVERY | webpdf.minio.client.rebuild.on.recovery | true | When the periodic health check observes that the storage is reachable again after an outage, the connection pool of the default client is rebuilt once, so that connections broken during the outage are not reused. Throttled by WEBPDF_MINIO_CLIENT_FORCED_REFRESH_COOLDOWN. Set to false to only record the recovery. |
WEBPDF_MINIO_CLIENT_STREAMING_SHARED_EXECUTOR | webpdf.minio.client.streaming.shared.executor | true | Since webPDF 10.0.7. Uploads and downloads share one thread pool per webPDF Server instance instead of starting a thread pool of their own for every transfer, so the number of threads follows the number of concurrent transfers instead of the transfer rate. Each transfer still uses its own connections. Set to false to restore the previous behavior with one thread pool per transfer. Read at startup. |
WEBPDF_MINIO_CLIENT_STREAMING_REGION_CACHE | webpdf.minio.client.streaming.region.cache | true | Since webPDF 10.0.7. Applies only when neither the region setting nor the endpoint specifies a region. The first upload or download determines the region of the bucket, and the following uploads and downloads use it, so that they no longer send an additional GetBucketLocation request to the storage before every transfer. The region is determined again after the connection pool of the default client has been rebuilt and after a transfer has failed with an error that can indicate a wrong region (NoSuchBucket, HTTP 301, 307 or 400). Set to false to restore the previous behavior with one region lookup per transfer. Read at startup. |
In containerized deployments, supply secrets such as the TLS certificate path using the file: resolver (WEBPDF_MINIO_CLIENT_TLS_CERT_FILE=file:/run/secrets/minio_ca), so the value is read from a mounted secret file.
Automatic Retry Policy
Retry configuration for transient failures:
- Max Attempts: 5 retries
- Strategy: Exponential backoff
- Initial Delay: 500ms
- Max Delay: 30 seconds
- Jitter: Enabled (randomized delays)
This handles network hiccups and temporary MinIO unavailability automatically.
File Storage Runtime Settings
These settings tune the file storage retry policy and the upload verification of the MinIO provider. They are configured as webPDF environment settings under the webpdf.minio.file.storage.* namespace and apply across all MinIO file storage operations.
| Environment variable | System property | Default | Description |
|---|---|---|---|
WEBPDF_MINIO_FILE_STORAGE_RETRY_ATTEMPTS | webpdf.minio.file.storage.retry.attempts | 5 | Maximum number of retry attempts for a file storage operation (the "Max Attempts" above). |
WEBPDF_MINIO_FILE_STORAGE_CLEANUP_RETRY_ATTEMPTS | webpdf.minio.file.storage.cleanup.retry.attempts | 2 | Maximum attempts for the short, independent best-effort cleanup that removes an orphaned object after a failed upload (see Operational Notes below). |
WEBPDF_MINIO_FILE_STORAGE_RETRY_MAX_TOTAL_DELAY | webpdf.minio.file.storage.retry.max.total.delay | 0 (unbounded) | Total time budget, in milliseconds, for the sum of the planned wait times between retry attempts of a single storage operation - in addition to the attempt-count limit above, not instead of it. 0 (the default) reproduces today's behavior, where only the attempt count bounds a retry loop. Because the backoff strategy applies jitter, this bounds a range of attempts rather than a fixed number, and it is not a guarantee on the operation's total response time (the loop can still fail its last attempt with a request that itself takes time). A negative value is ignored and falls back to 0. Applies to both the regular upload retry budget and the shorter cleanup budget above. |
WEBPDF_MINIO_FILE_STORAGE_UPLOAD_VERIFICATION | webpdf.minio.file.storage.upload.verification | HEAD | How a freshly uploaded object is confirmed before it is registered. HEAD (default) reproduces the original behavior: a statObject size comparison using the full retry budget above. ETAG verifies against the PutObject response ETag instead of an additional round trip, and falls back to a short-budget statObject probe only when that comparison is inconclusive (a multipart upload, a server-side-encrypted object, or an unavailable MD5 implementation on a FIPS-restricted JVM); such a fallback probe tolerates a transient "object not found yet" response (an S3 eventual-consistency visibility delay) instead of failing the upload, and logs a warning each time. The value is case-insensitive. An unrecognized value keeps the default (HEAD) and is logged as a warning. |
WEBPDF_MINIO_FILE_STORAGE_BATCH_SIZE | webpdf.minio.file.storage.batch.size | 1000 | Number of objects per batch delete request (unchanged). |
WEBPDF_MINIO_FILE_STORAGE_BUFFER_SIZE | webpdf.minio.file.storage.buffer.size | - | Local copy buffer size in bytes (unchanged). |
ETAG mode adds no extra I/O for the common case: the digest of a single-part upload is computed in the same pass as the local copy. Only a multipart upload (larger than the configured part size, 5 MiB by default) reads the freshly written local cache file a second time to compute the comparison digest.
Batch Processing
For efficient bulk operations:
- Batch Size: 1000 objects
- Use Case: Deleting multiple files in a single request
- Benefit: Reduces API calls and improves performance
File Caching
ETag-based caching mechanism:
- Local Cache - Files are cached locally after download
- ETag Validation - ETags and file sizes are compared before re-downloading
- Automatic Invalidation - Cache is updated when ETags don't match or file size differs
- Consistency Check - File size verification ensures complete uploads/downloads
Each node keeps up to 10,000 local copies in its temporary folder; a copy that has not been used for one hour is removed. The limit counts copies, not bytes, so with large documents plan the temporary storage of the node accordingly.
A copy that is being delivered stays readable until the delivery has finished, even if the cache removes it in the meantime; the file is deleted afterwards. A new version of a copy (after an update or a new download) replaces the file as a whole and never changes a file that is being read.
A download of a document that is overwritten continuously on another node is read again for up to 15 seconds. It returns a complete version that was loaded or confirmed after the read began, never a mixed one. Only if the document keeps changing for the whole 15 seconds, the read ends with FILE_STORAGE_RETRIEVE_CONTENT (-21001).
In a cluster, deleting a document or a session removes its local copies on every node, not only on the node that processes the deletion: each node follows the deletion events with its own reader.
| Environment variable | System property | Default | Description |
|---|---|---|---|
WEBPDF_CLUSTER_EVENTS_LOCAL_CACHE_CLEANUP_ENABLED | -Dwebpdf.cluster.events.local.cache.cleanup.enabled | true | false switches the reader off; the local copies of deleted documents then remain until the cache removes them, at the latest after one hour without access. |
Operational Notes
Failed upload verification no longer deletes existing content. When a document is stored without its own revision history (useHistory=false), storing a new version overwrites the object that already holds the document's previous content, at the same storage id. Before the upload the storage id holds the previous content, after it the new content, which is not yet verified. In both cases, removing the object would leave the document record without any content. If the upload verification then fails, the compensating cleanup that removes a leftover object therefore only ever removes a genuinely new object it created itself - never one that overwrote existing content. Storing a document with revision history is unaffected: such a store always creates a genuinely new object, which remains eligible for cleanup on failure.
Overwriting a document that is deleted at the same time. When the document is deleted - or its session ends - while a new version overwrites its object, the call fails with WEBSERVICE_INVALID_DOCUMENT_ID = -50 and the object it wrote is removed. This also holds when the upload verification HEAD finds the object already removed by the deletion; the call then no longer reports FILE_STORAGE_STORE_CONTENT = -21003.
Empty storage reference on the removal path. remove() (single object) and removeAll() (bulk session/document cleanup) now reject or skip an empty (but non-null) storage id instead of silently treating it as "nothing to do". Previously, on this provider, an empty storage id resolved to a listObjects prefix that matched nothing, so the call completed successfully without actually deleting anything. A direct remove() call with an empty storage id now fails with FILE_STORAGE_EMPTY_STORAGE_ID = -21007 (see Troubleshooting below); removeAll() instead skips such an entry with a warning in the log, so that a single unusable record does not abort the removal of the remaining, valid entries. A null entry in removeAll() is skipped the same way; only a direct remove() call with null still clears the whole bucket.
On the Azure Blob provider, the same empty-storage-id condition previously deleted every object in the configured container - an empty prefix matches every blob there. This is now rejected the same way as described above.
Network Optimization
- Use dedicated network for storage traffic
- Enable jumbo frames (MTU 9000) if supported
- Co-locate webPDF and MinIO in same data center/region
Monitoring
MinIO Metrics
Monitor MinIO health and performance:
# MinIO metrics endpoint
curl http://minio.example.com:9000/minio/v2/metrics/cluster
Key Metrics
- Request rate (GET/PUT operations)
- Response time (latency)
- Bandwidth utilization
- Error rate
- Storage capacity
Troubleshooting
Cannot Connect to MinIO
- Verify MinIO is running:
curl http://minio.example.com:9000/minio/health/live - Check network connectivity
- Verify access credentials
- Check firewall rules (port 9000)
Bucket Not Found
- Verify bucket exists:
mc ls myminio/ - Check bucket name matches configuration
- Verify access permissions
- If the bucket was deleted while the server was running, create it again; a missing bucket is created automatically only at startup (see Missing Bucket at Runtime)
Slow Upload/Download
- Check network bandwidth
- Review MinIO server performance
- Consider distributed MinIO setup
- Check file size - large files automatically use streaming client
- Review retry attempts in logs
Access Denied Errors
- Verify access key and secret key
- Check IAM policy permissions
- Review bucket policies
- Verify bucket ownership
Empty or Invalid Storage Reference
A request that previously failed only after the full retry budget was exhausted, with FILE_STORAGE_RETRIEVE_CONTENT (-21001) on a read or FILE_STORAGE_STORE_CONTENT (-21003) on a write, now fails immediately with FILE_STORAGE_EMPTY_STORAGE_ID (-21007) when the underlying document record has no usable storage reference. This is the same underlying condition surfacing faster and more precisely, not a new class of error - update an integration that branches on the specific error code accordingly.
Records Created Before This Fix
A document record can only lose its storage reference through the failure mode this fix removes: the record was created before its content, and storing the content then failed. Records that were left behind that way before the upgrade are not repaired by it. They live in the cluster document store, not in a server process, so restarting a node does not clear them - the condition persists across restarts and rolling updates.
Such a record is recognisable by FILE_STORAGE_EMPTY_STORAGE_ID (-21007) on every access to the affected
document. On an installation that has not been upgraded yet, the same records instead produce a log line
reading object name must be a non-empty string, repeated once per retry until the retry budget is
exhausted.
There is nothing to repair: the content of these documents was never written. Discard the affected documents, or the sessions that own them; ending a session removes its records together with its objects. No new records of this kind are created after the upgrade.
AWS S3 Compatibility
MinIO provider works with AWS S3 and S3-compatible services:
AWS S3 Configuration
url: https://s3.amazonaws.com
username: AWS_ACCESS_KEY_ID
password: AWS_SECRET_ACCESS_KEY
bucketName: webpdf-files
settings:
region: us-east-1
Examples
Basic MinIO Setup
url: http://192.168.1.100:9000
username: webpdf-user
password: secure-password
bucketName: webpdf-files
MinIO with TLS
url: https://minio.example.com:9000
username: webpdf-user
password: secure-password
bucketName: webpdf-files-prod
settings:
region: us-east-1
AWS S3
url: https://s3.eu-central-1.amazonaws.com
username: AKIAIOSFODNN7EXAMPLE
password: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
bucketName: my-webpdf-bucket
settings:
region: eu-central-1