పాఠాలు
ప్రారంభించండి
నేర్చుకోవడం ప్రారంభించండి
ఇప్పుడే నేర్చుకోవడం ప్రారంభించండి
కోడ్‌జిమ్/జావా కోర్సు/All lectures for TE purposes/బిగ్‌డేటా: HBase

బిగ్‌డేటా: HBase

All lectures for TE purposes
స్థాయి, పాఠం
అందుబాటులో ఉంది

6.1 HBaseని ఎవరు కనుగొన్నారు మరియు ఎందుకు

ఈ ఉపన్యాసంలో, మేము Hbase వంటి అద్భుతమైన సాధనం గురించి మాట్లాడుతాము, ఇది ఇటీవల గొప్ప ప్రజాదరణ పొందింది: ఉదాహరణకు, Facebook దాని సందేశ వ్యవస్థ యొక్క ఆధారం వలె ఉపయోగిస్తుంది మరియు ఇది ఇప్పటికే చాలా చెప్పింది.

ఈ ఉపన్యాసం బిగ్ టేబుల్ యొక్క భావన మరియు దాని ఉచిత అమలు, పని యొక్క లక్షణాలు మరియు క్లాసికల్ రిలేషనల్ డేటాబేస్‌లు (MySQL మరియు ఒరాకిల్ వంటివి) మరియు రెడిస్, ఏరోస్పైక్ మరియు మెమ్‌క్యాచెడ్ వంటి కీలక-విలువ స్టోరేజీల నుండి తేడా గురించి మాట్లాడుతుంది. ఎప్పటిలాగే, సమస్య యొక్క చరిత్రతో ప్రారంభిద్దాం. అనేక ఇతర BigData ప్రాజెక్ట్‌ల మాదిరిగానే, Hbase Google అభివృద్ధి చేసిన కాన్సెప్ట్ నుండి పుట్టింది. Hbase వెనుక ఉన్న సూత్రాలు Bigtable: A Distributed Storage System for Structured Data కథనంలో వివరించబడ్డాయి .

మేము మునుపటి ఉపన్యాసాలలో చర్చించినట్లుగా, MapReduce నమూనాను ఉపయోగించి బ్యాచ్ డేటా ప్రాసెసింగ్ కోసం సాధారణ ఫైల్‌లు బాగా సరిపోతాయి. మరోవైపు, ఫైల్‌లలో నిల్వ చేయబడిన సమాచారం నవీకరించడానికి అసౌకర్యంగా ఉంటుంది; ఫైల్‌లు యాదృచ్ఛిక యాక్సెస్‌ను కూడా కోల్పోతాయి. యాదృచ్ఛిక ప్రాప్యతతో శీఘ్ర మరియు అనుకూలమైన పని కోసం, Aerospike, Redis, Couchbase, Memcached వంటి కీ-విలువ నిల్వ వంటి nosql వ్యవస్థల తరగతి ఉంది. అయితే, ఈ వ్యవస్థల్లో బ్యాచ్ ప్రాసెసింగ్ సాధారణంగా చాలా అసౌకర్యంగా ఉంటుంది. Hbase అనేది బ్యాచ్ ప్రాసెసింగ్ సౌలభ్యాన్ని అప్‌డేట్ చేయడం మరియు యాదృచ్ఛిక యాక్సెస్ సౌలభ్యంతో మిళితం చేసే ప్రయత్నం.

6.2 డేటా మోడల్

