ਸਟੋਰੇਜ਼ ਸਪੀਡ ਆਦਿ ਲਈ ਢੁਕਵੀਂ ਹੈ? ਆਓ ਫਿਓ ਨੂੰ ਪੁੱਛੀਏ

ਫਿਓ ਅਤੇ ਆਦਿ ਬਾਰੇ ਇੱਕ ਛੋਟੀ ਕਹਾਣੀ

ਕਲੱਸਟਰ ਪ੍ਰਦਰਸ਼ਨ ਆਦਿ ਜ਼ਿਆਦਾਤਰ ਇਸਦੀ ਸਟੋਰੇਜ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। etcd ਕੁਝ ਮੈਟ੍ਰਿਕਸ ਨੂੰ ਐਕਸਪੋਰਟ ਕਰਦਾ ਹੈ Prometheusਲੋੜੀਂਦੀ ਸਟੋਰੇਜ ਕਾਰਗੁਜ਼ਾਰੀ ਜਾਣਕਾਰੀ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ। ਉਦਾਹਰਨ ਲਈ, wal_fsync_duration_seconds ਮੈਟ੍ਰਿਕ। etcd ਲਈ ਦਸਤਾਵੇਜ਼ ਕਹਿੰਦਾ ਹੈ: ਸਟੋਰੇਜ ਨੂੰ ਕਾਫ਼ੀ ਤੇਜ਼ ਮੰਨੇ ਜਾਣ ਲਈ, ਇਸ ਮੈਟ੍ਰਿਕ ਦਾ 99ਵਾਂ ਪ੍ਰਤੀਸ਼ਤ 10ms ਤੋਂ ਘੱਟ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਜੇ ਤੁਸੀਂ ਲੀਨਕਸ ਮਸ਼ੀਨਾਂ 'ਤੇ ਇੱਕ etcd ਕਲੱਸਟਰ ਚਲਾਉਣ ਦੀ ਯੋਜਨਾ ਬਣਾ ਰਹੇ ਹੋ ਅਤੇ ਮੁਲਾਂਕਣ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਕੀ ਤੁਹਾਡੀ ਸਟੋਰੇਜ ਕਾਫ਼ੀ ਤੇਜ਼ ਹੈ (ਜਿਵੇਂ ਕਿ SSD), ਤਾਂ ਤੁਸੀਂ ਵਰਤ ਸਕਦੇ ਹੋ ਫਿਓ I/O ਕਾਰਵਾਈਆਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰਸਿੱਧ ਸੰਦ ਹੈ। ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਚਲਾਓ, ਜਿੱਥੇ test-data ਸਟੋਰੇਜ਼ ਮਾਊਂਟ ਪੁਆਇੰਟ ਦੇ ਅਧੀਨ ਡਾਇਰੈਕਟਰੀ ਹੈ:

fio --rw=write --ioengine=sync --fdatasync=1 --directory=test-data --size=22m --bs=2300 --name=mytest

ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਨਤੀਜਿਆਂ ਨੂੰ ਦੇਖਣ ਦੀ ਲੋੜ ਹੈ ਅਤੇ ਇਹ ਜਾਂਚ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਕਿ ਮਿਆਦ ਦਾ 99ਵਾਂ ਪ੍ਰਤੀਸ਼ਤ ਹੈ fdatasync 10 ms ਤੋਂ ਘੱਟ ਜੇਕਰ ਅਜਿਹਾ ਹੈ, ਤਾਂ ਤੁਹਾਡੇ ਕੋਲ ਕਾਫ਼ੀ ਤੇਜ਼ ਸਟੋਰੇਜ ਹੈ। ਇੱਥੇ ਨਤੀਜਿਆਂ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ:

  sync (usec): min=534, max=15766, avg=1273.08, stdev=1084.70
  sync percentiles (usec):
   | 1.00th=[ 553], 5.00th=[ 578], 10.00th=[ 594], 20.00th=[ 627],
   | 30.00th=[ 709], 40.00th=[ 750], 50.00th=[ 783], 60.00th=[ 1549],
   | 70.00th=[ 1729], 80.00th=[ 1991], 90.00th=[ 2180], 95.00th=[ 2278],
   | 99.00th=[ 2376], 99.50th=[ 9634], 99.90th=[15795], 99.95th=[15795],
   | 99.99th=[15795]

