Skip to main content
Version: 10.0

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​

AttributeTypeDescriptionExample
urlstringMinIO server endpoint URLhttp://minio.example.com:9000
usernamestringMinIO access keyminioadmin
passwordstringMinIO secret keyminioadmin-secret

Optional Attributes​

AttributeTypeDescriptionDefault
bucketNamestringS3 bucket name for file storageAuto-generated
settingsobjectAdditional MinIO/S3 client settings{}

Settings Object​

The settings object supports S3 client configuration options:

SettingTypeDescriptionDefault
regionstringAWS/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).

tip

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:

  1. Bucket Existence Check - Uses a HEAD request to check if the bucket exists
  2. Connection Validation - Verifies network connectivity to MinIO endpoint
  3. 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 accessible
  • DOWN - 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 checks setting. The result appears in the server log only. If the bucket does not exist, it reports DOWN with the reason Bucket '<name>' does not exist at '<endpoint>', and reports UP again once the bucket exists. If the storage does not answer at all (for example because it is paused or unreachable), the status changes to DOWN after 15 seconds with the reason Health 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 checks section of provider.json (enabled, default false) controls whether the provider reports its status to the readiness endpoint (/health/ready). It is evaluated only when enabled is true, and it also reports DOWN if 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.

warning

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, or FILE_STORAGE_REMOVE_CONTENT (-21002) when removing content. The error description contains The bucket of the file storage does not exist.
  • The server log contains an ERROR line 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:

  1. Distributed MinIO – Multi-node MinIO cluster with erasure coding
  2. Load Balancing – Distribute requests across MinIO nodes
  3. Replication – Site-to-site bucket replication
  4. 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 region is 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.

note

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 variableSystem propertyDefaultDescription
WEBPDF_MINIO_CLIENT_PING_INTERVALwebpdf.minio.client.ping.interval15000Keepalive 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_COOLDOWNwebpdf.minio.client.forced.refresh.cooldown5000Minimum 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_INTERVALwebpdf.minio.client.certificate.poll.interval60000Polling interval in milliseconds for detecting changes to the external TLS certificate file.
WEBPDF_MINIO_CLIENT_TLS_CERT_FILEwebpdf.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_SIZEwebpdf.minio.client.part.size5242880Multipart transfer part size in bytes (default 5 MiB) for streaming uploads.
WEBPDF_MINIO_CLIENT_SHUTDOWN_TIMEOUTwebpdf.minio.client.shutdown.timeout20000Timeout in milliseconds for releasing client resources during shutdown or a pool rebuild.
WEBPDF_MINIO_CLIENT_REBUILD_ON_RECOVERYwebpdf.minio.client.rebuild.on.recoverytrueWhen 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_EXECUTORwebpdf.minio.client.streaming.shared.executortrueSince 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_CACHEwebpdf.minio.client.streaming.region.cachetrueSince 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.
tip

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 variableSystem propertyDefaultDescription
WEBPDF_MINIO_FILE_STORAGE_RETRY_ATTEMPTSwebpdf.minio.file.storage.retry.attempts5Maximum number of retry attempts for a file storage operation (the "Max Attempts" above).
WEBPDF_MINIO_FILE_STORAGE_CLEANUP_RETRY_ATTEMPTSwebpdf.minio.file.storage.cleanup.retry.attempts2Maximum 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_DELAYwebpdf.minio.file.storage.retry.max.total.delay0 (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_VERIFICATIONwebpdf.minio.file.storage.upload.verificationHEADHow 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_SIZEwebpdf.minio.file.storage.batch.size1000Number of objects per batch delete request (unchanged).
WEBPDF_MINIO_FILE_STORAGE_BUFFER_SIZEwebpdf.minio.file.storage.buffer.size-Local copy buffer size in bytes (unchanged).
tip

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:

  1. Local Cache - Files are cached locally after download
  2. ETag Validation - ETags and file sizes are compared before re-downloading
  3. Automatic Invalidation - Cache is updated when ETags don't match or file size differs
  4. 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 variableSystem propertyDefaultDescription
WEBPDF_CLUSTER_EVENTS_LOCAL_CACHE_CLEANUP_ENABLED-Dwebpdf.cluster.events.local.cache.cleanup.enabledtruefalse 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.

danger

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​

  1. Use dedicated network for storage traffic
  2. Enable jumbo frames (MTU 9000) if supported
  3. 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​

  1. Verify MinIO is running: curl http://minio.example.com:9000/minio/health/live
  2. Check network connectivity
  3. Verify access credentials
  4. Check firewall rules (port 9000)

Bucket Not Found​

  1. Verify bucket exists: mc ls myminio/
  2. Check bucket name matches configuration
  3. Verify access permissions
  4. 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​

  1. Check network bandwidth
  2. Review MinIO server performance
  3. Consider distributed MinIO setup
  4. Check file size - large files automatically use streaming client
  5. Review retry attempts in logs

Access Denied Errors​

  1. Verify access key and secret key
  2. Check IAM policy permissions
  3. Review bucket policies
  4. 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