HBase అనేది పంపిణీ చేయబడిన, కాలమ్-ఆధారిత, మల్టీవర్షన్ కీ-విలువ డేటాబేస్.

  • డేటా Hbaseలో RowKey అనే ప్రాథమిక కీ ద్వారా సూచిక చేయబడిన పట్టికలుగా నిర్వహించబడుతుంది.
  • ప్రతి RowKey కీ కోసం, అపరిమిత సెట్ అట్రిబ్యూట్‌లు (లేదా నిలువు వరుసలు) నిల్వ చేయబడతాయి.
  • నిలువు వరుసలు కాలమ్ ఫ్యామిలీ అని పిలువబడే నిలువు వరుసల సమూహాలుగా నిర్వహించబడతాయి. నియమం ప్రకారం, ఒకే విధమైన వినియోగం మరియు నిల్వ నమూనాను కలిగి ఉన్న నిలువు వరుసలు ఒక నిలువు కుటుంబంగా మిళితం చేయబడతాయి.
  • ప్రతి లక్షణం కోసం, అనేక విభిన్న సంస్కరణలు నిల్వ చేయబడతాయి. వేర్వేరు సంస్కరణలు వేర్వేరు సమయ ముద్రను కలిగి ఉంటాయి.

రికార్డ్‌లు భౌతికంగా RowKey క్రమబద్ధీకరించబడిన క్రమంలో నిల్వ చేయబడతాయి. ఈ సందర్భంలో, వివిధ కాలమ్ కుటుంబానికి సంబంధించిన డేటా విడిగా నిల్వ చేయబడుతుంది, ఇది అవసరమైతే, కావలసిన కాలమ్ కుటుంబం నుండి మాత్రమే డేటాను చదవడానికి అనుమతిస్తుంది.

నిర్దిష్ట లక్షణం తొలగించబడినప్పుడు, అది వెంటనే భౌతికంగా తొలగించబడదు, కానీ ప్రత్యేక సమాధి జెండాతో మాత్రమే గుర్తించబడుతుంది. మేజర్ కాంపాక్షన్ ఆపరేషన్ చేసినప్పుడు డేటా యొక్క భౌతిక తొలగింపు తర్వాత జరుగుతుంది.

ఒకే నిలువు సమూహానికి చెందిన మరియు అదే కీకి సంబంధించిన లక్షణాలు భౌతికంగా క్రమబద్ధీకరించబడిన జాబితాగా నిల్వ చేయబడతాయి. ప్రతి కీకి ఏదైనా లక్షణం ఉండకపోవచ్చు లేదా ఉనికిలో ఉండవచ్చు మరియు లక్షణం లేనట్లయితే, ఇది ఖాళీ విలువలను నిల్వ చేసే ఓవర్‌హెడ్‌కు కారణం కాదు.

జాబితా మరియు నిలువు సమూహ పేర్లు స్థిరంగా ఉన్నాయి మరియు స్పష్టమైన లేఅవుట్‌ను కలిగి ఉంటాయి. నిలువు సమూహ స్థాయిలో, టైమ్ టు లైవ్ (TTL) మరియు గరిష్టంగా నిల్వ చేయబడిన సంస్కరణలు వంటి పారామితులు సెట్ చేయబడతాయి. నిర్దిష్ట సంస్కరణకు టైమ్‌స్టాంప్ మరియు ప్రస్తుత సమయం మధ్య వ్యత్యాసం TTL కంటే ఎక్కువగా ఉంటే, నమోదు తొలగింపు కోసం గుర్తించబడుతుంది. నిర్దిష్ట లక్షణం కోసం సంస్కరణల సంఖ్య గరిష్ట సంఖ్యలో సంస్కరణలను మించి ఉంటే, రికార్డ్ కూడా తొలగింపు కోసం గుర్తించబడుతుంది.

Java university

Hbase డేటా మోడల్‌ను కీ-విలువ సరిపోలికగా గుర్తుంచుకోవచ్చు:

<table, RowKey, Column Family, Column, timestamp> -> Value

6.3 మద్దతు ఉన్న కార్యకలాపాలు