ਨੋਟਸ

• ਅਸੀਂ ਆਪਣੇ ਖਾਸ ਦ੍ਰਿਸ਼ ਲਈ --size ਅਤੇ --bs ਵਿਕਲਪਾਂ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕੀਤਾ ਹੈ। fio ਤੋਂ ਲਾਭਦਾਇਕ ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਆਪਣੇ ਖੁਦ ਦੇ ਮੁੱਲ ਪ੍ਰਦਾਨ ਕਰੋ। ਉਹਨਾਂ ਨੂੰ ਕਿੱਥੇ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ? ਪੜ੍ਹੋ ਅਸੀਂ fio ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨਾ ਕਿਵੇਂ ਸਿੱਖਿਆ.
• ਟੈਸਟਿੰਗ ਦੌਰਾਨ, ਸਾਰਾ I/O ਲੋਡ fio ਤੋਂ ਆਉਂਦਾ ਹੈ। ਇੱਕ ਅਸਲ-ਜੀਵਨ ਦ੍ਰਿਸ਼ ਵਿੱਚ, ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ ਸਟੋਰੇਜ ਵਿੱਚ wal_fsync_duration_seconds ਨਾਲ ਸਬੰਧਤ ਹੋਰ ਲਿਖਤੀ ਬੇਨਤੀਆਂ ਆਉਣਗੀਆਂ। ਵਾਧੂ ਲੋਡ wal_fsync_duration_seconds ਦੇ ਮੁੱਲ ਨੂੰ ਵਧਾਏਗਾ। ਇਸ ਲਈ ਜੇਕਰ 99ਵਾਂ ਪਰਸੈਂਟਾਈਲ 10ms ਦੇ ਨੇੜੇ ਹੈ, ਤਾਂ ਤੁਹਾਡੀ ਸਟੋਰੇਜ ਦੀ ਗਤੀ ਖਤਮ ਹੋ ਰਹੀ ਹੈ।
• ਸੰਸਕਰਣ ਲਓ ਫਿਓ 3.5 ਤੋਂ ਘੱਟ ਨਹੀਂ (ਪਿਛਲੇ ਵਾਲੇ fdatasync ਮਿਆਦ ਪਰਸੈਂਟਾਈਲ ਨਹੀਂ ਦਿਖਾਉਂਦੇ ਹਨ)।
• ਉੱਪਰ ਫਿਓ ਦੇ ਨਤੀਜਿਆਂ ਦਾ ਸਿਰਫ਼ ਇੱਕ ਸਨਿੱਪਟ ਹੈ।

fio ਅਤੇ etcd ਬਾਰੇ ਲੰਬੀ ਕਹਾਣੀ

ਆਦਿ ਵਿੱਚ WAL ਕੀ ਹੈ?

ਆਮ ਤੌਰ 'ਤੇ ਡਾਟਾਬੇਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ ਲਿਖਣ-ਅੱਗੇ ਲਾਗ; etcd ਇਸਦੀ ਵਰਤੋਂ ਵੀ ਕਰਦਾ ਹੈ। ਅਸੀਂ ਇੱਥੇ ਰਾਈਟ-ਹੇਡ ਲੌਗ (WAL) ਬਾਰੇ ਵਿਸਥਾਰ ਵਿੱਚ ਚਰਚਾ ਨਹੀਂ ਕਰਾਂਗੇ। ਸਾਡੇ ਲਈ ਇਹ ਜਾਣਨਾ ਕਾਫ਼ੀ ਹੈ ਕਿ etcd ਕਲੱਸਟਰ ਦਾ ਹਰੇਕ ਮੈਂਬਰ ਇਸਨੂੰ ਨਿਰੰਤਰ ਸਟੋਰੇਜ ਵਿੱਚ ਰੱਖਦਾ ਹੈ। etcd ਸਟੋਰ 'ਤੇ ਲਾਗੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ WAL ਨੂੰ ਹਰੇਕ ਕੁੰਜੀ-ਮੁੱਲ ਕਾਰਵਾਈ (ਜਿਵੇਂ ਕਿ ਅੱਪਡੇਟ) ਲਿਖਦਾ ਹੈ। ਜੇਕਰ ਸਟੋਰੇਜ਼ ਮੈਂਬਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਕ੍ਰੈਸ਼ ਹੋ ਜਾਂਦਾ ਹੈ ਅਤੇ ਸਨੈਪਸ਼ਾਟ ਦੇ ਵਿਚਕਾਰ ਮੁੜ ਚਾਲੂ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਇਹ WAL ਸਮੱਗਰੀ ਦੁਆਰਾ ਆਖਰੀ ਸਨੈਪਸ਼ਾਟ ਤੋਂ ਬਾਅਦ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਨੂੰ ਬਹਾਲ ਕਰ ਸਕਦਾ ਹੈ।

