@@ -47,6 +47,7 @@ repos:
           - interrogate==1.7.0
           - isort==6.0.1
           - matplotlib==3.10.0
+          - minio==7.2.20
           - more-itertools==10.7.0
           - mypy==1.16.1
           - nicegui==2.24.1
 
@@ -54,6 +54,7 @@ dev = [
     "flake8==7.3.0",
     "interrogate==1.7.0",
     "isort==6.0.1",
+    "minio==7.2.20",
     "mypy==1.16.1",
     "pandas-stubs==2.3.2.250926",
     "pre-commit==4.1.0",
@@ -67,7 +68,7 @@ dev = [
     "pytest-timeout==2.4.0",
     "PyYAML==6.0.2",
     "selenium==4.40.0",
-    "testcontainers[minio]==4.13.1",
+    "testcontainers==4.13.1",
     "types-aiobotocore-s3==2.26.0",
     "twine==6.2.0",
     "yamllint==1.35.1",
 
@@ -35,7 +35,8 @@
 
 BUCKET = "recordings"
 PREFIX = "project-0/site-0/camera-1"
-MINIO_IMAGE = "minio/minio:RELEASE.2025-09-07T16-13-09Z"
+# Pinned for reproducibility, and built for both amd64 and arm64.
+RUSTFS_IMAGE = "rustfs/rustfs:1.0.0-rc.6"
 CHUNKS = ["10-00-00", "10-15-00"]
 
 
@@ -52,16 +53,16 @@ def _docker_is_available() -> bool:
 
 
 pytestmark = pytest.mark.skipif(
-    not _docker_is_available(), reason="needs Docker to run MinIO"
+    not _docker_is_available(), reason="needs Docker to run RustFS"
 )
 
 
 @pytest.fixture(scope="module")
-def minio() -> Iterator[dict]:
-    from testcontainers.minio import MinioContainer
+def rustfs() -> Iterator[dict]:
+    from tests.utils.rustfs_container import RustFsContainer
 
     os.environ.setdefault("TESTCONTAINERS_RYUK_DISABLED", "true")
-    with MinioContainer(image=MINIO_IMAGE) as container:
+    with RustFsContainer(image=RUSTFS_IMAGE) as container:
         client = container.get_client()
         client.make_bucket(BUCKET)
         for chunk in CHUNKS:
@@ -76,19 +77,19 @@ def minio() -> Iterator[dict]:
 
 
 @pytest.fixture
-def s3_app(minio: dict, tmp_path: Path) -> Iterator[Any]:
-    """The real application, started in s3 mode against MinIO.
+def s3_app(rustfs: dict, tmp_path: Path) -> Iterator[Any]:
+    """The real application, started in s3 mode against RustFS.
 
     Configuration is environment only, so pointing the documented variables at a
-    throwaway MinIO exercises the production path with no test-only hooks.
+    throwaway RustFS exercises the production path with no test-only hooks.
     """
     environment = dict(os.environ)
     environment.update(
         {
             ENV_DATA_TRANSFER_MODE: "s3",
-            ENV_S3_ENDPOINT_URL: minio["endpoint_url"],
-            ENV_S3_ACCESS_KEY: minio["access_key"],
-            ENV_S3_SECRET_KEY: minio["secret_key"],
+            ENV_S3_ENDPOINT_URL: rustfs["endpoint_url"],
+            ENV_S3_ACCESS_KEY: rustfs["access_key"],
+            ENV_S3_SECRET_KEY: rustfs["secret_key"],
             ENV_S3_BUCKET: BUCKET,
             ENV_S3_KEY_PREFIX: PREFIX,
             ENV_S3_USER_SOURCE: str(tmp_path / "user-source"),
 
@@ -40,9 +40,8 @@
 # a suffix swap would look for an object that is not there.
 VIDEO_TYPE = ".mkv"
 
-# Pinned for reproducibility. testcontainers' own default is a 2022 build that is
-# amd64 only and will not start on an arm64 host.
-MINIO_IMAGE = "minio/minio:RELEASE.2025-09-07T16-13-09Z"
+# Pinned for reproducibility, and built for both amd64 and arm64.
+RUSTFS_IMAGE = "rustfs/rustfs:1.0.0-rc.6"
 
 
 def _docker_is_available() -> bool:
@@ -58,19 +57,19 @@ def _docker_is_available() -> bool:
 
 
 pytestmark = pytest.mark.skipif(
-    not _docker_is_available(), reason="needs Docker to run MinIO"
+    not _docker_is_available(), reason="needs Docker to run RustFS"
 )
 
 
 @pytest.fixture(scope="module")
-def minio() -> Iterator[dict]:
-    from testcontainers.minio import MinioContainer
+def rustfs() -> Iterator[dict]:
+    from tests.utils.rustfs_container import RustFsContainer
 
     # The reaper container bind-mounts the Docker socket, which Docker Desktop
     # refuses on some hosts. The context manager below cleans up on a normal
     # exit; the reaper only matters if the test process is killed outright.
     os.environ.setdefault("TESTCONTAINERS_RYUK_DISABLED", "true")
-    with MinioContainer(image=MINIO_IMAGE) as container:
+    with RustFsContainer(image=RUSTFS_IMAGE) as container:
         client = container.get_client()
         client.make_bucket(BUCKET)
         for chunk in CHUNKS:
@@ -104,12 +103,12 @@ class Given:
     user_source: Path
 
 
-def create_given(minio: dict, tmp_path: Path, hours: float = 1) -> Given:
+def create_given(rustfs: dict, tmp_path: Path, hours: float = 1) -> Given:
     user_source = tmp_path / "user-source"
     config = S3Config(
-        endpoint_url=minio["endpoint_url"],
-        access_key=minio["access_key"],
-        secret_key=minio["secret_key"],
+        endpoint_url=rustfs["endpoint_url"],
+        access_key=rustfs["access_key"],
+        secret_key=rustfs["secret_key"],
         bucket=BUCKET,
         region=None,
         key_prefix=PREFIX,
@@ -151,14 +150,14 @@ def create_video_target(given: Given) -> S3VideoFileProvider:
     )
 
 
-class TestLoadFromMinio:
+class TestLoadFromRustFs:
     """#Requirement https://openproject.platomo.de/wp/10283"""
 
     async def test_an_over_long_selection_loads_only_up_to_the_cap(
-        self, minio: dict, tmp_path: Path
+        self, rustfs: dict, tmp_path: Path
     ) -> None:
         """10:00-11:00 clamps to 10:20, so only the 10:00 and 10:15 chunks load."""
-        given = create_given(minio, tmp_path, hours=1)
+        given = create_given(rustfs, tmp_path, hours=1)
         target = create_track_target(given)
 
         provided = await target.provide()
@@ -170,9 +169,9 @@ async def test_an_over_long_selection_loads_only_up_to_the_cap(
         given.dialog.report_clamped.assert_called_once()
 
     async def test_downloads_each_track_file_with_its_video(
-        self, minio: dict, tmp_path: Path
+        self, rustfs: dict, tmp_path: Path
     ) -> None:
-        given = create_given(minio, tmp_path, hours=1)
+        given = create_given(rustfs, tmp_path, hours=1)
         target = create_track_target(given)
 
         await target.provide()
@@ -187,9 +186,9 @@ async def test_downloads_each_track_file_with_its_video(
                 assert staged.is_file(), f"{staged} was not downloaded"
 
     async def test_stages_objects_under_paths_mirroring_their_keys(
-        self, minio: dict, tmp_path: Path
+        self, rustfs: dict, tmp_path: Path
     ) -> None:
-        given = create_given(minio, tmp_path, hours=1)
+        given = create_given(rustfs, tmp_path, hours=1)
         target = create_track_target(given)
 
         provided = await target.provide()
@@ -199,20 +198,20 @@ async def test_stages_objects_under_paths_mirroring_their_keys(
         )
 
     async def test_reads_the_bytes_that_were_stored(
-        self, minio: dict, tmp_path: Path
+        self, rustfs: dict, tmp_path: Path
     ) -> None:
-        given = create_given(minio, tmp_path, hours=1)
+        given = create_given(rustfs, tmp_path, hours=1)
         target = create_track_target(given)
 
         provided = await target.provide()
 
         assert bz2.decompress(provided[0].read_bytes()).startswith(b"{")
 
     async def test_pairs_each_track_file_with_the_video_its_metadata_names(
-        self, minio: dict, tmp_path: Path
+        self, rustfs: dict, tmp_path: Path
     ) -> None:
         """A suffix swap would have looked for a .mp4 that does not exist."""
-        given = create_given(minio, tmp_path, hours=1)
+        given = create_given(rustfs, tmp_path, hours=1)
         target = create_track_target(given)
 
         await target.provide()
@@ -221,8 +220,8 @@ async def test_pairs_each_track_file_with_the_video_its_metadata_names(
         assert (staged / f"OTCamera19_FR20_2023-05-24_10-00-00{VIDEO_TYPE}").is_file()
         assert not (staged / "OTCamera19_FR20_2023-05-24_10-00-00.mp4").exists()
 
-    async def test_videos_load_on_their_own(self, minio: dict, tmp_path: Path) -> None:
-        given = create_given(minio, tmp_path, hours=1)
+    async def test_videos_load_on_their_own(self, rustfs: dict, tmp_path: Path) -> None:
+        given = create_given(rustfs, tmp_path, hours=1)
         target = create_video_target(given)
 
         provided = await target.provide()
 
@@ -0,0 +1,62 @@
+"""A testcontainers wrapper for RustFS, an S3-compatible object store.
+
+testcontainers-python ships a dedicated module for MinIO but not for RustFS (that
+only exists in the Rust bindings), so this wraps the official `rustfs/rustfs` image
+as a generic container the same way `testcontainers.minio.MinioContainer` wraps
+MinIO's. MinIO stopped publishing free images to Docker Hub in 2025 and later
+pulled the `minio/minio` repository entirely, which is why acceptance and
+integration tests were switched to RustFS.
+"""
+
+from minio import Minio
+from testcontainers.core.container import DockerContainer
+from testcontainers.core.wait_strategies import HttpWaitStrategy
+
+
+class RustFsContainer(DockerContainer):
+    """Runs RustFS and exposes it through the `minio` Python client.
+
+    RustFS speaks the S3 API, so the same client used against MinIO works here
+    unchanged; only how the container itself is started and its endpoint is
+    obtained differs.
+    """
+
+    def __init__(
+        self,
+        image: str,
+        port: int = 9000,
+        access_key: str = "rustfsadmin",
+        secret_key: str = "rustfsadmin",
+        **kwargs: object,
+    ) -> None:
+        super().__init__(image, **kwargs)
+        self.port = port
+        self.access_key = access_key
+        self.secret_key = secret_key
+
+        self.with_exposed_ports(self.port)
+        self.with_env("RUSTFS_ACCESS_KEY", self.access_key)
+        self.with_env("RUSTFS_SECRET_KEY", self.secret_key)
+        self.with_env("RUSTFS_ADDRESS", f"0.0.0.0:{self.port}")
+        self.waiting_for(
+            HttpWaitStrategy(self.port, "/health/ready").for_status_code(200)
+        )
+
+    def get_client(self) -> Minio:
+        """Returns a `minio` Python client connected to this container."""
+        return Minio(
+            self.get_config()["endpoint"],
+            access_key=self.access_key,
+            secret_key=self.secret_key,
+            secure=False,
+        )
+
+    def get_config(self) -> dict:
+        """Returns the container's endpoint, access key, and secret key."""
+        host_ip = self.get_container_host_ip()
+        exposed_port = self.get_exposed_port(self.port)
+        return {
+            "endpoint": f"{host_ip}:{exposed_port}",
+            "access_key": self.access_key,
+            "secret_key": self.secret_key,
+        }