hbaseలో మద్దతు ఉన్న కార్యకలాపాల జాబితా చాలా సులభం. 4 ప్రధాన కార్యకలాపాలకు మద్దతు ఉంది:

  • ఉంచండి : hbaseకి కొత్త ఎంట్రీని జోడించండి. ఈ ఎంట్రీ యొక్క టైమ్‌స్టాంప్ చేతితో సెట్ చేయబడుతుంది, లేకుంటే అది ప్రస్తుత సమయానికి స్వయంచాలకంగా సెట్ చేయబడుతుంది.
  • పొందండి : నిర్దిష్ట RowKey కోసం డేటాను పొందండి. మేము డేటాను మరియు మేము చదవాలనుకుంటున్న సంస్కరణల సంఖ్యను తీసుకునే కాలమ్ ఫ్యామిలీని మీరు పేర్కొనవచ్చు.
  • స్కాన్ : రికార్డులను ఒక్కొక్కటిగా చదవండి. మేము చదవడం ప్రారంభించిన రికార్డ్, చదవాల్సిన రికార్డ్, చదవాల్సిన రికార్డ్‌ల సంఖ్య, పఠనం ప్రదర్శించబడే కాలమ్ కుటుంబం మరియు ప్రతి రికార్డ్‌కు గరిష్ట సంఖ్యలో సంస్కరణలను మీరు పేర్కొనవచ్చు.
  • తొలగించు : తొలగింపు కోసం నిర్దిష్ట సంస్కరణను గుర్తించండి. భౌతిక తొలగింపు ఉండదు, తదుపరి మేజర్ కాంపాక్షన్ వరకు ఇది వాయిదా వేయబడుతుంది (క్రింద చూడండి).

6.4 ఆర్కిటెక్చర్

HBase అనేది పంపిణీ చేయబడిన డేటాబేస్, ఇది డజన్ల కొద్దీ లేదా వందల కొద్దీ ఫిజికల్ సర్వర్‌లలో అమలు చేయగలదు, వాటిలో కొన్ని విఫలమైనప్పటికీ అవి అంతరాయం లేని ఆపరేషన్‌ను అందిస్తాయి. అందువల్ల, క్లాసిక్ రిలేషనల్ డేటాబేస్‌లతో పోలిస్తే HBase యొక్క నిర్మాణం చాలా క్లిష్టంగా ఉంటుంది.

HBase దాని పని కోసం రెండు ప్రధాన ప్రక్రియలను ఉపయోగిస్తుంది:

1. రీజియన్ సర్వర్ - ఒకటి లేదా అంతకంటే ఎక్కువ ప్రాంతాలకు సేవలు అందిస్తుంది. ప్రాంతం అనేది నిర్దిష్ట వరుస వరుస RowKeysకి సంబంధించిన రికార్డుల శ్రేణి. ప్రతి ప్రాంతం వీటిని కలిగి ఉంటుంది:

  • HBaseలో పెర్సిస్టెంట్ స్టోరేజ్ అనేది ప్రధాన డేటా స్టోరేజ్. డేటా భౌతికంగా HDFSలో, ప్రత్యేక HFile ఆకృతిలో నిల్వ చేయబడుతుంది. HFileలోని డేటా RowKey క్రమబద్ధీకరించబడిన క్రమంలో నిల్వ చేయబడుతుంది. ఒక జత (ప్రాంతం, కాలమ్ కుటుంబం) కనీసం ఒక HFIleకి అనుగుణంగా ఉంటుంది.
  • MemStore - వ్రాసే బఫర్. డేటా HFile dలో క్రమబద్ధీకరించబడిన క్రమంలో నిల్వ చేయబడినందున, ఒక్కో రికార్డ్‌కు HFileని నవీకరించడం చాలా ఖరీదైనది. బదులుగా, వ్రాసేటప్పుడు, డేటా ఒక ప్రత్యేక MemStore మెమరీ ప్రాంతంలోకి ప్రవేశిస్తుంది, అక్కడ అది కొంత సమయం వరకు పేరుకుపోతుంది. MemStore కొంత క్లిష్టమైన విలువకు పూరించబడినప్పుడు, డేటా కొత్త HFileకి వ్రాయబడుతుంది.
  • BlockCache - చదవడానికి కాష్. తరచుగా చదివే డేటాపై సమయాన్ని గణనీయంగా ఆదా చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.
  • ముందు లాగ్ వ్రాయండి (WAL) . డేటా మెమ్‌స్టోర్‌కు వ్రాయబడినందున, క్రాష్ కారణంగా కొంత డేటా నష్టపోయే ప్రమాదం ఉంది. ఇది జరగకుండా నిరోధించడానికి, అవకతవకల యొక్క వాస్తవ అమలుకు ముందు అన్ని కార్యకలాపాలు ప్రత్యేక లాగ్ ఫైల్‌లోకి వస్తాయి. ఏదైనా వైఫల్యం తర్వాత డేటాను పునరుద్ధరించడానికి ఇది మిమ్మల్ని అనుమతిస్తుంది.