ਜਦੋਂ ਇੱਕ ਕਲਾਇੰਟ ਕੁੰਜੀ-ਮੁੱਲ ਸਟੋਰ ਵਿੱਚ ਇੱਕ ਕੁੰਜੀ ਜੋੜਦਾ ਹੈ ਜਾਂ ਮੌਜੂਦਾ ਕੁੰਜੀ ਦੇ ਮੁੱਲ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ, etcd ਓਪਰੇਸ਼ਨ ਨੂੰ WAL ਵਿੱਚ ਰਿਕਾਰਡ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਨਿਰੰਤਰ ਸਟੋਰੇਜ ਵਿੱਚ ਇੱਕ ਨਿਯਮਤ ਫਾਈਲ ਹੈ। etcd ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਯਕੀਨੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ WAL ਐਂਟਰੀ ਅਸਲ ਵਿੱਚ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਜਾਰੀ ਰੱਖਣ ਤੋਂ ਪਹਿਲਾਂ ਆਈ ਹੈ। ਲੀਨਕਸ 'ਤੇ, ਇਸਦੇ ਲਈ ਇੱਕ ਸਿਸਟਮ ਕਾਲ ਕਾਫ਼ੀ ਨਹੀਂ ਹੈ। ਲਿਖਣ ਦੀ, ਕਿਉਂਕਿ ਭੌਤਿਕ ਸਟੋਰੇਜ ਨੂੰ ਅਸਲ ਲਿਖਣ ਵਿੱਚ ਦੇਰੀ ਹੋ ਸਕਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਲੀਨਕਸ ਕੁਝ ਸਮੇਂ ਲਈ ਕਰਨਲ ਮੈਮੋਰੀ (ਜਿਵੇਂ ਕਿ ਇੱਕ ਪੰਨਾ ਕੈਸ਼) ਵਿੱਚ ਇੱਕ ਕੈਸ਼ ਵਿੱਚ ਇੱਕ WAL ਐਂਟਰੀ ਸਟੋਰ ਕਰ ਸਕਦਾ ਹੈ। ਅਤੇ ਲਗਾਤਾਰ ਸਟੋਰੇਜ਼ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਲਿਖੇ ਜਾਣ ਲਈ, ਲਿਖਣ ਤੋਂ ਬਾਅਦ fdatasync ਸਿਸਟਮ ਕਾਲ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਅਤੇ etcd ਇਸਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ (ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਕੰਮ ਦੇ ਨਤੀਜੇ ਵਿੱਚ ਦੇਖ ਸਕਦੇ ਹੋ। ਸਟਰੇਸ, ਜਿੱਥੇ 8 WAL ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ ਹੈ):

21:23:09.894875 lseek(8, 0, SEEK_CUR)   = 12808 <0.000012>
21:23:09.894911 write(8, ". 20210220361223255266632$10 20103026"34"rn3fo"..., 2296) = 2296 <0.000130>
21:23:09.895041 fdatasync(8)            = 0 <0.008314>

