Error Request failed Caused by: mismatch in file size

[Icehunter]

I'm self hosting using portainer on truenas scale. I had it working but for some reason I get this error now.

• All of this is running as mentioned on truenas scale, using portainer.
• Nginx does the proxying so I can use a custom domain to host everything, including web
• In front of that is Cloudflare Tunnels/ZeroTrust Access
• I've tried turning it off and just using the ports directly

Is there something I'm missing or accidentally added somewhere that is now limiting me?

Ente Web Dockerfile:

FROM node:20-alpine AS builder

WORKDIR /ente

RUN apk add --no-cache git
RUN git --version

# Will help default to yarn versoin 1.22.22
RUN corepack enable

RUN git clone https://github.com/ente-io/ente --depth 1 .

# Configure Albums and Accounts Endpoints
ENV NEXT_PUBLIC_ENTE_ALBUMS_ENDPOINT=https://127.0.0.1:8080
ENV NEXT_PUBLIC_ENTE_ACCOUNTS_URL=https://127.0.0.1:8080

WORKDIR /ente/web

RUN git submodule update --init --recursive
RUN yarn cache clean
RUN yarn install --network-timeout 1000000000
RUN yarn build:photos && yarn build:accounts && yarn build:auth && yarn build:cast

FROM node:20-alpine

WORKDIR /app

COPY --from=builder /ente/web/apps/photos/out /app/photos
COPY --from=builder /ente/web/apps/accounts/out /app/accounts
COPY --from=builder /ente/web/apps/auth/out /app/auth
COPY --from=builder /ente/web/apps/cast/out /app/cast

RUN npm install -g serve

ENV PHOTOS=3000
EXPOSE ${PHOTOS}

ENV ACCOUNTS=3001
EXPOSE ${ACCOUNTS}

ENV AUTH=3002
EXPOSE ${AUTH}

ENV CAST=3003
EXPOSE ${CAST}

# The albums app does not have navigable pages on it, but the
# port will be exposed in-order to self up the albums endpoint
# `apps.public-albums` in museum.yaml configuration file.
ENV ALBUMS=3004
EXPOSE ${ALBUMS}

CMD ["sh", "-c", "serve /app/photos -l tcp://0.0.0.0:${PHOTOS} & serve /app/accounts -l tcp://0.0.0.0:${ACCOUNTS} & serve /app/auth -l tcp://0.0.0.0:${AUTH} & serve /app/cast -l tcp://0.0.0.0:${CAST}"]

musem.yaml contains SMTP settings

credentials.yaml

db:
    host: postgres
    port: 5432
    name: ente_db
    user: pguser
    password: pgpassword

s3:
    are_local_buckets: true
    b2-eu-cen:
        key: bucketKey
        secret: bucketSecret
        endpoint: https://photos.domain.com
        region: eu-central-2
        bucket: b2-eu-cen
    wasabi-eu-central-2-v3:
        key: bucketKey
        secret: bucketSecret
        endpoint: https://photos.domain.com
        region: eu-central-2
        bucket: wasabi-eu-central-2-v3
        compliance: false
    scw-eu-fr-v3:
        key: bucketKey
        secret: bucketSecret
        endpoint: https://photos.domain.com
        region: eu-central-2
        bucket: scw-eu-fr-v3

minio-provision.sh

#!/bin/sh

# Script to prepare the MinIO instance in the development Docker Compose cluster.
# Wait for MinIO to be ready and configure the host alias
echo "Waiting for MinIO to be ready..."
while ! mc alias set h0 http://minio:3200 bucketKey bucketSecret
do
    echo "Retrying connection to MinIO..."
    sleep 0.5
done

# Create the buckets and set policies
for bucket in b2-eu-cen wasabi-eu-central-2-v3 scw-eu-fr-v3; do
    if mc ls h0/$bucket >/dev/null 2>&1; then
        echo "Bucket $bucket already exists."
    else
        echo "Creating bucket: $bucket"
        mc mb -p h0/$bucket
        echo "Bucket $bucket configured successfully."
    fi
done

echo "Provisioning complete."

nginx.conf

worker_processes auto;
events {
    worker_connections 1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    # Default client size limits
    client_max_body_size 5G;

    # General timeouts for large file uploads/downloads
    proxy_connect_timeout 300s;
    proxy_read_timeout 300s;
    proxy_send_timeout 300s;

    server {
        listen 80;
        server_name photos.domain.com;

        # Web application (default route)
        location / {
            proxy_pass http://web:3000; # Assuming the web service runs on port 3000
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }

        # API service (rewrite /api to root)
        location /api/ {
            rewrite ^/api(/.*)?$ $1 break; # Remove /api prefix
            proxy_pass http://museum:8080; # Assuming the museum service runs on port 8080
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }

        location /b2-eu-cen/ {
            proxy_pass http://minio:3200;     # MinIO service runs on port 3200
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;

            # Prevent buffering for large uploads
            proxy_request_buffering off;
            proxy_buffering off;

            # Timeouts and buffer settings
            proxy_connect_timeout 300s;
            proxy_read_timeout 300s;
            proxy_send_timeout 300s;
            proxy_buffer_size 128k;
            proxy_buffers 4 256k;
            proxy_busy_buffers_size 256k;
        }

        location /scw-eu-fr-v3/ {
            proxy_pass http://minio:3200;     # MinIO service runs on port 3200
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;

            # Prevent buffering for large uploads
            proxy_request_buffering off;
            proxy_buffering off;

            # Timeouts and buffer settings
            proxy_connect_timeout 300s;
            proxy_read_timeout 300s;
            proxy_send_timeout 300s;
            proxy_buffer_size 128k;
            proxy_buffers 4 256k;
            proxy_busy_buffers_size 256k;
        }

        location /wasabi-eu-central-2-v3/ {
            proxy_pass http://minio:3200;     # MinIO service runs on port 3200
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;

            # Prevent buffering for large uploads
            proxy_request_buffering off;
            proxy_buffering off;

            # Timeouts and buffer settings
            proxy_connect_timeout 300s;
            proxy_read_timeout 300s;
            proxy_send_timeout 300s;
            proxy_buffer_size 128k;
            proxy_buffers 4 256k;
            proxy_busy_buffers_size 256k;
        }
    }
}