2. మాస్టర్ సర్వర్ - HBase క్లస్టర్‌లోని ప్రధాన సర్వర్. మాస్టర్ రీజియన్ సర్వర్‌ల మధ్య ప్రాంతాల పంపిణీని నిర్వహిస్తుంది, ప్రాంతాల రిజిస్టర్‌ను నిర్వహిస్తుంది, సాధారణ పనుల ప్రారంభాన్ని నిర్వహిస్తుంది మరియు ఇతర ఉపయోగకరమైన పనిని చేస్తుంది.

సేవల మధ్య చర్యలను సమన్వయం చేయడానికి, HBase Apache ZooKeeperని ఉపయోగిస్తుంది, ఇది కాన్ఫిగరేషన్‌లను నిర్వహించడానికి మరియు సేవలను సమకాలీకరించడానికి రూపొందించబడిన ప్రత్యేక సేవ.

ప్రాంతంలో డేటా మొత్తం పెరిగి, అది నిర్దిష్ట పరిమాణానికి చేరుకున్నప్పుడు, Hbase స్ప్లిట్ ప్రారంభమవుతుంది, ఇది ప్రాంతాన్ని 2 ద్వారా విభజించే ఆపరేషన్. ప్రాంతాల స్థిరమైన విభజనలను నివారించడానికి, మీరు ప్రాంతాల సరిహద్దులను ముందే సెట్ చేయవచ్చు మరియు వాటి గరిష్టాన్ని పెంచవచ్చు. పరిమాణం.

ఒక ప్రాంతం యొక్క డేటా అనేక HFilesలో నిల్వ చేయబడుతుంది కాబట్టి, పనిని వేగవంతం చేయడానికి Hbase కాలానుగుణంగా వాటిని ఒకదానితో ఒకటి విలీనం చేస్తుంది. ఈ ఆపరేషన్‌ను Hbaseలో కాంపాక్షన్ అంటారు. సంపీడనాలు రెండు రకాలు:

  • చిన్న సంపీడనం . స్వయంచాలకంగా ప్రారంభమవుతుంది, నేపథ్యంలో నడుస్తుంది. ఇతర Hbase కార్యకలాపాలతో పోలిస్తే తక్కువ ప్రాధాన్యతను కలిగి ఉంది.
  • ప్రధాన సంపీడనం . ఇది చేతితో లేదా కొన్ని ట్రిగ్గర్‌లు సంభవించినప్పుడు ప్రారంభించబడుతుంది (ఉదాహరణకు, టైమర్ ద్వారా). ఇది అధిక ప్రాధాన్యతను కలిగి ఉంది మరియు క్లస్టర్‌ను గణనీయంగా తగ్గిస్తుంది. క్లస్టర్‌పై లోడ్ తక్కువగా ఉన్న సమయంలో మేజర్ కాంపాక్షన్‌లు ఉత్తమంగా చేయబడతాయి. మేజర్ కాంపాక్షన్ గతంలో సమాధి రాయితో గుర్తించబడిన డేటాను భౌతికంగా తొలగిస్తుంది.

6.5 HBaseతో పని చేయడానికి మార్గాలు

HBase షెల్

Hbaseతో ప్రారంభించడానికి సులభమైన మార్గం hbase షెల్ యుటిలిటీని ఉపయోగించడం. ఏదైనా hbase క్లస్టర్ నోడ్‌లో hbaseని ఇన్‌స్టాల్ చేసిన వెంటనే ఇది అందుబాటులో ఉంటుంది.