ਬਦਕਿਸਮਤੀ ਨਾਲ, ਨਿਰੰਤਰ ਸਟੋਰੇਜ ਨੂੰ ਲਿਖਣਾ ਤੁਰੰਤ ਨਹੀਂ ਹੁੰਦਾ ਹੈ। ਜੇਕਰ fdatasync ਕਾਲ ਹੌਲੀ ਹੈ, etcd ਸਿਸਟਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਨੁਕਸਾਨ ਹੋਵੇਗਾ। etcd ਲਈ ਦਸਤਾਵੇਜ਼ ਕਹਿੰਦਾ ਹੈਕਿ ਸਟੋਰੇਜ ਨੂੰ ਕਾਫ਼ੀ ਤੇਜ਼ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਜੇਕਰ, 99ਵੇਂ ਪਰਸੈਂਟਾਈਲ ਵਿੱਚ, fdatasync ਕਾਲਾਂ ਨੂੰ WAL ਫਾਈਲ ਵਿੱਚ ਲਿਖਣ ਲਈ 10ms ਤੋਂ ਘੱਟ ਸਮਾਂ ਲੱਗਦਾ ਹੈ। ਸਟੋਰੇਜ ਲਈ ਹੋਰ ਉਪਯੋਗੀ ਮੈਟ੍ਰਿਕਸ ਹਨ, ਪਰ ਇਸ ਪੋਸਟ ਵਿੱਚ ਅਸੀਂ ਸਿਰਫ ਇਸ ਮੈਟ੍ਰਿਕ ਬਾਰੇ ਗੱਲ ਕਰ ਰਹੇ ਹਾਂ.

fio ਨਾਲ ਸਟੋਰੇਜ ਦਾ ਅਨੁਮਾਨ ਲਗਾਇਆ ਜਾ ਰਿਹਾ ਹੈ

ਜੇਕਰ ਤੁਹਾਨੂੰ ਇਹ ਮੁਲਾਂਕਣ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਕਿ ਕੀ ਤੁਹਾਡੀ ਸਟੋਰੇਜ etcd ਲਈ ਢੁਕਵੀਂ ਹੈ, ਤਾਂ fio ਦੀ ਵਰਤੋਂ ਕਰੋ, ਇੱਕ ਬਹੁਤ ਮਸ਼ਹੂਰ I/O ਲੋਡ ਟੈਸਟਿੰਗ ਟੂਲ। ਇਹ ਯਾਦ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਡਿਸਕ ਓਪਰੇਸ਼ਨ ਬਹੁਤ ਵੱਖਰੇ ਹੋ ਸਕਦੇ ਹਨ: ਸਮਕਾਲੀ ਅਤੇ ਅਸਿੰਕਰੋਨਸ, ਸਿਸਟਮ ਕਾਲਾਂ ਦੀਆਂ ਕਈ ਸ਼੍ਰੇਣੀਆਂ, ਆਦਿ। ਨਤੀਜੇ ਵਜੋਂ, ਫਿਓ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਕਾਫ਼ੀ ਮੁਸ਼ਕਲ ਹੈ। ਇਸਦੇ ਬਹੁਤ ਸਾਰੇ ਮਾਪਦੰਡ ਹਨ, ਅਤੇ ਉਹਨਾਂ ਦੇ ਮੁੱਲਾਂ ਦੇ ਵੱਖ-ਵੱਖ ਸੰਜੋਗ ਬਹੁਤ ਵੱਖਰੇ I/O ਵਰਕਲੋਡ ਪੈਦਾ ਕਰਦੇ ਹਨ। etcd ਲਈ ਢੁਕਵੇਂ ਅੰਕੜੇ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ WAL ਫਾਈਲਾਂ ਲਿਖਣ ਵੇਲੇ fio ਤੋਂ ਟੈਸਟ ਲਿਖਣ ਦਾ ਲੋਡ etcd ਤੋਂ ਅਸਲ ਲੋਡ ਦੇ ਜਿੰਨਾ ਸੰਭਵ ਹੋ ਸਕੇ ਨੇੜੇ ਹੋਵੇ।

