1. परिचय
इस कोडलैब में, Cloud Bigtable के मॉनिटरिंग टूल इस्तेमाल किए जा सकेंगे. इनकी मदद से, Cloud Dataflow और Java HBase क्लाइंट की मदद से अलग-अलग तरह की आर्ट बनाई जा सकेगी और डेटा को पढ़ा जा सकेगा.
आपको इनके बारे में जानकारी मिलेगी
- Cloud Dataflow का इस्तेमाल करके Bigtable में बड़ी मात्रा में डेटा लोड करें
- आपका डेटा डाले जाने के बाद, Bigtable के इंस्टेंस और टेबल पर नज़र रखें
- Dataflow जॉब का इस्तेमाल करके Bigtable क्वेरी
- उस कुंजी विज़ुअलाइज़र टूल के बारे में जानें जिसका इस्तेमाल आपके स्कीमा डिज़ाइन की वजह से हॉटस्पॉट ढूंढने के लिए किया जा सकता है
- की विज़ुअलाइज़र का इस्तेमाल करके आर्ट बनाएं
Cloud Bigtable को इस्तेमाल करने के अपने अनुभव को आप कितनी रेटिंग देंगे?
इस ट्यूटोरियल का इस्तेमाल कैसे किया जाएगा?
2. अपना Bigtable डेटाबेस बनाएं
Cloud Bigtable, Google की NoSQL Big Data डेटाबेस सेवा है. इस डेटाबेस की मदद से Search, Analytics, Maps, और Gmail के साथ-साथ Google की कई मुख्य सेवाएं काम करती हैं. यह, आंकड़ों से जुड़े ज़्यादा वर्कलोड चलाने और कम इंतज़ार वाले ऐप्लिकेशन बनाने के लिए बिलकुल सही है. इसके बारे में ज़्यादा जानने के लिए, Cloud Bigtable कोडलैब के बारे में जानकारी देखें.
प्रोजेक्ट बनाना
सबसे पहले, एक नया प्रोजेक्ट बनाएं. पहले से मौजूद क्लाउड शेल का इस्तेमाल करें. इसे "चालू क्लाउड शेल" पर क्लिक करके खोला जा सकता है बटन पर क्लिक करें.
कोडलैब के निर्देशों को आसानी से कॉपी करने और चिपकाने के लिए, इन एनवायरमेंट वैरिएबल को सेट करें:
BIGTABLE_PROJECT=$GOOGLE_CLOUD_PROJECT INSTANCE_ID="keyviz-art-instance" CLUSTER_ID="keyviz-art-cluster" TABLE_ID="art" CLUSTER_NUM_NODES=1 CLUSTER_ZONE="us-central1-c" # You can choose a zone closer to you
Cloud Shell में वे टूल पहले से मौजूद होते हैं जिनका इस्तेमाल इस कोडलैब में किया जा सकता है. इनमें gcloud कमांड-लाइन टूल, cbt कमांड-लाइन इंटरफ़ेस, और Maven भी शामिल हैं.
इस निर्देश को चलाकर, Cloud Bigtable एपीआई को चालू करें.
gcloud services enable bigtable.googleapis.com bigtableadmin.googleapis.com
नीचे दिए गए निर्देश की मदद से कोई इंस्टेंस बनाएं:
gcloud bigtable instances create $INSTANCE_ID \
--cluster=$CLUSTER_ID \
--cluster-zone=$CLUSTER_ZONE \
--cluster-num-nodes=$CLUSTER_NUM_NODES \
--display-name=$INSTANCE_ID
इंस्टेंस बनाने के बाद, cbt कॉन्फ़िगरेशन फ़ाइल को पॉप्युलेट करें. इसके बाद, इन निर्देशों की मदद से टेबल और कॉलम फ़ैमिली बनाएं:
echo project = $GOOGLE_CLOUD_PROJECT > ~/.cbtrc echo instance = $INSTANCE_ID >> ~/.cbtrc cbt createtable $TABLE_ID cbt createfamily $TABLE_ID cf
3. जानें: Dataflow की मदद से Bigtable पर लिखना
लिखने की बुनियादी बातें
Cloud Bigtable पर लिखते समय, आपको एक CloudBigtableTableConfiguration कॉन्फ़िगरेशन ऑब्जेक्ट देना होगा. यह ऑब्जेक्ट आपकी टेबल के प्रोजेक्ट आईडी और इंस्टेंस आईडी के साथ-साथ टेबल के नाम के बारे में भी बताता है:
CloudBigtableTableConfiguration bigtableTableConfig =
new CloudBigtableTableConfiguration.Builder()
.withProjectId(PROJECT_ID)
.withInstanceId(INSTANCE_ID)
.withTableId(TABLE_ID)
.build();
इसके बाद, आपकी पाइपलाइन HBase Mutation ऑब्जेक्ट को पास कर सकती है, जिसमें डालें और मिटाएं शामिल हो सकते हैं.
p.apply(Create.of("hello", "world"))
.apply(
ParDo.of(
new DoFn<String, Mutation>() {
@ProcessElement
public void processElement(@Element String rowkey, OutputReceiver<Mutation> out) {
long timestamp = System.currentTimeMillis();
Put row = new Put(Bytes.toBytes(rowkey));
row.addColumn(...);
out.output(row);
}
}))
.apply(CloudBigtableIO.writeToTable(bigtableTableConfig));
LoadData Dataflow जॉब
अगले पेज में आपको LoadData जॉब को चलाने का तरीका बताया जाएगा. हालांकि, यहां हम आपको पाइपलाइन के ज़रूरी हिस्सों के बारे में बताएंगे.
डेटा जनरेट करने के लिए, आपको एक पाइपलाइन बनानी होगी, जो कुछ मेगाबाइट रैंडम डेटा वाली कई पंक्तियां लिखने के लिए GenerateSequence क्लास (जैसे, लूप के लिए) का इस्तेमाल करती है. पंक्ति कुंजी के क्रम संख्या को पैडेड और उलटा किया जाएगा, ताकि 250 0000000052 हो जाए.
LoadData.java
String numberFormat = "%0" + maxLength + "d";
p.apply(GenerateSequence.from(0).to(max))
.apply(
ParDo.of(
new DoFn<Long, Mutation>() {
@ProcessElement
public void processElement(@Element Long rowkey, OutputReceiver<Mutation> out) {
String paddedRowkey = String.format(numberFormat, rowkey);
// Reverse the rowkey for more efficient writing
String reversedRowkey = new StringBuilder(paddedRowkey).reverse().toString();
Put row = new Put(Bytes.toBytes(reversedRowkey));
// Generate random bytes
byte[] b = new byte[(int) rowSize];
new Random().nextBytes(b);
long timestamp = System.currentTimeMillis();
row.addColumn(Bytes.toBytes(COLUMN_FAMILY), Bytes.toBytes("C"), timestamp, b);
out.output(row);
}
}))
.apply(CloudBigtableIO.writeToTable(bigtableTableConfig));
4. Bigtable में डेटा जनरेट करें और फ़्लो को मॉनिटर करें
नीचे दिए गए निर्देश, dataflow जॉब को चलाएंगे, जो आपकी टेबल में 40 जीबी डेटा जनरेट करेगा. यह कुंजी विज़ुअलाइज़र को चालू करने के लिए ज़रूरत के मुताबिक है:
Cloud Dataflow API को चालू करना
gcloud services enable dataflow.googleapis.com
GitHub से कोड पाएं और डायरेक्ट्री में बदलें
git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git cd java-docs-samples/bigtable/beam/keyviz-art
डेटा जनरेट करें (स्क्रिप्ट में करीब 15 मिनट लगते हैं)
mvn compile exec:java -Dexec.mainClass=keyviz.LoadData \ "-Dexec.args=--bigtableProjectId=$BIGTABLE_PROJECT \ --bigtableInstanceId=$INSTANCE_ID --runner=dataflow \ --bigtableTableId=$TABLE_ID --project=$GOOGLE_CLOUD_PROJECT"
इंपोर्ट की रिपोर्ट पर नज़र रखना
Cloud Dataflow यूज़र इंटरफ़ेस (यूआई) में जॉब को मॉनिटर किया जा सकता है. इसके अलावा, मॉनिटरिंग यूज़र इंटरफ़ेस (यूआई) की मदद से, Cloud Bigtable के इंस्टेंस पर लोड को भी देखा जा सकता है.
Dataflow के यूज़र इंटरफ़ेस (यूआई) में, आपको जॉब ग्राफ़ और कई जॉब मेट्रिक दिखेंगी. इनमें प्रोसेस किए गए एलिमेंट, मौजूदा vCPU, और थ्रूपुट शामिल हैं.
Bigtable में रीड/राइट ऑपरेशन, इस्तेमाल किए गए स्टोरेज, गड़बड़ी की दर वगैरह के लिए क्लस्टर और टेबल के लेवल पर स्टैंडर्ड मॉनिटरिंग टूल मौजूद हैं. इसके अलावा, Bigtable में Key विज़ुअलाइज़र की सुविधा भी होती है, जो पंक्ति की उन कुंजियों के आधार पर आपके इस्तेमाल का डेटा दिखाता है जिन्हें हम कम से कम 30 जीबी डेटा जनरेट होने के बाद इस्तेमाल करेंगे.
5. जानें: Dataflow की मदद से Bigtable से पढ़ना सीखें
पढ़ने के बारे में बुनियादी बातें
Cloud Bigtable से पढ़ते समय, आपको एक CloudBigtableTableScanConfiguration कॉन्फ़िगरेशन ऑब्जेक्ट देना होगा. यह CloudBigtableTableConfiguration के जैसा ही है. हालांकि, आपके पास स्कैन करने और पढ़ने के लिए पंक्तियां तय करने की सुविधा होती है.
Scan scan = new Scan();
scan.setCacheBlocks(false);
scan.setFilter(new FirstKeyOnlyFilter());
CloudBigtableScanConfiguration config =
new CloudBigtableScanConfiguration.Builder()
.withProjectId(options.getBigtableProjectId())
.withInstanceId(options.getBigtableInstanceId())
.withTableId(options.getBigtableTableId())
.withScan(scan)
.build();
इसके बाद, पाइपलाइन शुरू करने के लिए इसका इस्तेमाल करें:
p.apply(Read.from(CloudBigtableIO.read(config)))
.apply(...
हालांकि, अगर आपको पाइपलाइन के हिस्से के तौर पर रीड करना है, तो AbstractCloudBigtableTableDoFn को बढ़ाने वाले doFn को CloudBigtableTableConfiguration पास किया जा सकता है.
p.apply(GenerateSequence.from(0).to(10))
.apply(ParDo.of(new ReadFromTableFn(bigtableTableConfig, options)));
इसके बाद, super() को अपने कॉन्फ़िगरेशन के बारे में बताएं. साथ ही, getConnection() पर कॉल करके, उपलब्ध कनेक्शन पाएं.
public static class ReadFromTableFn extends AbstractCloudBigtableTableDoFn<Long, Void> {
public ReadFromTableFn(CloudBigtableConfiguration config, ReadDataOptions readDataOptions) {
super(config);
}
@ProcessElement
public void processElement(PipelineOptions po) {
Table table = getConnection().getTable(TableName.valueOf(options.getBigtableTableId()));
ResultScanner imageData = table.getScanner(scan);
}
}
ReadData Dataflow जॉब
इस कोडलैब के लिए, आपको हर सेकंड टेबल से पढ़ना होगा, ताकि आप अपनी पाइपलाइन को जनरेट किए गए क्रम से शुरू कर सकें. यह क्रम, इनपुट की गई CSV फ़ाइल के समय के आधार पर, कई रीड रेंज ट्रिगर करता है.
दिए गए समय में, किन लाइन की रेंज को स्कैन करना है, यह तय करने की ज़रूरत है. अगर आपको ज़्यादा जानना है, तो सोर्स कोड देखने के लिए फ़ाइल के नाम पर क्लिक करें.
ReadData.java
p.apply(GenerateSequence.from(0).withRate(1, new Duration(1000)))
.apply(ParDo.of(new ReadFromTableFn(bigtableTableConfig, options)));
ReadData.java
public static class ReadFromTableFn extends AbstractCloudBigtableTableDoFn<Long, Void> {
List<List<Float>> imageData = new ArrayList<>();
String[] keys;
public ReadFromTableFn(CloudBigtableConfiguration config, ReadDataOptions readDataOptions) {
super(config);
keys = new String[Math.toIntExact(getNumRows(readDataOptions))];
downloadImageData(readDataOptions.getFilePath());
generateRowkeys(getNumRows(readDataOptions));
}
@ProcessElement
public void processElement(PipelineOptions po) {
// Determine which column will be drawn based on runtime of job.
long timestampDiff = System.currentTimeMillis() - START_TIME;
long minutes = (timestampDiff / 1000) / 60;
int timeOffsetIndex = Math.toIntExact(minutes / KEY_VIZ_WINDOW_MINUTES);
ReadDataOptions options = po.as(ReadDataOptions.class);
long count = 0;
List<RowRange> ranges = getRangesForTimeIndex(timeOffsetIndex, getNumRows(options));
if (ranges.size() == 0) {
return;
}
try {
// Scan with a filter that will only return the first key from each row. This filter is used
// to more efficiently perform row count operations.
Filter rangeFilters = new MultiRowRangeFilter(ranges);
FilterList firstKeyFilterWithRanges = new FilterList(
rangeFilters,
new FirstKeyOnlyFilter(),
new KeyOnlyFilter());
Scan scan =
new Scan()
.addFamily(Bytes.toBytes(COLUMN_FAMILY))
.setFilter(firstKeyFilterWithRanges);
Table table = getConnection().getTable(TableName.valueOf(options.getBigtableTableId()));
ResultScanner imageData = table.getScanner(scan);
} catch (Exception e) {
System.out.println("Error reading.");
e.printStackTrace();
}
}
/**
* Download the image data as a grid of weights and store them in a 2D array.
*/
private void downloadImageData(String artUrl) {
...
}
/**
* Generates an array with the rowkeys that were loaded into the specified Bigtable. This is
* used to create the correct intervals for scanning equal sections of rowkeys. Since Bigtable
* sorts keys lexicographically if we just used standard intervals, each section would have
* different sizes.
*/
private void generateRowkeys(long maxInput) {
...
}
/**
* Get the ranges to scan for the given time index.
*/
private List<RowRange> getRangesForTimeIndex(@Element Integer timeOffsetIndex, long maxInput) {
...
}
}
6. अपनी मास्टरपीस बनाई जा रही है
अब आपको Bigtable में डेटा को लोड करने और इसे Dataflow से पढ़ने का तरीका पता चल गया है. इसलिए, अब फ़ाइनल निर्देश चलाया जा सकता है. इससे आठ घंटों के अंदर मोना लीसा की इमेज जनरेट होगी.
mvn compile exec:java -Dexec.mainClass=keyviz.ReadData \ "-Dexec.args=--bigtableProjectId=$BIGTABLE_PROJECT \ --bigtableInstanceId=$INSTANCE_ID --runner=dataflow \ --bigtableTableId=$TABLE_ID --project=$GOOGLE_CLOUD_PROJECT"
आपके पास पहले से मौजूद इमेज वाला एक बकेट है, जिसे इस्तेमाल किया जा सकता है. इसके अलावा, इस टूल की मदद से, अपनी किसी भी इमेज से इनपुट फ़ाइल बनाई जा सकती है. इसके बाद, उन्हें सार्वजनिक GCS बकेट में अपलोड किया जा सकता है.
फ़ाइल के नाम, gs://keyviz-art/[painting]_[hours]h.txt से बनाए गए हैं, उदाहरण: gs://keyviz-art/american_gothic_4h.txt
पेंटिंग के विकल्प:
- american_gothic
- mona_lisa
- pearl_earring
- persistence_of_memory
- starry_night
- sunday_afternoon
- the_scream
घंटे के विकल्प: 1, 4, 8, 12, 24, 48, 72, 96, 120, 144
allUsers को Storage Object Viewer भूमिका देकर, अपना GCS बकेट या फ़ाइल सार्वजनिक करें.
इमेज चुनने के बाद, इस कमांड में --file-path पैरामीटर को बदलें:
mvn compile exec:java -Dexec.mainClass=keyviz.ReadData \ "-Dexec.args=--bigtableProjectId=$BIGTABLE_PROJECT \ --bigtableInstanceId=$INSTANCE_ID --runner=dataflow \ --bigtableTableId=$TABLE_ID --project=$GOOGLE_CLOUD_PROJECT \ --filePath=gs://keyviz-art/american_gothic_4h.txt"
7. इसे बाद में देखें
पूरी इमेज दिखने में कुछ घंटे लग सकते हैं. हालांकि, 30 मिनट के बाद, आपको की विज़ुअलाइज़र में गतिविधि दिखने लगेगी. ज़ूम, चमक, और मेट्रिक जैसे कई पैरामीटर इस्तेमाल किए जा सकते हैं. माउस पर स्क्रोल व्हील का इस्तेमाल करके या 'की विज़ुअलाइज़र' ग्रिड पर रेक्टैंगल खींचकर ज़ूम किया जा सकता है.
चमक, चित्र की स्केलिंग को बदल देती है, जो कि अगर आपको किसी बहुत गर्म क्षेत्र को गहराई से देखना हो, तो यह उपयोगी होता है.
यह भी तय किया जा सकता है कि कौनसी मेट्रिक दिखे. ओपी, रीड बाइट क्लाइंट, और बाइट क्लाइंट टाइप जैसी कई सुविधाएं मिलती हैं. "क्लाइंट डेटा को बाइट पढ़ना" "Ops" होने पर, लगता है कि सहज इमेज जनरेट हो रही हैं ज़्यादा लाइनों वाली इमेज जनरेट करता है, जो कुछ इमेज पर बहुत अच्छी दिख सकती हैं.
8. पूरा करें
शुल्क से बचने के लिए, जगह खाली करें
इस कोडलैब में इस्तेमाल किए गए संसाधनों के लिए, Google Cloud Platform खाते पर लगने वाले शुल्क से बचने के लिए, आपको अपना इंस्टेंस मिटा देना चाहिए.
gcloud bigtable instances delete $INSTANCE_ID
इसमें हमने इन विषयों के बारे में बताया
- Dataflow की मदद से Bigtable में लिखना
- Dataflow की मदद से Bigtable से पढ़ना (आपकी पाइपलाइन की शुरुआत में, आपकी पाइपलाइन के बीच में)
- Dataflow मॉनिटर करने के टूल का इस्तेमाल करना
- Bigtable को मॉनिटर करने वाले टूल के साथ-साथ Key विज़ुअलाइज़र का इस्तेमाल करना
अगले चरण
- की विज़ुअलाइज़र आर्ट कैसे बनाई गई, इस बारे में और पढ़ें.
- दस्तावेज़ में Cloud Bigtable के बारे में ज़्यादा जानें.
- Google Cloud Platform की अन्य सुविधाएं खुद आज़माएं. हमारे ट्यूटोरियल देखें.