Hbase షెల్ అనేది అన్ని ప్రాథమిక Hbase ఆపరేషన్‌లకు అంతర్నిర్మిత మద్దతుతో కూడిన jruby కన్సోల్. రెండు నిలువు వరుస కుటుంబాలతో వినియోగదారుల పట్టికను సృష్టించడం, దానిపై కొన్ని అవకతవకలు చేయడం మరియు పట్టికను hbase షెల్‌లో చివరన వదలడం వంటి వాటికి క్రింది ఉదాహరణ:

create 'users', {NAME => 'user_profile', VERSIONS => 5}, {NAME => 'user_posts', VERSIONS => 1231231231} 
put 'users', 'id1', 'user_profile:name', 'alexander' 
put 'users', 'id1', 'user_profile:second_name', 'alexander' 
get 'users', 'id1' 
put 'users', 'id1', 'user_profile:second_name', 'kuznetsov' 
get 'users', 'id1' 
get 'users', 'id1', {COLUMN => 'user_profile:second_name', VERSIONS => 5} 
put 'users', 'id2', 'user_profile:name', 'vasiliy' 
put 'users', 'id2', 'user_profile:second_name', 'ivanov' 
scan 'users', {COLUMN => 'user_profile:second_name', VERSIONS => 5} 
delete 'users', 'id1', 'user_profile:second_name' 
get 'users', 'id1' 
disable 'users' 
drop 'users'

స్థానిక API

ఇతర హడూప్-సంబంధిత ప్రాజెక్ట్‌ల వలె, hbase జావాలో అమలు చేయబడుతుంది, కాబట్టి స్థానిక api జావాలో అందుబాటులో ఉంటుంది. స్థానిక API అధికారిక వెబ్‌సైట్‌లో చక్కగా డాక్యుమెంట్ చేయబడింది. ఇక్కడ నుండి తీసుకోబడిన Hbase APIని ఉపయోగించే ఉదాహరణ:

import java.io.IOException;

import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;

public class MyLittleHBaseClient {
  public static void main(String[] args) throws IOException {
	Configuration config = HBaseConfiguration.create();
	Connection connection = ConnectionFactory.createConnection(config);
	try {
  	Table table = connection.getTable(TableName.valueOf("myLittleHBaseTable"));
  	try {
    	Put p = new Put(Bytes.toBytes("myLittleRow"));
    	p.add(Bytes.toBytes("myLittleFamily"), Bytes.toBytes("someQualifier"),
    	Bytes.toBytes("Some Value"));
    	table.put(p);

    	Get g = new Get(Bytes.toBytes("myLittleRow"));
    	Result r = table.get(g);
    	byte [] value = r.getValue(Bytes.toBytes("myLittleFamily"),
      	Bytes.toBytes("someQualifier"));

    	String valueStr = Bytes.toString(value);
    	System.out.println("GET: " + valueStr);

    	Scan s = new Scan();
    	s.addColumn(Bytes.toBytes("myLittleFamily"), Bytes.toBytes("someQualifier"));
    	ResultScanner scanner = table.getScanner(s);
    	try {
       	for (Result rr = scanner.next(); rr != null; rr = scanner.next()) {
         	System.out.println("Found row: " + rr);
       	}
     	} finally {
       	scanner.close();
     	}
   	} finally {
     	if (table != null) table.close();
   	}
 	} finally {
   	connection.close();
 	}
  }
}

పొదుపు, REST మరియు ఇతర ప్రోగ్రామింగ్ భాషలకు మద్దతు

ఇతర ప్రోగ్రామింగ్ భాషల నుండి పని చేయడానికి, Hbase పొదుపు API మరియు Rest APIని అందిస్తుంది. వాటి ఆధారంగా, క్లయింట్లు అన్ని ప్రధాన ప్రోగ్రామింగ్ భాషల కోసం నిర్మించబడ్డాయి: పైథాన్, PHP, జావా స్క్రిప్ట్, మొదలైనవి.