ਇਸ ਲਈ, fio ਨੂੰ, ਘੱਟੋ-ਘੱਟ, ਫਾਈਲ ਵਿੱਚ ਕ੍ਰਮਵਾਰ ਲਿਖਤਾਂ ਦੀ ਇੱਕ ਲੜੀ ਦਾ ਇੱਕ ਲੋਡ ਬਣਾਉਣਾ ਚਾਹੀਦਾ ਹੈ, ਹਰੇਕ ਲਿਖਤ ਵਿੱਚ ਇੱਕ ਸਿਸਟਮ ਕਾਲ ਸ਼ਾਮਲ ਹੋਵੇਗੀ। ਲਿਖਣ ਦੀfdatasync ਸਿਸਟਮ ਕਾਲ ਤੋਂ ਬਾਅਦ। fio ਨੂੰ ਕ੍ਰਮਵਾਰ ਲਿਖਣ ਲਈ --rw=write ਵਿਕਲਪ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। fio ਲਈ ਲਿਖਣ ਵੇਲੇ, ਨਾ ਕਿ ਲਿਖਣ ਵੇਲੇ ਰਾਈਟ ਸਿਸਟਮ ਕਾਲ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਲਿਖੋ, ਤੁਹਾਨੂੰ --ioengine=sync ਪੈਰਾਮੀਟਰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਅੰਤ ਵਿੱਚ, ਹਰੇਕ ਲਿਖਤ ਤੋਂ ਬਾਅਦ fdatasync ਨੂੰ ਕਾਲ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ --fdatasync=1 ਪੈਰਾਮੀਟਰ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਹੋਰ ਦੋ ਵਿਕਲਪ (--ਆਕਾਰ ਅਤੇ -bs) ਸਕ੍ਰਿਪਟ-ਵਿਸ਼ੇਸ਼ ਹਨ। ਅਗਲੇ ਭਾਗ ਵਿੱਚ, ਅਸੀਂ ਤੁਹਾਨੂੰ ਦਿਖਾਵਾਂਗੇ ਕਿ ਉਹਨਾਂ ਨੂੰ ਕਿਵੇਂ ਸੈੱਟ ਕਰਨਾ ਹੈ।

fio ਕਿਉਂ ਅਤੇ ਅਸੀਂ ਇਸਨੂੰ ਕਿਵੇਂ ਸੈੱਟ ਕਰਨਾ ਸਿੱਖਿਆ

ਇਸ ਪੋਸਟ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਅਸਲ ਕੇਸ ਦਾ ਵਰਣਨ ਕਰਦੇ ਹਾਂ. ਸਾਡੇ ਕੋਲ ਇੱਕ ਕਲੱਸਟਰ ਹੈ ਕਬਰਨੇਟਿਸ v1.13 ਜਿਸਦੀ ਅਸੀਂ ਪ੍ਰੋਮੀਥੀਅਸ ਨਾਲ ਨਿਗਰਾਨੀ ਕੀਤੀ। etcd v3.2.24 ਨੂੰ ਇੱਕ SSD ਉੱਤੇ ਹੋਸਟ ਕੀਤਾ ਗਿਆ ਸੀ। Etcd ਮੈਟ੍ਰਿਕਸ ਨੇ fdatasync ਲੇਟੈਂਸੀਆਂ ਨੂੰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਦਿਖਾਇਆ, ਭਾਵੇਂ ਕਲੱਸਟਰ ਕੁਝ ਨਹੀਂ ਕਰ ਰਿਹਾ ਸੀ। ਮੈਟ੍ਰਿਕਸ ਅਜੀਬ ਸਨ ਅਤੇ ਸਾਨੂੰ ਅਸਲ ਵਿੱਚ ਨਹੀਂ ਪਤਾ ਸੀ ਕਿ ਉਹਨਾਂ ਦਾ ਕੀ ਮਤਲਬ ਹੈ। ਕਲੱਸਟਰ ਵਿੱਚ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਸ਼ਾਮਲ ਸਨ, ਇਹ ਸਮਝਣਾ ਜ਼ਰੂਰੀ ਸੀ ਕਿ ਸਮੱਸਿਆ ਕੀ ਸੀ: ਭੌਤਿਕ SSD ਵਿੱਚ ਜਾਂ ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਲੇਅਰ ਵਿੱਚ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਅਸੀਂ ਅਕਸਰ ਹਾਰਡਵੇਅਰ ਅਤੇ ਸੌਫਟਵੇਅਰ ਸੰਰਚਨਾ ਵਿੱਚ ਬਦਲਾਅ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਸਾਨੂੰ ਉਹਨਾਂ ਦੇ ਨਤੀਜਿਆਂ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਲਈ ਇੱਕ ਤਰੀਕੇ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਅਸੀਂ ਹਰ ਸੰਰਚਨਾ ਵਿੱਚ etcd ਚਲਾ ਸਕਦੇ ਹਾਂ ਅਤੇ ਪ੍ਰੋਮੀਥੀਅਸ ਮੈਟ੍ਰਿਕਸ ਨੂੰ ਦੇਖ ਸਕਦੇ ਹਾਂ, ਪਰ ਇਹ ਬਹੁਤ ਜ਼ਿਆਦਾ ਮੁਸ਼ਕਲ ਹੈ। ਅਸੀਂ ਇੱਕ ਖਾਸ ਸੰਰਚਨਾ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਲਈ ਇੱਕ ਕਾਫ਼ੀ ਸਰਲ ਤਰੀਕਾ ਲੱਭ ਰਹੇ ਸੀ। ਅਸੀਂ ਜਾਂਚ ਕਰਨਾ ਚਾਹੁੰਦੇ ਸੀ ਕਿ ਕੀ ਅਸੀਂ etcd ਤੋਂ ਪ੍ਰੋਮੀਥੀਅਸ ਮੈਟ੍ਰਿਕਸ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸਮਝਦੇ ਹਾਂ।

