Tile generating takes too long

[vietnguyengit]

Hi all,

I tried to use XarrayReader to visualise SST Zarr in out S3, works great on Notebook and can also be visualised with Leaflet.

Except it's quite slow. It takes more than a minute to generate a tile, so I can't take advantage of having the tiles generated with Lambda with an API Gateway endpoint as API Gateway restricts to 30 seconds timeout although Lambda itself has 15min timeout limit.

(The results above come from stacks deployed on EC2, Sydney region)

Below is the API controller (not much different from the example except I added idx to handle time index selection, the Zarr store has over 11k indexes.

@app.get("/tiles/{z}/{x}/{y}", response_class=Response)
def tile(
        z: int,
        x: int,
        y: int,
        url: str = Query(description="Zarr URL"),
        variable: str = Query(description="Zarr Variable"),
        idx: int = Query(description="Time index")
):
    with xarray.open_dataset(url, engine="zarr", decode_coords="all") as src:
        ds = src[variable][[idx]]
        # Make sure we are a CRS
        ds.rio.write_crs(4326, inplace=True)
        with XarrayReader(ds) as dst:
            img = dst.tile(x, y, z, tilesize=256)
            img.rescale(
                in_range=((260, 320),),
                out_range=((-20, 255),)
            )
            content = img.render(colormap=cm)
            return Response(content, media_type="image/png")

I also tried to cache the Zarr store, it does look faster but it might only be helpful on either local or EC2 environments, but not Lambda.

url = 's3://imos-data-pixeldrill/vhnguyen/playground/multi-years/'
store = zarr.storage.FSStore(url)
cache = zarr.LRUStoreCache(store, max_size=2**28)
ds = xr.open_dataset(cache, engine='zarr')

@app.get("/tiles/{z}/{x}/{y}", response_class=Response)
def tile(
        z: int,
        x: int,
        y: int,
        variable: str = Query(description="Zarr Variable"),
        idx: int = Query(description="Time index")
):
    # with xarray.open_dataset(url, engine="zarr", decode_coords="all") as src:
    da = ds[variable][[idx]]
    # Make sure we are a CRS
    da.rio.write_crs(4326, inplace=True)
    with XarrayReader(da) as dst:
        img = dst.tile(x, y, z, tilesize=256)
        img.rescale(
            in_range=((260, 320),),
            out_range=((-20, 255),)
        )
        content = img.render(colormap=cm)
        return Response(content, media_type="image/png")

Here's how the dataset looks like:

big one:

sliced one:

Can you please advise what should we be looking at, either the Rio-tiler configs or the Zarr store chunking, or something else?

Thank you.

[vincentsarago]

Zarr is not a visualization oriented first format and it's chunk configuration will have a huge impact on performance. If on each tile request the Reader has to download a huge chunk then the tiler will be slow. We advise to have Zarr chunked in the spatial dimension for better performance.

[vincentsarago]

Note: when using lambda you may want to increase it's Memory configuration has it also impacts its network configuration (highest memory will be faster to retrieve data from S3)

[vietnguyengit]

Hi @vincentsarago , thanks for your reply, that was helpful. Apparently, I could get the big Zarr store to be visualised nicely with Leaflet using Rio-tiler:

XarrayReader is a really cool feature!

What would be your recommendation on the chunk size for the SST dataset, I use the shape of (time: 10, lon: 1000, lat: 1000), and not sure if that is the optimal one.

Thanks Vincent again. Cheers!