# Notes on seaweedfs > 2020-04-28, martin@archive.org Currently (04/2020) [minio](https://github.com/minio/minio) is used to store output from PDF analysis for [fatcat](https://fatcat.wiki) (e.g. from [grobid](https://grobid.readthedocs.io/en/latest/)). The file checksum (sha1) serves as key, values are blobs of XML or JSON. Problem: minio inserts slowed down after inserting 80M or more objects. Summary: I did four test runs, three failed, one (testrun-4) succeeded. * [testrun-4](https://git.archive.org/webgroup/sandcrawler/-/blob/master/proposals/2020_seaweed_s3.md#testrun-4) So far, in a non-distributed mode, the project looks usable. Added 200M objects (about 550G) in 6 days. Full CPU load, 400M RAM usage, constant insert times. ---- Details (03/2020) / @bnewbold, slack > the sandcrawler XML data store (currently on aitio) is grinding to a halt, I > think because despite tuning minio+ext4+hdd just doesn't work. current at 2.6 > TiB of data (each document compressed with snappy) and 87,403,183 objects. > this doesn't impact ingest processing (because content is queued and archived > in kafka), but does impact processing and analysis > it is possible that the other load on aitio is making this worse, but I did > an experiment with dumping to a 16 TB disk that slowed way down after about > 50 million files also. some people on the internet said to just not worry > about these huge file counts on modern filesystems, but i've debugged a bit > and I think it is a bad idea after all Possible solutions * putting content in fake WARCs and trying to do something like CDX * deploy CEPH object store (or swift, or any other off-the-shelf object store) * try putting the files in postgres tables, mongodb, cassandra, etc: these are not designed for hundreds of millions of ~50 KByte XML documents (5 - 500 KByte range) * try to find or adapt an open source tool like Haystack, Facebook's solution to this engineering problem. eg: https://engineering.linkedin.com/blog/2016/05/introducing-and-open-sourcing-ambry---linkedins-new-distributed- ---- The following are notes gathered during a few test runs of seaweedfs in 04/2020 on wbgrp-svc170.us.archive.org (4 core E5-2620 v4, 4GB RAM). ---- ## Setup There are frequent [releases](https://github.com/chrislusf/seaweedfs/releases) but for the test, we used a build off master branch. Directions for configuring AWS CLI for seaweedfs: [https://github.com/chrislusf/seaweedfs/wiki/AWS-CLI-with-SeaweedFS](https://github.com/chrislusf/seaweedfs/wiki/AWS-CLI-with-SeaweedFS). ### Build the binary Using development version (requires a [Go installation](https://golang.org/dl/)). ``` $ git clone git@github.com:chrislusf/seaweedfs.git # 11f5a6d9 $ cd seaweedfs $ make $ ls -lah weed/weed -rwxr-xr-x 1 tir tir 55M Apr 17 16:57 weed $ git rev-parse HEAD 11f5a6d91346e5f3cbf3b46e0a660e231c5c2998 $ sha1sum weed/weed a7f8f0b49e6183da06fc2d1411c7a0714a2cc96b ``` A single, 55M binary emerges after a few seconds. The binary contains subcommands to run different parts of seaweed, e.g. master or volume servers, filer and commands for maintenance tasks, like backup and compaction. To *deploy*, just copy this binary to the destination. ### Quickstart with S3 Assuming `weed` binary is in PATH. Start a master and volume server (over /tmp, most likely) and the S3 API with a single command: ``` $ weed -server s3 ... Start Seaweed Master 30GB 1.74 at 0.0.0.0:9333 ... Store started on dir: /tmp with 0 volumes max 7 Store started on dir: /tmp with 0 ec shards Volume server start with seed master nodes: [localhost:9333] ... Start Seaweed S3 API Server 30GB 1.74 at http port 8333 ... ``` Install the [AWS CLI](https://github.com/chrislusf/seaweedfs/wiki/AWS-CLI-with-SeaweedFS). Create a bucket. ``` $ aws --endpoint-url http://localhost:8333 s3 mb s3://sandcrawler-dev make_bucket: sandcrawler-dev ``` List buckets. ``` $ aws --endpoint-url http://localhost:8333 s3 ls 2020-04-17 17:44:39 sandcrawler-dev ``` Create a dummy file. ``` $ echo "blob" > 12340d9a4a4f710ecf03b127051814385e83ff08.tei.xml ``` Upload. ``` $ aws --endpoint-url http://localhost:8333 s3 cp 12340d9a4a4f710ecf03b127051814385e83ff08.tei.xml s3://sandcrawler-dev upload: ./12340d9a4a4f710ecf03b127051814385e83ff08.tei.xml to s3://sandcrawler-dev/12340d9a4a4f710ecf03b127051814385e83ff08.tei.xml ``` List. ``` $ aws --endpoint-url http://localhost:8333 s3 ls s3://sandcrawler-dev 2020-04-17 17:50:35 5 12340d9a4a4f710ecf03b127051814385e83ff08.tei.xml ``` Stream to stdout. ``` $ aws --endpoint-url http://localhost:8333 s3 cp s3://sandcrawler-dev/12340d9a4a4f710ecf03b127051814385e83ff08.tei.xml - blob ``` Drop the bucket. ``` $ aws --endpoint-url http://localhost:8333 s3 rm --recursive s3://sandcrawler-dev ``` ### Builtin benchmark The project comes with a builtin benchmark command. ``` $ weed benchmark ``` I encountered an error like [#181](https://github.com/chrislusf/seaweedfs/issues/181), "no free volume left" - when trying to start the benchmark after the S3 ops. A restart or a restart with `-volume.max 100` helped. ``` $ weed server -s3 -volume.max 100 ``` ### Listing volumes ``` $ weed shell > volume.list Topology volume:15/112757 active:8 free:112742 remote:0 volumeSizeLimit:100 MB DataCenter DefaultDataCenter volume:15/112757 active:8 free:112742 remote:0 Rack DefaultRack volume:15/112757 active:8 free:112742 remote:0 DataNode localhost:8080 volume:15/112757 active:8 free:112742 remote:0 volume id:1 size:105328040 collection:"test" file_count:33933 version:3 modified_at_second:1587215730 volume id:2 size:106268552 collection:"test" file_count:34236 version:3 modified_at_second:1587215730 volume id:3 size:106290280 collection:"test" file_count:34243 version:3 modified_at_second:1587215730 volume id:4 size:105815368 collection:"test" file_count:34090 version:3 modified_at_second:1587215730 volume id:5 size:105660168 collection:"test" file_count:34040 version:3 modified_at_second:1587215730 volume id:6 size:106296488 collection:"test" file_count:34245 version:3 modified_at_second:1587215730 volume id:7 size:105753288 collection:"test" file_count:34070 version:3 modified_at_second:1587215730 volume id:8 size:7746408 file_count:12 version:3 modified_at_second:1587215764 volume id:9 size:10438760 collection:"test" file_count:3363 version:3 modified_at_second:1587215788 volume id:10 size:10240104 collection:"test" file_count:3299 version:3 modified_at_second:1587215788 volume id:11 size:10258728 collection:"test" file_count:3305 version:3 modified_at_second:1587215788 volume id:12 size:10240104 collection:"test" file_count:3299 version:3 modified_at_second:1587215788 volume id:13 size:10112840 collection:"test" file_count:3258 version:3 modified_at_second:1587215788 volume id:14 size:10190440 collection:"test" file_count:3283 version:3 modified_at_second:1587215788 volume id:15 size:10112840 collection:"test" file_count:3258 version:3 modified_at_second:1587215788 DataNode localhost:8080 total size:820752408 file_count:261934 Rack DefaultRack total size:820752408 file_count:261934 DataCenter DefaultDataCenter total size:820752408 file_count:261934 total size:820752408 file_count:261934 ``` ### Custom S3 benchmark To simulate the use case of S3 for 100-500M small files (grobid xml, pdftotext, ...), I created a synthetic benchmark. * [https://gist.github.com/miku/6f3fee974ba82083325c2f24c912b47b](https://gist.github.com/miku/6f3fee974ba82083325c2f24c912b47b) We just try to fill up the datastore with millions of 5k blobs. ---- ### testrun-1 Small set, just to run. Status: done. Learned that the default in-memory volume index grows too quickly for the 4GB RAM machine. ``` $ weed server -dir /tmp/martin-seaweedfs-testrun-1 -s3 -volume.max 512 -master.volumeSizeLimitMB 100 ``` * https://github.com/chrislusf/seaweedfs/issues/498 -- RAM * at 10M files, we already consume ~1G ``` -volume.index string Choose [memory|leveldb|leveldbMedium|leveldbLarge] mode for memory~performance balance. (default "memory") ``` ### testrun-2 200M 5k objects, in-memory volume index. Status: done. Observed: After 18M objects the 512 100MB volumes are exhausted and seaweedfs will not accept any new data. ``` $ weed server -dir /tmp/martin-seaweedfs-testrun-2 -s3 -volume.max 512 -master.volumeSizeLimitMB 100 ... I0418 12:01:43 1622 volume_loading.go:104] loading index /tmp/martin-seaweedfs-testrun-2/test_511.idx to memory I0418 12:01:43 1622 store.go:122] add volume 511 I0418 12:01:43 1622 volume_layout.go:243] Volume 511 becomes writable I0418 12:01:43 1622 volume_growth.go:224] Created Volume 511 on topo:DefaultDataCenter:DefaultRack:localhost:8080 I0418 12:01:43 1622 master_grpc_server.go:158] master send to master@[::1]:45084: url:"localhost:8080" public_url:"localhost:8080" new_vids:511 I0418 12:01:43 1622 master_grpc_server.go:158] master send to filer@::1:18888: url:"localhost:8080" public_url:"localhost:8080" new_vids:511 I0418 12:01:43 1622 store.go:118] In dir /tmp/martin-seaweedfs-testrun-2 adds volume:512 collection:test replicaPlacement:000 ttl: I0418 12:01:43 1622 volume_loading.go:104] loading index /tmp/martin-seaweedfs-testrun-2/test_512.idx to memory I0418 12:01:43 1622 store.go:122] add volume 512 I0418 12:01:43 1622 volume_layout.go:243] Volume 512 becomes writable I0418 12:01:43 1622 master_grpc_server.go:158] master send to master@[::1]:45084: url:"localhost:8080" public_url:"localhost:8080" new_vids:512 I0418 12:01:43 1622 master_grpc_server.go:158] master send to filer@::1:18888: url:"localhost:8080" public_url:"localhost:8080" new_vids:512 I0418 12:01:43 1622 volume_growth.go:224] Created Volume 512 on topo:DefaultDataCenter:DefaultRack:localhost:8080 I0418 12:01:43 1622 node.go:82] topo failed to pick 1 from 0 node candidates I0418 12:01:43 1622 volume_growth.go:88] create 7 volume, created 2: No enough data node found! I0418 12:04:30 1622 volume_layout.go:231] Volume 511 becomes unwritable I0418 12:04:30 1622 volume_layout.go:231] Volume 512 becomes unwritable E0418 12:04:30 1622 filer_server_handlers_write.go:69] failing to assign a file id: rpc error: code = Unknown desc = No free volumes left! I0418 12:04:30 1622 filer_server_handlers_write.go:120] fail to allocate volume for /buckets/test/k43731970, collection:test, datacenter: E0418 12:04:30 1622 filer_server_handlers_write.go:69] failing to assign a file id: rpc error: code = Unknown desc = No free volumes left! E0418 12:04:30 1622 filer_server_handlers_write.go:69] failing to assign a file id: rpc error: code = Unknown desc = No free volumes left! E0418 12:04:30 1622 filer_server_handlers_write.go:69] failing to assign a file id: rpc error: code = Unknown desc = No free volumes left! E0418 12:04:30 1622 filer_server_handlers_write.go:69] failing to assign a file id: rpc error: code = Unknown desc = No free volumes left! I0418 12:04:30 1622 masterclient.go:88] filer failed to receive from localhost:9333: rpc error: code = Unavailable desc = transport is closing I0418 12:04:30 1622 master_grpc_server.go:276] - client filer@::1:18888 ``` Inserted about 18M docs, then: ``` worker-0 @3720000 45475.13 81.80 worker-1 @3730000 45525.00 81.93 worker-3 @3720000 45525.76 81.71 worker-4 @3720000 45527.22 81.71 Process Process-1: Traceback (most recent call last): File "/usr/lib/python3.5/multiprocessing/process.py", line 249, in _bootstrap self.run() File "/usr/lib/python3.5/multiprocessing/process.py", line 93, in run self._target(*self._args, **self._kwargs) File "s3test.py", line 42, in insert_keys s3.Bucket(bucket).put_object(Key=key, Body=data) File "/home/martin/.virtualenvs/6f3fee974ba82083325c2f24c912b47b/lib/python3.5/site-packages/boto3/resources/factory.py", line 520, in do_action response = action(self, *args, **kwargs) File "/home/martin/.virtualenvs/6f3fee974ba82083325c2f24c912b47b/lib/python3.5/site-packages/boto3/resources/action.py", line 83, in __call__ response = getattr(parent.meta.client, operation_name)(**params) File "/home/martin/.virtualenvs/6f3fee974ba82083325c2f24c912b47b/lib/python3.5/site-packages/botocore/client.py", line 316, in _api_call return self._make_api_call(operation_name, kwargs) File "/home/martin/.virtualenvs/6f3fee974ba82083325c2f24c912b47b/lib/python3.5/site-packages/botocore/client.py", line 626, in _make_api_call raise error_class(parsed_response, operation_name) botocore.exceptions.ClientError: An error occurred (InternalError) when calling the PutObject operation (reached max retries: 4): We encountered an internal error, please try again. real 759m30.034s user 1962m47.487s sys 105m21.113s ``` Sustained 400 S3 puts/s, RAM usage 41% of a 4G machine. 56G on disk. > No free volumes left! Failed to allocate bucket for /buckets/test/k163721819 ### testrun-3 * use leveldb, leveldbLarge * try "auto" volumes * Status: done. Observed: rapid memory usage increase. ``` $ weed server -dir /tmp/martin-seaweedfs-testrun-3 -s3 -volume.max 0 -volume.index=leveldbLarge -filer=false -master.volumeSizeLimitMB 100 ``` Observations: memory usage grows rapidly, soon at 15%. Note-to-self: [https://github.com/chrislusf/seaweedfs/wiki/Optimization](https://github.com/chrislusf/seaweedfs/wiki/Optimization) ### testrun-4 The default volume size is 30G (and cannot be more at the moment), and RAM grows very much with the number of volumes. Therefore, keep default volume size and do not limit number of volumes `-volume.max 0` and do not use in-memory index (rather leveldb) Status: done, 200M object upload via Python script successfully in about 6 days, memory usage was at a moderate 400M (~10% of RAM). Relatively constant performance at about 400 `PutObject` requests/s (over 5 threads, each thread was around 80 requests/s; then testing with 4 threads, each thread got to around 100 requests/s). ``` $ weed server -dir /tmp/martin-seaweedfs-testrun-4 -s3 -volume.max 0 -volume.index=leveldb ``` The test script command was (40M files per worker, 5 workers). ``` $ time python s3test.py -n 40000000 -w 5 2> s3test.4.log ... real 8454m33.695s user 21318m23.094s sys 1128m32.293s ``` The test script adds keys from `k0...k199999999`. ``` $ aws --endpoint-url http://localhost:8333 s3 ls s3://test | head -20 2020-04-19 09:27:13 5000 k0 2020-04-19 09:27:13 5000 k1 2020-04-19 09:27:13 5000 k10 2020-04-19 09:27:15 5000 k100 2020-04-19 09:27:26 5000 k1000 2020-04-19 09:29:15 5000 k10000 2020-04-19 09:47:49 5000 k100000 2020-04-19 12:54:03 5000 k1000000 2020-04-20 20:14:10 5000 k10000000 2020-04-22 07:33:46 5000 k100000000 2020-04-22 07:33:46 5000 k100000001 2020-04-22 07:33:46 5000 k100000002 2020-04-22 07:33:46 5000 k100000003 2020-04-22 07:33:46 5000 k100000004 2020-04-22 07:33:46 5000 k100000005 2020-04-22 07:33:46 5000 k100000006 2020-04-22 07:33:46 5000 k100000007 2020-04-22 07:33:46 5000 k100000008 2020-04-22 07:33:46 5000 k100000009 2020-04-20 20:14:10 5000 k10000001 ``` Glance at stats. ``` $ du -hs /tmp/martin-seaweedfs-testrun-4 596G /tmp/martin-seaweedfs-testrun-4 $ find . /tmp/martin-seaweedfs-testrun-4 | wc -l 5104 $ ps --pid $(pidof weed) -o pid,tid,class,stat,vsz,rss,comm PID TID CLS STAT VSZ RSS COMMAND 32194 32194 TS Sl+ 1966964 491644 weed $ ls -1 /proc/$(pidof weed)/fd | wc -l 192 $ free -m total used free shared buff/cache available Mem: 3944 534 324 39 3086 3423 Swap: 4094 27 4067 ``` ### Note on restart When stopping (CTRL-C) and restarting `weed` it will take about 10 seconds to get the S3 API server back up, but another minute or two, until seaweedfs inspects all existing volumes and indices. In that gap, requests to S3 will look like internal server errors. ``` $ aws --endpoint-url http://localhost:8333 s3 cp s3://test/k100 - download failed: s3://test/k100 to - An error occurred (500) when calling the GetObject operation (reached max retries: 4): Internal Server Error ``` ### Read benchmark Reading via command line `aws` client is a bit slow at first sight (3-5s). ``` $ time aws --endpoint-url http://localhost:8333 s3 cp s3://test/k123456789 - ppbhjgzkrrgwagmjsuwhqcwqzmefybeopqz [...] real 0m5.839s user 0m0.898s sys 0m0.293s ``` #### Single process random reads * via [s3read.go](https://gist.github.com/miku/6f3fee974ba82083325c2f24c912b47b#file-s3read-go) Running 1000 random reads takes 49s. #### Concurrent random reads * 80000 request with 8 parallel processes: 7m41.973968488s, so about 170 objects/s) * seen up to 760 keys/s reads for 8 workers * weed will utilize all cores, so more cpus could result in higher read throughput * RAM usage can increase (seen up to 20% of 4G RAM), then descrease (GC) back to 5%, depending on query load