ਪਰ ਇਸ ਦੇ ਲਈ ਦੋ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨਾ ਪਿਆ। ਪਹਿਲਾਂ, WAL ਨੂੰ ਲਿਖਣ ਵੇਲੇ etcd ਬਣਾਉਣ ਵਾਲਾ I/O ਲੋਡ ਕਿਹੋ ਜਿਹਾ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ? ਕਿਹੜੀਆਂ ਸਿਸਟਮ ਕਾਲਾਂ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ? ਰਿਕਾਰਡਾਂ ਦਾ ਆਕਾਰ ਕੀ ਹੈ? ਦੂਸਰਾ, ਜੇਕਰ ਅਸੀਂ ਇਹਨਾਂ ਸਵਾਲਾਂ ਦੇ ਜਵਾਬ ਦਿੰਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਫਿਓ ਨਾਲ ਸਮਾਨ ਵਰਕਲੋਡ ਨੂੰ ਕਿਵੇਂ ਦੁਬਾਰਾ ਤਿਆਰ ਕਰਦੇ ਹਾਂ? ਇਹ ਨਾ ਭੁੱਲੋ ਕਿ fio ਬਹੁਤ ਸਾਰੇ ਵਿਕਲਪਾਂ ਵਾਲਾ ਇੱਕ ਬਹੁਤ ਹੀ ਲਚਕਦਾਰ ਟੂਲ ਹੈ। ਅਸੀਂ ਦੋਵੇਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਇੱਕ ਪਹੁੰਚ ਨਾਲ ਹੱਲ ਕੀਤਾ - ਕਮਾਂਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ lsof и ਸਟਰੇਸ. lsof ਪ੍ਰਕਿਰਿਆ ਦੁਆਰਾ ਵਰਤੇ ਗਏ ਸਾਰੇ ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰਾਂ ਅਤੇ ਉਹਨਾਂ ਨਾਲ ਸੰਬੰਧਿਤ ਫਾਈਲਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰਦਾ ਹੈ। ਅਤੇ ਸਟ੍ਰੈਸ ਦੇ ਨਾਲ, ਤੁਸੀਂ ਪਹਿਲਾਂ ਤੋਂ ਚੱਲ ਰਹੀ ਪ੍ਰਕਿਰਿਆ ਦੀ ਜਾਂਚ ਕਰ ਸਕਦੇ ਹੋ, ਜਾਂ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਦੀ ਜਾਂਚ ਕਰ ਸਕਦੇ ਹੋ। strace ਜਾਂਚ ਕੀਤੀ ਜਾ ਰਹੀ ਪ੍ਰਕਿਰਿਆ (ਅਤੇ ਇਸ ਦੀਆਂ ਚਾਈਲਡ ਪ੍ਰਕਿਰਿਆਵਾਂ) ਤੋਂ ਸਾਰੀਆਂ ਸਿਸਟਮ ਕਾਲਾਂ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ। ਬਾਅਦ ਵਾਲਾ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਕਿਉਂਕਿ etcd ਸਿਰਫ ਇੱਕ ਸਮਾਨ ਪਹੁੰਚ ਅਪਣਾ ਰਿਹਾ ਹੈ.