6.6 HBaseతో పని చేసే కొన్ని లక్షణాలు

  1. Hbase MapReduceతో బాక్స్ వెలుపల ఇంటిగ్రేట్ అవుతుంది మరియు ప్రత్యేక TableInputFormat మరియు TableOutputFormatని ఉపయోగించి ఇన్‌పుట్ మరియు అవుట్‌పుట్‌గా ఉపయోగించవచ్చు.

  2. సరైన RowKeyని ఎంచుకోవడం చాలా ముఖ్యం. RowKey తప్పనిసరిగా ప్రాంతాలలో మంచి సమాన పంపిణీని అందించాలి, లేకుంటే "హాట్ రీజియన్‌లు" అని పిలవబడే ప్రమాదం ఉంది - ఇతర ప్రాంతాల కంటే చాలా తరచుగా ఉపయోగించబడే ప్రాంతాలు, ఇది సిస్టమ్ వనరుల అసమర్థ వినియోగానికి దారి తీస్తుంది.

  3. డేటా ఒంటరిగా అప్‌లోడ్ చేయబడకపోతే, వెంటనే పెద్ద బ్యాచ్‌లలో, Hbase ప్రత్యేక బల్క్‌లోడ్ మెకానిజంకు మద్దతు ఇస్తుంది, ఇది సింగిల్ పుట్‌లను ఉపయోగించడం కంటే చాలా వేగంగా డేటాను అప్‌లోడ్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. బల్క్‌లోడ్ తప్పనిసరిగా రెండు-దశల ఆపరేషన్:

    • ప్రత్యేక MapReduce జాబ్‌ని ఉపయోగించి పుట్‌ల భాగస్వామ్యం లేకుండా HFileని రూపొందించడం
    • ఈ ఫైల్‌లను నేరుగా Hbaseలోకి చొప్పించడం

  4. Hbase దాని కొలమానాలను గాంగ్లియా మానిటరింగ్ సర్వర్‌కు అవుట్‌పుట్ చేయడానికి మద్దతు ఇస్తుంది. Hbase సమస్యల దిగువన పొందడానికి Hbaseని నిర్వహించేటప్పుడు ఇది చాలా సహాయకారిగా ఉంటుంది.

వరుస కీ

RowKey అనేది వినియోగదారు ID, ఇది GUUID, ఇది ప్రపంచవ్యాప్తంగా ప్రత్యేకంగా ఉండేలా ప్రత్యేకంగా రూపొందించబడిన స్ట్రింగ్. GUUIDలు సమానంగా పంపిణీ చేయబడతాయి, ఇది సర్వర్‌ల అంతటా మంచి డేటా పంపిణీని అందిస్తుంది.

కాలమ్ కుటుంబం

మా నిల్వ రెండు నిలువు వరుస కుటుంబాలను ఉపయోగిస్తుంది:

  • సమాచారం. ఈ నిలువు వరుసల సమూహం నిర్దిష్ట URLలను వినియోగదారు సందర్శించిన వాస్తవం వంటి ప్రకటనల ప్రయోజనాల కోసం ఇకపై సంబంధితంగా లేని డేటాను నిల్వ చేస్తుంది. ఈ నిలువు వరుస కుటుంబం కోసం TTL 2 నెలలకు సెట్ చేయబడింది, సంస్కరణల సంఖ్యపై పరిమితి 2000.
  • దీర్ఘ డేటా. ఈ నిలువు వరుసల సమూహం లింగం, పుట్టిన తేదీ మరియు ఇతర "శాశ్వతమైన" వినియోగదారు లక్షణాలు వంటి కాలక్రమేణా దాని ఔచిత్యాన్ని కోల్పోని డేటాను నిల్వ చేస్తుంది.

స్పీకర్లు

ప్రతి రకమైన వినియోగదారు వాస్తవాలు ప్రత్యేక కాలమ్‌లో నిల్వ చేయబడతాయి. ఉదాహరణకు, డేటా:_v కాలమ్ వినియోగదారు సందర్శించిన URLలను నిల్వ చేస్తుంది మరియు LongData:లింగ కాలమ్ వినియోగదారు లింగాన్ని నిల్వ చేస్తుంది.