Portainer stack:

services:
  nginx:
    image: nginx:latest
    container_name: nginx-proxy
    ports:
      - "23080:80"
    volumes:
      - /mnt/fish/apps/ente/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - web
      - museum
      - minio
    restart: unless-stopped

  museum:
    image: ghcr.io/ente-io/server
    expose:
      - "8080"
    ports:
      - "28080:8080"
    depends_on:
      - postgres
    environment:
      ENTE_CREDENTIALS_FILE: /credentials.yaml
    volumes:
      - /mnt/fish/apps/ente/logs:/var/logs
      - /mnt/fish/apps/ente/scripts/museum.yaml:/museum.yaml:ro
      - /mnt/fish/apps/ente/scripts/credentials.yaml:/credentials.yaml:ro
      - /mnt/fish/apps/ente/data:/data:ro
    restart: unless-stopped

  web:
    image: ente-web
    expose:
      - "3000"
    environment:
      - NEXT_PUBLIC_ENTE_ALBUMS_ENDPOINT=https://photos.domain.com
      - NEXT_PUBLIC_ENTE_ACCOUNTS_URL=https://photos.domain.com
      - NODE_ENV=development
    restart: unless-stopped

  minio:
    image: minio/minio
    expose:
      - "3200"
    environment:
      MINIO_ROOT_USER: bucketKey
      MINIO_ROOT_PASSWORD: bucketSecret
    command: server /data --address ":3200"
    volumes:
      - /mnt/fish/apps/ente/minio:/data
    restart: unless-stopped

  minio-provision:
    image: minio/mc
    depends_on:
      - minio
    volumes:
      - /mnt/fish/apps/ente/scripts/minio-provision.sh:/provision.sh:ro
      - /mnt/fish/apps/ente/minio:/data
    entrypoint: sh /provision.sh
    restart: on-failure

  postgres:
    image: postgres:15
    expose:
      - "5432"
    environment:
      POSTGRES_USER: pguser
      POSTGRES_PASSWORD: pgpassword
      POSTGRES_DB: ente_db
    healthcheck:
      test: ['CMD', 'pg_isready', '-q', '-d', 'ente_db', '-U', 'pguser']
      start_period: 40s
      start_interval: 1s
    volumes:
      - /mnt/fish/apps/ente/postgres:/var/lib/postgresql/data
    restart: unless-stopped

[mngshm]

I do not see the parameter s3.path_style_urls being set anywhere in the provided musuem.yaml. For more, check

ente/server/configurations/local.yaml

Lines 173 to 183 in 0ae1557

	# Uncomment this to use "path" style S3 URLs.
	#
	# By default the bucket name is part of the (sub)domain, e.g.
	# http://b2-eu-cen.localhost:3200/. If this is true, then we use "path"
	# style S3 URLs where the bucket is part of the URL path, e.g.
	# http://localhost:3200/b2-eu-cen.
	#
	# This is useful in scenarios when sub-domain based addressing cannot be
	# resolved, e.g. when running a local instance, or when using MinIO as a
	# production store.
	#use_path_style_urls: true

Suggest this after seeing the nginx config which says /b2-eu-cen/ {.

Also, FYI you haven't shown any logs, just the title of this discussion isn't sufficient to take out the exact reason. When do you exactly see the Mismatch in File size error ? While you're uploading or when all the images you uploaded are in a loading/preview state ?

Typically, if this is seen while uploading, then its majorly a CORS or web error, as museum is not being able to read the file size because museum does file size check before your image is redirected towards the bucket.

If this is seen while loading/preview, then museum is failing in communicating with S3 for the images in the bucket, in this case the s3 configuration is somewhere wrong which leads to museum not being able to have a steady/proper connection with it.

[mngshm]

There's some CORS header out of the four which is not functionally support by minio, I remember running into this problem but I couldn't fix it even after running every minio with each single request header manually, hence I ended up using the second command.

the health check also looks good too, which means MinIO is working and MinIO is clean as a slate in the current situation, the mis-configuration is probably in the museum or configuration side.

Wild guess, but what credentials have entered in the below block ?

environment:
      MINIO_ROOT_USER: bucketKey
      MINIO_ROOT_PASSWORD: 

It is supposed to have the username and password for MinIO which can be access via the CLI and the web app which gets hosted on ::3201. if you're entering BucketKey and BucketPassword there it is wrong.

Also,

1. Have you setup use_path_style_urls?
2. Why isn't 3201 exposed ? Aren't you using the MinIO Web App ?

[mngshm]

@Icehunter Wsa the issue fixed ?

[Icehunter]

Nope, I'm going to redo the docker images and compose, and see if there's anything in CloudFlare ZeroTrust + access I can set.

[mngshm]

Ohh, this week I spent some time reading the code and understanding client -> museum -> s3 a bit. And modified the "Configuring S3" document.

You should check this regarding your issue: https://help.ente.io/self-hosting/guides/configuring-s3#mismatch-in-file-size

[kaido2ki]

did you solve it?