ਅਸੀਂ ਪਹਿਲਾਂ ਕੁਬਰਨੇਟਸ ਲਈ etcd ਸਰਵਰ ਦੀ ਪੜਚੋਲ ਕਰਨ ਲਈ ਸਟਰੇਸ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਦੋਂ ਕਲੱਸਟਰ 'ਤੇ ਕੋਈ ਲੋਡ ਨਹੀਂ ਸੀ। ਅਸੀਂ ਦੇਖਿਆ ਕਿ ਲਗਭਗ ਸਾਰੇ WAL ਰਿਕਾਰਡ ਇੱਕੋ ਆਕਾਰ ਦੇ ਸਨ: 2200-2400 ਬਾਈਟ। ਇਸਲਈ, ਪੋਸਟ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਕਮਾਂਡ ਵਿੱਚ, ਅਸੀਂ ਪੈਰਾਮੀਟਰ -bs=2300 (bs ਦਾ ਮਤਲਬ ਹੈ ਹਰੇਕ fio ਐਂਟਰੀ ਲਈ ਬਾਈਟਸ ਵਿੱਚ ਆਕਾਰ) ਨੂੰ ਨਿਰਧਾਰਿਤ ਕੀਤਾ ਹੈ। ਨੋਟ ਕਰੋ ਕਿ etcd ਐਂਟਰੀ ਦਾ ਆਕਾਰ etcd ਸੰਸਕਰਣ, ਵੰਡ, ਪੈਰਾਮੀਟਰ ਮੁੱਲ, ਆਦਿ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਅਤੇ fdatasync ਮਿਆਦ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਵੀ ਅਜਿਹਾ ਹੀ ਦ੍ਰਿਸ਼ ਹੈ, ਤਾਂ ਸਹੀ ਸੰਖਿਆਵਾਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਸਟਰੇਸ ਨਾਲ ਆਪਣੀਆਂ etcd ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੀ ਜਾਂਚ ਕਰੋ।

ਫਿਰ, etcd ਫਾਈਲ ਸਿਸਟਮ ਕੀ ਕਰ ਰਿਹਾ ਹੈ ਇਸ ਬਾਰੇ ਚੰਗੀ ਤਰ੍ਹਾਂ ਵਿਚਾਰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਅਸੀਂ ਇਸਨੂੰ ਸਟ੍ਰੈਸ ਅਤੇ -ffttT ਵਿਕਲਪਾਂ ਨਾਲ ਸ਼ੁਰੂ ਕੀਤਾ ਹੈ। ਇਸ ਲਈ ਅਸੀਂ ਚਾਈਲਡ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਅਤੇ ਉਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਦੇ ਆਉਟਪੁੱਟ ਨੂੰ ਇੱਕ ਵੱਖਰੀ ਫਾਈਲ ਵਿੱਚ ਰਿਕਾਰਡ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ, ਅਤੇ ਹਰੇਕ ਸਿਸਟਮ ਕਾਲ ਦੀ ਸ਼ੁਰੂਆਤ ਅਤੇ ਮਿਆਦ ਬਾਰੇ ਵਿਸਤ੍ਰਿਤ ਰਿਪੋਰਟਾਂ ਵੀ ਪ੍ਰਾਪਤ ਕੀਤੀਆਂ। ਅਸੀਂ ਸਟ੍ਰੈਸ ਆਉਟਪੁੱਟ ਦੇ ਸਾਡੇ ਵਿਸ਼ਲੇਸ਼ਣ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ lsof ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ ਅਤੇ ਇਹ ਦੇਖਣ ਲਈ ਕਿ ਕਿਹੜੀ ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ ਕਿਸ ਮਕਸਦ ਲਈ ਵਰਤਿਆ ਜਾ ਰਿਹਾ ਸੀ। ਇਸ ਲਈ ਸਟਰੇਸ ਦੀ ਮਦਦ ਨਾਲ, ਉੱਪਰ ਦਿਖਾਏ ਗਏ ਨਤੀਜੇ ਪ੍ਰਾਪਤ ਕੀਤੇ ਗਏ ਸਨ. ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਸਮੇਂ ਦੇ ਅੰਕੜਿਆਂ ਨੇ ਪੁਸ਼ਟੀ ਕੀਤੀ ਹੈ ਕਿ etcd ਤੋਂ wal_fsync_duration_seconds WAL ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰਾਂ ਨਾਲ fdatasync ਕਾਲਾਂ ਨਾਲ ਇਕਸਾਰ ਹੈ।