ఈ వాస్తవం యొక్క టైమ్ స్టాంప్ టైమ్‌స్టాంప్‌గా నిల్వ చేయబడుతుంది. ఉదాహరణకు, డేటా:_v కాలమ్‌లో, టైమ్‌స్టాంప్ అనేది వినియోగదారు నిర్దిష్ట URLని సందర్శించిన సమయం.

ఈ వినియోగదారు డేటా నిల్వ నిర్మాణం మా వినియోగ నమూనాతో బాగా సరిపోతుంది మరియు వినియోగదారు డేటాను త్వరగా నవీకరించడానికి, వినియోగదారుల గురించి అవసరమైన మొత్తం సమాచారాన్ని త్వరగా పొందడానికి మరియు MapReduceని ఉపయోగించి, వినియోగదారులందరికి సంబంధించిన డేటాను ఒకేసారి ప్రాసెస్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.

6.7 ప్రత్యామ్నాయాలు

HBase నిర్వహించడం మరియు ఉపయోగించడం చాలా క్లిష్టంగా ఉంటుంది, కాబట్టి HBaseని ఉపయోగించే ముందు ప్రత్యామ్నాయాలను చూడటం అర్ధమే:

  • రిలేషనల్ డేటాబేస్‌లు . చాలా మంచి ప్రత్యామ్నాయం, ప్రత్యేకించి ఒక మెషీన్‌లో డేటా సరిపోయే సందర్భంలో. అలాగే, అన్నింటిలో మొదటిది, ప్రాధమికం కాకుండా ఇతర సూచికల లావాదేవీలు ముఖ్యమైనవి అయినప్పుడు మీరు రిలేషనల్ డేటాబేస్‌ల గురించి ఆలోచించాలి.

  • కీ-విలువ నిల్వ . రెడిస్ మరియు ఏరోస్పైక్ వంటి స్టోరేజీలు జాప్యం అవసరమైనప్పుడు బాగా సరిపోతాయి మరియు బ్యాచ్ ప్రాసెసింగ్ తక్కువ ప్రాముఖ్యత కలిగి ఉంటుంది.

  • MapReduceతో ఫైల్‌లు మరియు వాటి ప్రాసెసింగ్ . డేటా మాత్రమే జోడించబడి మరియు అరుదుగా నవీకరించబడిన/మార్చబడినట్లయితే, HBaseని ఉపయోగించకపోవడమే మంచిది, కానీ ఫైల్‌లలో డేటాను నిల్వ చేయండి. ఫైల్‌లతో పనిని సరళీకృతం చేయడానికి, మీరు హైవ్, పిగ్ మరియు ఇంపాలా వంటి సాధనాలను ఉపయోగించవచ్చు.

HBase ఉపయోగం కింది సందర్భాలలో సమర్థించబడుతుంది:

  • చాలా డేటా ఉంది మరియు అవి ఒక కంప్యూటర్ / సర్వర్‌లో సరిపోవు
  • డేటా తరచుగా నవీకరించబడుతుంది మరియు తొలగించబడుతుంది
  • డేటాలో స్పష్టమైన "కీ" ఉంది, ఇది అన్నిటికీ కట్టుబడి సౌకర్యవంతంగా ఉంటుంది
  • బ్యాచ్ ప్రాసెసింగ్ అవసరం
  • నిర్దిష్ట కీల ద్వారా డేటాకు యాదృచ్ఛిక ప్రాప్యత అవసరం
మునుపటిమునుపటి పాఠం
తరువాతతదుపరి పాఠం
వ్యాఖ్యలు
  • జనాదరణ పొందినది
  • కొత్తది
  • పాతది
వ్యాఖ్యానించడానికి మీరు తప్పనిసరిగా సైన్ ఇన్ చేసి ఉండాలి
ఈ పేజీకి ఇంకా ఎలాంటి వ్యాఖ్యలు లేవు