Chan e eadhon fealla-dhà a tha seo, tha e coltach gu bheil an dealbh shònraichte seo gu cinnteach a’ nochdadh brìgh nan stòran-dàta sin, agus aig a’ cheann thall bidh e soilleir carson:
A rèir DB-Engines Ranking, is e an dà stòr-dàta colbh NoSQL as mòr-chòrdte Cassandra (CS an-seo) agus HBase (HB).
Le toil an dàn, tha an sgioba riaghlaidh luchdachadh dàta againn aig Sberbank mar-thà agus ag obair gu dlùth le HB. Rè na h-ùine seo, rinn sinn sgrùdadh math air a neartan agus laigsean agus dh'ionnsaich sinn mar a chòcaicheas sinn e. Ach, bha làthaireachd roghainn eile ann an cruth CS an-còmhnaidh a’ toirt oirnn a bhith gar cràdh fhèin beagan le teagamhan: an do rinn sinn an roghainn cheart? A bharrachd air an sin, na toraidhean , air a chluich le DataStax, thuirt iad gu bheil CS gu furasta a’ dèanamh a’ chùis air HB le cha mhòr sgòr pronnadh. Air an làimh eile, tha DataStax na phàrtaidh le ùidh, agus cha bu chòir dhut am facal aca a ghabhail air a shon. Bha sinn cuideachd air ar mealladh leis an ìre bheag de dh'fhiosrachadh mu na suidheachaidhean deuchainn, agus mar sin chuir sinn romhainn faighinn a-mach leinn fhìn cò a tha na rìgh air BigData NoSql, agus bha na toraidhean a fhuaireadh gu math inntinneach.
Ach, mus gluais thu air adhart gu toraidhean nan deuchainnean a chaidh a dhèanamh, feumar cunntas a thoirt air na taobhan cudromach de rèiteachaidhean na h-àrainneachd. Is e an fhìrinn gum faodar CS a chleachdadh ann am modh a leigeas le call dàta. An fheadhainn sin. Seo nuair nach eil ach aon fhrithealaiche (nód) an urra ri dàta iuchair sònraichte, agus ma dh’ fhailicheas e airson adhbhar air choireigin, thèid luach na h-iuchrach seo a chall. Airson mòran ghnìomhan chan eil seo riatanach, ach airson an roinn bancaidh is e seo an eisgeachd seach an riaghailt. Anns a 'chùis againn, tha e cudromach gum bi grunn lethbhreacan de dhàta ann airson stòradh earbsach.
Mar sin, cha deach beachdachadh ach air modh obrachaidh CS ann am modh ath-riochdachadh trì-fhillte, i.e. Chaidh cruthachadh àite-cùise a dhèanamh leis na crìochan a leanas:
CREATE KEYSPACE ks WITH REPLICATION = {'class' : 'NetworkTopologyStrategy', 'datacenter1' : 3};
An ath rud, tha dà dhòigh air dèanamh cinnteach gu bheil an ìre cunbhalachd a tha a dhìth. Riaghailt choitcheann:
NW + NR > RF
A tha a’ ciallachadh gum feum an àireamh de dhearbhaidhean bho nodan nuair a thathar a’ sgrìobhadh (NW) a bharrachd air an àireamh de dhearbhaidhean bho nodan nuair a thathar a’ leughadh (NR) a bhith nas àirde na am bàillidh mac-samhail. Anns a 'chùis againn, RF = 3, a tha a' ciallachadh gu bheil na roghainnean a leanas freagarrach:
2+2 >3
3+1 >3
Leis gu bheil e air leth cudromach dhuinn an dàta a stòradh cho earbsach ‘s a ghabhas, chaidh an sgeama 3+1 a thaghadh. A bharrachd air an sin, tha HB ag obair air an aon phrionnsapal, i.e. bidh coimeas mar sin nas cothromaiche.
Bu chòir a thoirt fa-near gun do rinn DataStax a chaochladh san sgrùdadh aca, shuidhich iad RF = 1 airson an dà chuid CS agus HB (airson an fheadhainn mu dheireadh le bhith ag atharrachadh roghainnean HDFS). Tha seo na phàirt fìor chudromach oir tha a’ bhuaidh air coileanadh CS sa chùis seo fìor mhòr. Mar eisimpleir, tha an dealbh gu h-ìosal a’ sealltainn an àrdachadh san ùine a dh’fheumar airson dàta a luchdachadh a-steach gu CS:
An seo chì sinn na leanas: mar as motha a bhios snàithleanan farpaiseach a’ sgrìobhadh dàta, is ann as fhaide a bheir e. Tha seo nàdarra, ach tha e cudromach gu bheil an ìsleachadh dèanadais airson RF = 3 gu math nas àirde. Ann am faclan eile, ma sgrìobhas sinn 4 snàithleanan ann an 5 bùird gach fear (20 gu h-iomlan), an uairsin bidh RF = 3 a’ call timcheall air 2 uair (150 diogan airson RF = 3 an aghaidh 75 airson RF = 1). Ach ma mheudaicheas sinn an luchd le bhith a’ luchdachadh dàta a-steach do bhùird 8 le 5 snàithleanan gach fear (40 gu h-iomlan), tha call RF = 3 mu thràth 2,7 tursan (375 diogan an aghaidh 138).
Is dòcha gu bheil seo gu ìre na dhìomhaireachd den deuchainn luchdan soirbheachail a rinn DataStax airson CS, oir airson HB nar seasamh cha robh buaidh sam bith aig atharrachadh a’ bhàillidh mac-samhail bho 2 gu 3. An fheadhainn sin. chan e diosgan an cnap-starra HB airson an rèiteachadh againn. Ach, tha mòran dhuilgheadasan eile an seo, oir bu chòir a thoirt fa-near gu robh an dreach againn de HB beagan air a ghleusadh agus air a thweaked, tha na h-àrainneachdan gu tur eadar-dhealaichte, msaa. Is fhiach a bhith mothachail cuideachd gur dòcha nach eil fios agam ciamar a dheasaicheas mi CS gu ceart agus gu bheil dòighean nas èifeachdaiche ann airson obrachadh leis, agus tha mi an dòchas gum faigh sinn a-mach anns na beachdan. Ach an toiseach rudan an-toiseach.
Chaidh a h-uile deuchainn a dhèanamh air cruinneachadh bathar-cruaidh anns an robh 4 frithealaichean, gach fear leis an rèiteachadh a leanas:
CPU: Xeon E5-2680 v4 @ 2.40GHz 64 snàithlean.
Diosg: 12 pìosan SATA HDD
tionndadh java: 1.8.0_111
Tionndadh CS: 3.11.5
paramadairean cassandra.ymlàireamh_tokens: 256
hinted_handoff_enabled: fìor
sanas_handoff_throttle_in_kb: 1024
max_hints_delivery_threads: 2
sanasan_directory: /data10/cassandra/hints
sanasan_flush_period_in_ms: 10000
max_hints_file_size_in_mb: 128
batchlog_replay_throttle_in_kb: 1024
dearbhadair: Ceadaich Uile Authenticator
ùghdar: AllowAllAuthorizer
role_manager: CassandraRoleManager
role_validity_in_ms: 2000
ceadan_dligheachd_ann an_ms: 2000
teisteanasan_validity_in_ms: 2000
partitioner: org.apache.cassandra.dht.Murmur3Partitioner
data_file_directories:
- / data1/cassandra/data # tha gach eòlaire dataN na diosc air leth
- /data2/cassandra/data
- /data3/cassandra/data
- /data4/cassandra/data
- /data5/cassandra/data
- /data6/cassandra/data
- /data7/cassandra/data
- /data8/cassandra/data
commitlog_directory: /data9/cassandra/commitlog
cdc_enabled: meallta
disk_failure_policy : stad
commit_failure_policy : stad
ullaichte_aithrisean_cache_size_mb:
thrift_prepared_statements_cache_size_mb:
key_cache_size_in_mb:
key_cache_save_period: 14400
row_cache_size_in_mb: 0
row_cache_save_period: 0
counter_cache_size_in_mb:
counter_cache_save_period: 7200
save_caches_directory: /data10/cassandra/saved_caches
commitlog_sync: ràitheil
commitlog_sync_period_in_ms: 10000
commitlog_segment_size_in_mb: 32
sìol_solaraiche:
- class_name: org.apache.cassandra.locator.SimpleSeedProvider
paramadairean:
- sìol: "*,*"
concurrent_reads: 256 # dh’fheuch 64 - cha do mhothaich diofar
concurrent_writes: 256 # dh’fheuch 64 - cha do mhothaich diofar
concurrent_counter_writes: 256 # dh’fheuch 64 - cha do mhothaich diofar
concurrent_materialized_view_writes: 32
memtable_heap_space_in_mb: 2048 # dh'fheuch 16 GB - bha e na bu shlaodaiche
memtable_allocation_type: heap_buffers
index_summary_capacity_in_mb:
index_summary_resize_interval_in_minutes: 60
trickle_fsync : ceàrr
trickle_fsync_interval_in_kb: 10240
port_stòraidh: 7000
ssl_storage_port: 7001
èist_seòladh: *
craoladh_seòladh: *
listen_on_broadcast_address : fìor
internode_authenticator: org.apache.cassandra.auth.AllowAllInternodeAuthenticator
start_native_transport : fìor
port_còmhdhail_dùthchasach: 9042
start_rpc: fìor
rpc_seòladh: *
rpc_port: 9160
rpc_keepalive: fìor
rpc_server_type: sioncranachadh
thrift_framed_transport_size_in_mb: 15
incremental_backups: ceàrr
snapshot_before_compaction: ceàrr
auto_snapshot: fìor
colbh_index_size_in_kb: 64
colbh_index_cache_size_in_kb: 2
Concurrent_compacors: 4
dlùthadh_throughput_mb_per_sec: 1600
sstable_preemptive_open_interval_in_mb: 50
read_request_timeout_in_ms: 100000
raon_request_timeout_in_ms: 200000
write_request_timeout_in_ms: 40000
counter_write_request_timeout_in_ms: 100000
cas_contention_timeout_in_ms: 20000
truncate_request_timeout_in_ms: 60000
iarrtas_timeout_in_ms: 200000
slow_query_log_timeout_in_ms: 500
cross_node_timeout : ceàrr
endpoint_snitch: GossipingPropertyFileSnitch
dynamic_snitch_update_interval_in_ms: 100
dynamic_snitch_reset_interval_in_ms: 600000
dynamic_snitch_badness_threshold: 0.1
request_scheduler: org.apache.cassandra.scheduler.NoScheduler
server_encryption_roghainnean:
internode_encryption: gin
client_encryption_roghainnean:
comasach: false
internode_compression: dc
inter_dc_tcp_nodelay: meallta
lorg seòrsa_query_ttl: 86400
tracetype_càradh_ttl: 604800
enable_user_defined_functions: ceàrr
enable_scripted_user_defined_functions: ceàrr
uinneagan_timer_interval: 1
trédhearcach_data_encryption_roghainnean:
comasach: false
Tombstone_warn_threshold: 1000
tombstone_failure_threshold: 100000
baidse_size_warn_threshold_in_kb: 200
baidse_size_fail_threshold_in_kb: 250
unlogged_batch_across_partitions_warn_threshold: 10
dlùthadh_large_partition_rabhadh_threshold_mb: 100
gc_warn_threshold_in_ms: 1000
back_pressure_enabled: ceàrr
enable_materialized_views : fìor
enable_sasi_indexes : fìor
Roghainnean GC:
### roghainnean CMS-XX:+CleachdParNewGC
-XX:+CleachdConcMarkSweepGC
-XX:+CMSParallelRemark comas
-XX:SurvivorRatio=8
-XX: MaxTenuringThreshold=1
-XX:CMSInitiatingOccupancyFraction=75
-XX:+Cleachd CMSI a’ tòiseachadh Seilbh a-mhàin
-XX:CMSWaitDuration=10000
-XX:+CMPparallelInitialMarkEnable
-XX:+CMSEdenChunksRecord an-còmhnaidh
-XX:+CMSClassUnloadingEnable
Chaidh 16Gb a thoirt don chuimhne jvm.options (dh’ fheuch sinn cuideachd 32 Gb, cha deach diofar a thoirt fa-near).
Chaidh na bùird a chruthachadh leis an àithne:
CREATE TABLE ks.t1 (id bigint PRIMARY KEY, title text) WITH compression = {'sstable_compression': 'LZ4Compressor', 'chunk_length_kb': 64};Tionndadh HB: 1.2.0-cdh5.14.2 (anns a’ chlas org.apache.hadoop.hbase.regionserver.HRegion chuir sinn a-mach MetricsRegion a lean gu GC nuair a bha an àireamh de roinnean nas àirde na 1000 air RegionServer)
Paramadairean HBase neo-àbhaisteachzookeeper.session.timeout: 120000
hbase.rpc.timeout: 2 mhionaid (ean)
hbase.client.scanner.timeout.period: 2 mhionaid (ean)
hbase.master.handler.count: 10
hbase.regionserver.lease.period, hbase.client.scanner.timeout.period: 2 mhionaid (ean)
hbase.regionserver.handler.count: 160
hbase.regionserver.metahandler.count:30
hbase.regionserver.logroll.period: 4 uairean (ean)
hbase.regionserver.maxlogs: 200
hbase.hregion.memstore.flush.size: 1 GiB
hbase.hregion.memstore.block.multiplier: 6
hbase.hstore.compactionThreshold: 5
hbase.hstore.blockingStoreFiles: 200
hbase.hregion.majorcompacion: 1 latha (ean)
Snippet Rèiteachaidh Adhartach Seirbheis HBase (Balbhaiche Sàbhailteachd) airson hbase-site.xml:
hbase.regionserver.wal.codecorg.apache.hadoop.hbase.regionserver.wal.IndexedWALEditCodec
hbase.master.namespace.init.timeout3600000
hbase.regionserver.optionalcacheflushinterval18000000
hbase.regionserver.thread.compaction.large12
hbase.regionserver.wal.comasachadh compression fìor
hbase.hstore.compaction.max.size1073741824
hbase.server.compactchecker.interval.multiplier200
Roghainnean rèiteachaidh Java airson HBase RegionServer:
-XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:CMSInitiatingOccupancyFraction=70 -XX:+CMSParallelRemarkEnabled -XX:ReservedCodeCacheSize=256m
hbase.snapshot.master.timeoutMillis: 2 mhionaid (ean)
hbase.snapshot.region.timeout: 2 mhionaid(ean)
hbase.snapshot.master.timeout.millis: 2 mhionaid (ean)
HBase REST Server Max Log Meud: 100 MiB
HBase REST Server Cùl-taic faidhle log as àirde: 5
HBase Thrift Server Max Log Meud: 100 MiB
Cùl-taic faidhle log as àirde HBase Server Thrift: 5
Meud Log Master Max: 100 MiB
Maighstir cùl-taic faidhle log as àirde: 5
Meud Loga RegionServer Max: 100 MiB
RegionServer Cùl-taic faidhle log as àirde: 5
Uinneag Lorgaidh Maighstir Gnìomhach HBase: 4 mionaidean (ean)
dfs.client.hedged.read.threadpool.size: 40
dfs.client.hedged.read.threshold.millis: 10 millisecond (ean)
hbase.rest.threads.min: 8
hbase.rest.threads.max: 150
Tuairisgeulan faidhle pròiseas as àirde: 180000
hbase.thrift.minWorkerThreads: 200
hbase.master.executor.openregion.threads: 30
hbase.master.executor.closerregion.threads: 30
hbase.master.executor.serverops.threads: 60
hbase.regionserver.thread.compaction.small: 6
hbase.ipc.server.read.threadpool.size: 20
Snàthainn gluasad sgìre: 6
Meud cruachan Java teachdaiche ann am Bytes: 1 GiB
Buidheann bunaiteach frithealaiche HBase REST: 3 GiB
Buidheann bunaiteach frithealaiche HBase Thrift: 3 GiB
Meud Java Heap de HBase Master ann am Bytes: 16 GiB
Meud Java Heap de fhrithealaiche sgìre HBase ann am Bytes: 32 GiB
+ Neach-glèidhidh sù
ClientCnxns as àirde: 601
Ùine an t-Seisein as àirde: 120000
A’ cruthachadh chlàran:
hbase org.apache.hadoop.hbase.util.RegionSplitter ns: t1 UniformSplit -c 64 -f cf
atharraich 'ns:t1', {NAME => 'cf', DATA_BLOCK_ENCODING => 'FAST_DIFF', COMPRESSION => 'GZ'}
Tha aon phuing chudromach an seo - chan eil an tuairisgeul DataStax ag ràdh cia mheud roinn a chaidh a chleachdadh gus clàran HB a chruthachadh, ged a tha seo deatamach airson meudan mòra. Mar sin, airson na deuchainnean, chaidh meud = 64 a thaghadh, a leigeas le stòradh suas ri 640 GB, i.e. clàr meud meadhanach.
Aig àm na deuchainn, bha 22 mìle clàr aig HBase agus 67 mìle roinn (bhiodh seo air a bhith marbhtach airson dreach 1.2.0 mura biodh e airson a’ phìos gu h-àrd).
A-nis airson a 'chòd. Leis nach robh e soilleir dè na rèiteachaidhean a bha na bu bhuannachdaile airson stòr-dàta sònraichte, chaidh deuchainnean a dhèanamh ann an grunn choimeasgaidhean. An fheadhainn sin. ann an cuid de dheuchainnean, chaidh clàran 4 a luchdachadh aig an aon àm (chaidh na 4 nodan a chleachdadh airson ceangal). Ann an deuchainnean eile dh’obraich sinn le 8 bùird eadar-dhealaichte. Ann an cuid de chùisean, b 'e meud a' bhaidse 100, ann an cuid eile 200 (paramadair baidse - faic an còd gu h-ìosal). Is e meud an dàta airson luach 10 bytes no 100 bytes (dataSize). Uile gu lèir, chaidh 5 millean clàr a sgrìobhadh agus a leughadh anns gach clàr gach turas. Aig an aon àm, chaidh 5 snàithleanan a sgrìobhadh / a leughadh gu gach clàr (àireamh snàthainn - thNum), agus chleachd gach fear dhiubh a raon iuchraichean fhèin (cunntadh = 1 millean):
if (opType.equals("insert")) {
for (Long key = count * thNum; key < count * (thNum + 1); key += 0) {
StringBuilder sb = new StringBuilder("BEGIN BATCH ");
for (int i = 0; i < batch; i++) {
String value = RandomStringUtils.random(dataSize, true, true);
sb.append("INSERT INTO ")
.append(tableName)
.append("(id, title) ")
.append("VALUES (")
.append(key)
.append(", '")
.append(value)
.append("');");
key++;
}
sb.append("APPLY BATCH;");
final String query = sb.toString();
session.execute(query);
}
} else {
for (Long key = count * thNum; key < count * (thNum + 1); key += 0) {
StringBuilder sb = new StringBuilder("SELECT * FROM ").append(tableName).append(" WHERE id IN (");
for (int i = 0; i < batch; i++) {
sb = sb.append(key);
if (i+1 < batch)
sb.append(",");
key++;
}
sb = sb.append(");");
final String query = sb.toString();
ResultSet rs = session.execute(query);
}
}
Mar sin, chaidh gnìomhan coltach ris a thoirt seachad airson HB:
Configuration conf = getConf();
HTable table = new HTable(conf, keyspace + ":" + tableName);
table.setAutoFlush(false, false);
List<Get> lGet = new ArrayList<>();
List<Put> lPut = new ArrayList<>();
byte[] cf = Bytes.toBytes("cf");
byte[] qf = Bytes.toBytes("value");
if (opType.equals("insert")) {
for (Long key = count * thNum; key < count * (thNum + 1); key += 0) {
lPut.clear();
for (int i = 0; i < batch; i++) {
Put p = new Put(makeHbaseRowKey(key));
String value = RandomStringUtils.random(dataSize, true, true);
p.addColumn(cf, qf, value.getBytes());
lPut.add(p);
key++;
}
table.put(lPut);
table.flushCommits();
}
} else {
for (Long key = count * thNum; key < count * (thNum + 1); key += 0) {
lGet.clear();
for (int i = 0; i < batch; i++) {
Get g = new Get(makeHbaseRowKey(key));
lGet.add(g);
key++;
}
Result[] rs = table.get(lGet);
}
}
Leis gum feum an neach-dèiligidh ann an HB aire a thoirt do sgaoileadh èideadh dàta, bha coltas mar seo air a’ phrìomh obair sailleadh:
public static byte[] makeHbaseRowKey(long key) {
byte[] nonSaltedRowKey = Bytes.toBytes(key);
CRC32 crc32 = new CRC32();
crc32.update(nonSaltedRowKey);
long crc32Value = crc32.getValue();
byte[] salt = Arrays.copyOfRange(Bytes.toBytes(crc32Value), 5, 7);
return ArrayUtils.addAll(salt, nonSaltedRowKey);
}
A-nis am pàirt as inntinniche - na toraidhean:
An aon rud ann an cruth grafa:
Tha buannachd HB cho iongantach gu bheil amharas ann gu bheil cnap-starra de sheòrsa air choreigin ann an suidheachadh CS. Ach, cha do luathaich Googling agus a bhith a’ lorg nam paramadairean as fhollaisiche (leithid concurrent_writes no memtable_heap_space_in_mb) cùisean. Aig an aon àm, tha na logaichean glan agus chan eil iad a 'mionnachadh dad.
Chaidh an dàta a sgaoileadh gu cothromach thairis air na nodan, bha na staitistig bho gach nod timcheall air an aon rud.
Seo mar a tha staitistig a’ bhùird coltach bho aon de na nodanPrìomh àite: ks
Cunnt leughaidh: 9383707
Leugh Latency: 0.04287025042448576 ms
Sgrìobh Cunntas: 15462012
Sgrìobh Latency: 0.1350068438699957 ms
Sruthan ri feitheamh: 0
Clàr: t1
Cunntas SSTable: 16
Àite air a chleachdadh (beò): 148.59 MiB
Àite air a chleachdadh (iomlan): 148.59 MiB
Àite air a chleachdadh le snapshots (iomlan): 0 bytes
Cuimhne far tiùrr air a chleachdadh (iomlan): 5.17 MiB
Co-mheas teannachaidh SSTable: 0.5720989576459437
An àireamh de phàirtean (tuairmse): 3970323
Cunntas cealla memtable: 0
Meud dàta memtable: 0 bytes
Memtable far cuimhne tiùrr air a chleachdadh: 0 bytes
Cunntas suidse memtable: 5
Cunntas leughaidh ionadail: 2346045
Ùine leughaidh ionadail: NaN ms
Cunntas sgrìobhaidh ionadail: 3865503
Ùine sgrìobhaidh ionadail: NaN ms
Sruthan ri feitheamh: 0
Ceud sa cheud air a chàradh: 0.0
Filter Bloom nithean ceàrr: 25
Co-mheas meallta sìoltachain Bloom: 0.00000
Àite sìoltachain Bloom air a chleachdadh: 4.57 MiB
Criathrag Bloom far cuimhne tiùrr air a chleachdadh: 4.57 MiB
Geàrr-chunntas clàr-amais far cuimhne tiùrr a chaidh a chleachdadh: 590.02 KiB
Meata-dàta teannachaidh far cuimhne tiùrr air a chleachdadh: 19.45 KiB
Pàirtean teann as ìsle bytes: 36
Pàirtean teann as àirde bytes: 42
Pàirteachadh teannaichte a’ ciallachadh bytes: 42
Ceallan beò cuibheasach gach sliseag (còig mionaidean mu dheireadh): NaN
Na ceallan beò as àirde airson gach sliseag (còig mionaidean mu dheireadh): 0
Clach-uaighe cuibheasach gach sliseag (còig mionaidean mu dheireadh): NaN
An ìre as àirde de chlachan-uaighe gach sliseag (còig mionaidean mu dheireadh): 0
Mùthaidhean air tuiteam: 0 bytes
Cha robh buaidh sam bith aig oidhirp air meud a’ bhaidse a lughdachadh (eadhon ga chuir leotha fhèin), cha do dh’ fhàs e ach na bu mhiosa. Tha e comasach gur e seo dha-rìribh an coileanadh as àirde airson CS, leis gu bheil na toraidhean a gheibhear airson CS coltach ris an fheadhainn a gheibhear airson DataStax - timcheall air ceudan de mhìltean de ghnìomhachd san diog. A bharrachd air an sin, ma choimheadas sinn air cleachdadh ghoireasan, chì sinn gu bheil CS a’ cleachdadh tòrr a bharrachd CPU agus diosgan:
Tha am figear a’ sealltainn mar a chaidh a h-uile deuchainn ann an sreath a chleachdadh airson an dà stòr-dàta.
A thaobh buannachd leughaidh cumhachdach HB. An seo chì thu, airson an dà stòr-dàta, gu bheil cleachdadh diosc aig àm leughaidh gu math ìosal (is e deuchainnean leughaidh am pàirt mu dheireadh den chearcall deuchainn airson gach stòr-dàta, mar eisimpleir airson CS tha seo bho 15:20 gu 15:40). Ann an cùis HB, tha an t-adhbhar soilleir - tha a 'mhòr-chuid den dàta a' crochadh mar chuimhneachan, anns a 'mhemstore, agus tha cuid air a thasgadh ann an blockcache. A thaobh CS, chan eil e gu math soilleir ciamar a dh’ obraicheas e, ach chan eil ath-chuairteachadh diosc ri fhaicinn cuideachd, ach air eagal ’s gun deach oidhirp a dhèanamh gus an tasgadan row_cache_size_in_mb = 2048 a chomasachadh agus caching a shuidheachadh = { ‘iuchraichean’: ‘ALL’, 'rows_per_partition': ' 2000000'}, ach rinn sin e beagan na bu mhiosa buileach.
Is fhiach cuideachd iomradh a thoirt a-rithist air puing chudromach mun àireamh de roinnean ann am HB. Anns a 'chùis againn, chaidh an luach a shònrachadh mar 64. Ma lùghdaicheas tu e agus dèan e co-ionnan ri, mar eisimpleir, 4, an uairsin nuair a bhios tu a' leughadh, bidh an astar a 'tuiteam le 2 uair. Is e an adhbhar gum bi memstore a’ lìonadh nas luaithe agus gun tèid faidhlichean a sruthadh nas trice agus nuair a bhios iad gan leughadh, feumar barrachd fhaidhlichean a phròiseasadh, rud a tha gu math toinnte airson HB. Ann an suidheachaidhean fìor, faodar seo a làimhseachadh le bhith a’ smaoineachadh tro ro-innleachd presplitting agus compactification; gu sònraichte, bidh sinn a’ cleachdadh goireas fèin-sgrìobhte a bhios a’ cruinneachadh sgudal agus a’ teannachadh HFiles an-còmhnaidh air a’ chùl. Tha e gu math comasach airson deuchainnean DataStax nach tug iad seachad ach 1 roinn gach clàr (rud nach eil ceart) agus bhiodh seo a’ soilleireachadh carson a bha HB cho ìosal anns na deuchainnean leughaidh aca.
Tha na co-dhùnaidhean tòiseachaidh a leanas air an tarraing bho seo. A’ gabhail ris nach deach mearachdan mòra sam bith a dhèanamh rè na deuchainn, tha Cassandra coltach ri colossus le casan crèadha. Nas mionaidiche, fhad 'sa tha i a' cothromachadh air aon chas, mar a tha san dealbh aig toiseach an artaigil, tha i a 'sealltainn toraidhean coimeasach math, ach ann an sabaid fo na h-aon chumhachan bidh i a' call gu tur. Aig an aon àm, a’ gabhail a-steach cleachdadh ìosal CPU air ar bathar-cruaidh, dh’ ionnsaich sinn dà HB RegionServer a chur airson gach aoigh agus mar sin dhùblaich sinn an coileanadh. An fheadhainn sin. A’ gabhail a-steach cleachdadh ghoireasan, tha suidheachadh CS eadhon nas miosa.
Gu dearbh, tha na deuchainnean sin gu math synthetigeach agus tha an ìre de dhàta a chaidh a chleachdadh an seo gu ìre mhath beag. Tha e comasach nan atharraich sinn gu terabytes, gum biodh an suidheachadh eadar-dhealaichte, ach ged as urrainn dhuinn terabytes a luchdachadh airson HB, airson CS bha seo na dhuilgheadas. Gu tric thilg e OperationTimedOutException eadhon leis na leabhraichean sin, ged a chaidh na crìochan airson feitheamh ri freagairt àrdachadh grunn thursan mar-thà an taca ris an fheadhainn àbhaisteach.
Tha mi an dòchas tro cho-oidhirpean gun lorg sinn na botail CS agus mas urrainn dhuinn a luathachadh, an uairsin aig deireadh na dreuchd cuiridh mi gu cinnteach fiosrachadh mu na toraidhean deireannach.
UPD: Taing do chomhairle chompanaich, chaidh agam air an leughadh a luathachadh. Bha:
159 ops (644 bùird, 4 sruthan, baidse 5).
Air a chur ris le:
.withLoadBalancingPolicy(Policy TokenAware ùr(DCAwareRoundRobinPolicy.builder().build()))
Agus chluich mi mun cuairt leis an àireamh de snàithleanan. Tha an toradh mar a leanas:
4 bùird, 100 snàithlean, baidse = 1 (pìos air pìos): 301 ops
4 bùird, 100 snàithlean, baidse = 10: 447 ops
4 bùird, 100 snàithlean, baidse = 100: 625 ops
Nas fhaide air adhart cuiridh mi molaidhean gleusaidh eile an sàs, ruith làn chearcall deuchainn agus cuiridh mi na toraidhean aig deireadh na dreuchd.
Source: www.habr.com