ਅਸੀਂ fio ਲਈ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚੋਂ ਲੰਘੇ ਅਤੇ ਸਾਡੀ ਸਕ੍ਰਿਪਟ ਲਈ ਵਿਕਲਪ ਚੁਣੇ ਤਾਂ ਜੋ fio etcd ਵਰਗਾ ਲੋਡ ਪੈਦਾ ਕਰੇ। ਅਸੀਂ ਸਟਰੇਸ ਤੋਂ fio ਚਲਾ ਕੇ ਸਿਸਟਮ ਕਾਲਾਂ ਅਤੇ ਉਹਨਾਂ ਦੀ ਮਿਆਦ ਦੀ ਵੀ ਜਾਂਚ ਕੀਤੀ, etcd ਵਾਂਗ।

ਅਸੀਂ fio ਤੋਂ ਪੂਰੇ I/O ਲੋਡ ਨੂੰ ਦਰਸਾਉਣ ਲਈ --size ਪੈਰਾਮੀਟਰ ਦੇ ਮੁੱਲ ਨੂੰ ਧਿਆਨ ਨਾਲ ਚੁਣਿਆ ਹੈ। ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਇਹ ਸਟੋਰੇਜ ਵਿੱਚ ਲਿਖੇ ਗਏ ਬਾਈਟਾਂ ਦੀ ਕੁੱਲ ਸੰਖਿਆ ਹੈ। ਇਹ ਰਾਈਟ (ਅਤੇ fdatasync) ਸਿਸਟਮ ਕਾਲਾਂ ਦੀ ਸੰਖਿਆ ਦੇ ਸਿੱਧੇ ਅਨੁਪਾਤਕ ਸਾਬਤ ਹੋਇਆ। bs ਦੇ ਇੱਕ ਨਿਸ਼ਚਿਤ ਮੁੱਲ ਲਈ, fdatasync ਕਾਲਾਂ ਦੀ ਸੰਖਿਆ = ਆਕਾਰ/bs। ਕਿਉਂਕਿ ਅਸੀਂ ਪਰਸੈਂਟਾਈਲ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਸੀ, ਸਾਡੇ ਕੋਲ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਾਫ਼ੀ ਨਮੂਨੇ ਹੋਣੇ ਸਨ, ਅਤੇ ਅਸੀਂ ਗਣਨਾ ਕੀਤੀ ਕਿ 10^4 ਸਾਡੇ ਲਈ ਕਾਫ਼ੀ ਹੋਵੇਗਾ (ਜੋ ਕਿ 22 ਮੈਬੀਬਾਈਟ ਹੈ)। ਜੇਕਰ --ਸਾਈਜ਼ ਛੋਟਾ ਹੈ, ਤਾਂ ਆਊਟਲੀਅਰ ਹੋ ਸਕਦੇ ਹਨ (ਉਦਾਹਰਨ ਲਈ, ਕਈ fdatasync ਕਾਲਾਂ ਆਮ ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਸਮਾਂ ਲੈਂਦੀਆਂ ਹਨ ਅਤੇ 99ਵੇਂ ਪ੍ਰਤੀਸ਼ਤ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੀਆਂ ਹਨ)।

ਇਸ ਨੂੰ ਆਪਣੇ ਆਪ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ

ਅਸੀਂ ਤੁਹਾਨੂੰ ਦਿਖਾਇਆ ਹੈ ਕਿ ਕਿਵੇਂ fio ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਹੈ ਅਤੇ ਦੇਖੋ ਕਿ ਕੀ ਸਟੋਰੇਜ ਚੰਗੀ ਤਰ੍ਹਾਂ ਪ੍ਰਦਰਸ਼ਨ ਕਰਨ ਲਈ etcd ਲਈ ਕਾਫ਼ੀ ਤੇਜ਼ ਹੈ। ਹੁਣ ਤੁਸੀਂ ਇਸਦੀ ਵਰਤੋਂ ਆਪਣੇ ਲਈ ਕਰ ਸਕਦੇ ਹੋ, ਉਦਾਹਰਨ ਲਈ, SSD ਸਟੋਰੇਜ ਵਾਲੀਆਂ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਆਈਬੀਐਮ ਬੱਦਲ.

ਸਰੋਤ: www.habr.com