इस पेज का अनुवाद Cloud Translation API से किया गया है.

डेटाप्रॉक सर्वरलेस

1. खास जानकारी - Google Dataproc

Dataproc, Apache Spark, Apache Flink, Presto, और कई अन्य ओपन सोर्स टूल और फ़्रेमवर्क को चलाने के लिए पूरी तरह से मैनेज की गई और बड़े पैमाने पर काम करने वाली सेवा है. डेटा लेक को आधुनिक बनाने, ETL / ELT, और ग्रह के स्तर पर डेटा साइंस को सुरक्षित करने के लिए, Dataproc का इस्तेमाल करें. Dataproc को Google Cloud की कई सेवाओं के साथ भी पूरी तरह से इंटिग्रेट किया गया है. इनमें BigQuery, Cloud Storage, Vertex AI, और Dataplex शामिल हैं.

Dataproc, तीन तरह के विकल्पों में उपलब्ध है:

Dataproc सर्वरलेस, आपको इन्फ़्रास्ट्रक्चर और ऑटो स्केलिंग को कॉन्फ़िगर किए बिना PySpark जॉब चलाने की सुविधा देता है. Dataproc Serverless, PySpark बैच वर्कलोड और सेशन / नोटबुक के साथ काम करता है.
Google Compute Engine पर डेटाproc की मदद से, Flink और Presto जैसे ओपन सोर्स टूल के साथ-साथ, YARN पर आधारित Spark वर्कलोड के लिए, Hadoop YARN क्लस्टर को मैनेज किया जा सकता है. क्लाउड-आधारित क्लस्टर में, ऑटो स्केलिंग की सुविधा के साथ-साथ वर्टिकल या हॉरिज़ॉन्टल स्केलिंग का इस्तेमाल किया जा सकता है.
Google Kubernetes Engine पर डेटाproc की मदद से, अपने GKE (जीकेई) इन्फ़्रास्ट्रक्चर में Dataproc वर्चुअल क्लस्टर को कॉन्फ़िगर किया जा सकता है. ऐसा Spark, PySpark, SparkR या Spark SQL जॉब सबमिट करने के लिए किया जाता है.

इस कोडलैब में, आपको Dataproc Serverless का इस्तेमाल करने के कई अलग-अलग तरीके मिलेंगे.

Apache Spark मूल रूप से Hadoop क्लस्टर पर चलने के लिए बनाया गया था और इसने अपने संसाधन मैनेजर के रूप में YARN का इस्तेमाल किया. Hadoop क्लस्टर को मैनेज करने के लिए, खास तरह की विशेषज्ञता की ज़रूरत होती है. साथ ही, यह पक्का करना भी ज़रूरी है कि क्लस्टर में अलग-अलग नॉब को सही तरीके से कॉन्फ़िगर किया गया है. इसके अलावा, Spark नॉब के एक अलग सेट को सेट करने के लिए भी उपयोगकर्ता को अनुमति की ज़रूरत होती है. इसकी वजह से कई स्थितियां पैदा होती हैं, जिनमें डेवलपर स्पार्क कोड पर काम करने के बजाय, अपने इन्फ़्रास्ट्रक्चर को कॉन्फ़िगर करने में ज़्यादा समय खर्च करते हैं.

Dataproc Serverless की मदद से, Hadoop क्लस्टर या Spark को मैन्युअल तरीके से कॉन्फ़िगर करने की ज़रूरत नहीं पड़ती. Dataproc Serverless, Hadoop पर नहीं चलता और अपने संसाधन से जुड़ी ज़रूरतों का पता लगाने के लिए, डाइनैमिक रिसॉर्स ऐलोकेशन का इस्तेमाल करता है. इसमें, ऑटो स्केलिंग की भी ज़रूरत होती है. Dataproc Serverless की मदद से, स्पार्क प्रॉपर्टी के छोटे सबसेट को अब भी पसंद के मुताबिक बनाया जा सकता है. हालांकि, ज़्यादातर मामलों में आपको इनमें बदलाव करने की ज़रूरत नहीं होगी.

2. सेट अप करें

सबसे पहले आपको इस कोडलैब में इस्तेमाल किए जाने वाले संसाधनों और एनवायरमेंट को कॉन्फ़िगर करना होगा.

Google Cloud प्रोजेक्ट बनाएं. किसी मौजूदा प्रोफ़ाइल का इस्तेमाल किया जा सकता है.

Cloud Console टूलबार में Cloud Shell पर क्लिक करके, उसे खोलें.

Cloud Shell, इस्तेमाल के लिए तैयार शेल एनवायरमेंट उपलब्ध कराता है. इसे कोडलैब के लिए इस्तेमाल किया जा सकता है.

Cloud Shell, आपके प्रोजेक्ट का नाम डिफ़ॉल्ट रूप से सेट कर देगा. echo $GOOGLE_CLOUD_PROJECT चलाकर दोबारा जांच करें. अगर आपको आउटपुट में प्रोजेक्ट आईडी नहीं दिखता, तो इसे सेट करें.

export GOOGLE_CLOUD_PROJECT=<your-project-id>

अपने संसाधनों के लिए, Compute Engine का क्षेत्र सेट करें. जैसे, us-central1 या europe-west2.

export REGION=<your-region>

एपीआई चालू करें

कोडलैब इन एपीआई का इस्तेमाल करता है:

BigQuery
डेटाप्रॉक

ज़रूरी एपीआई चालू करें. इसमें करीब एक मिनट लगेगा. प्रोसेस पूरी होने पर आपको सफल होने का मैसेज दिखेगा.

gcloud services enable bigquery.googleapis.com
gcloud services enable dataproc.googleapis.com

नेटवर्क का ऐक्सेस कॉन्फ़िगर करें

Dataproc Serverless को उस क्षेत्र में Google निजी ऐक्सेस को सक्षम करने की आवश्यकता होती है जहां आप अपने Spark जॉब चलाएंगे, क्योंकि Spark ड्राइवरों और प्रदर्शनकर्ताओं के केवल निजी IP होते हैं. इसे default सबनेट में चालू करने के लिए, नीचे दिया गया तरीका अपनाएं.

gcloud compute networks subnets update default \
  --region=${REGION} \
  --enable-private-ip-google-access

आपके पास यह पुष्टि करने का विकल्प होता है कि Google निजी ऐक्सेस चालू है. इसके लिए, दिए गए यूआरएल का इस्तेमाल करने पर True या False मिलेगा.

gcloud compute networks subnets describe default \
  --region=${REGION} \
  --format="get(privateIpGoogleAccess)"

स्टोरेज बकेट बनाना

ऐसा स्टोरेज बकेट बनाएं जिसका इस्तेमाल, इस कोडलैब में बनाई गई ऐसेट को स्टोर करने के लिए किया जाएगा.

अपनी बकेट के लिए कोई नाम चुनें. बकेट के नाम सभी उपयोगकर्ताओं के लिए वैश्विक रूप से खास होने चाहिए.

export BUCKET=<your-bucket-name>

उस क्षेत्र में बकेट बनाएं जहां आपको Spark जॉब चलाने हैं.

gsutil mb -l ${REGION} gs://${BUCKET}

आपके पास यह देखने का विकल्प होता है कि आपका बकेट, Cloud Storage कंसोल में उपलब्ध है. अपनी बकेट देखने के लिए, gsutil ls भी चलाया जा सकता है.

परसिस्टेंट हिस्ट्री सर्वर बनाएं

Spark यूज़र इंटरफ़ेस (यूआई) में डीबग करने के टूल का एक बेहतर सेट और Spark जॉब के बारे में अहम जानकारी दी गई है. पूरे हो चुके Dataproc सर्वरलेस जॉब का स्पार्क यूज़र इंटरफ़ेस (यूआई) देखने के लिए, आपको परसिस्टेंट हिस्ट्री सर्वर के तौर पर इस्तेमाल करने के लिए, एक नोड Dataproc क्लस्टर बनाना होगा.

अपने स्थायी इतिहास सर्वर को कोई नाम दें.

PHS_CLUSTER_NAME=my-phs

नीचे दिया गया तरीका अपनाएं.

gcloud dataproc clusters create ${PHS_CLUSTER_NAME} \
    --region=${REGION} \
    --single-node \
    --enable-component-gateway \
    --properties=spark:spark.history.fs.logDirectory=gs://${BUCKET}/phs/*/spark-job-history

स्पार्क यूज़र इंटरफ़ेस (यूआई) और स्थायी इतिहास सर्वर के बारे में बाद में, कोडलैब में बाद में ज़्यादा विस्तार से बात की जाएगी.

3. Dataproc बैच की मदद से, बिना सर्वर वाले स्पार्क जॉब चलाएं

इस सैंपल में, न्यूयॉर्क सिटी (एनवाईसी) सिटी बाइक ट्रिप्स के सार्वजनिक डेटासेट से मिले डेटा के सेट का इस्तेमाल किया जा सकता है. न्यूयॉर्क सिटी सिटी बाइक में साइकल शेयर करने की सुविधा है. पैसे चुकाकर यह सुविधा ली जा सकती है. आप कुछ आसान से बदलाव करेंगे और सबसे लोकप्रिय 10 सबसे लोकप्रिय सिटी बाइक स्टेशन आईडी प्रिंट करेंगे. यह सैंपल, Spark और BigQuery के बीच आसानी से डेटा पढ़ने और उसमें बदलाव करने के लिए, ओपन सोर्स spark-bigquery-connector का खास तौर पर इस्तेमाल करता है.

यहां दिए गए GitHub रेपो और cd को citibike.py फ़ाइल वाली डायरेक्ट्री में क्लोन करें.

git clone https://github.com/GoogleCloudPlatform/devrel-demos.git
cd devrel-demos/data-analytics/next-2022-workshop/dataproc-serverless

citibike.py

import sys

from pyspark.sql import SparkSession
from pyspark.sql.functions import col
from pyspark.sql.types import BooleanType

if len(sys.argv) == 1:
    print("Please provide a GCS bucket name.")

bucket = sys.argv[1]
table = "bigquery-public-data:new_york_citibike.citibike_trips"

spark = SparkSession.builder \
          .appName("pyspark-example") \
          .config("spark.jars","gs://spark-lib/bigquery/spark-bigquery-with-dependencies_2.12-0.26.0.jar") \
          .getOrCreate()

df = spark.read.format("bigquery").load(table)

top_ten = df.filter(col("start_station_id") \
            .isNotNull()) \
            .groupBy("start_station_id") \
            .count() \
            .orderBy("count", ascending=False) \
            .limit(10) \
            .cache()

top_ten.show()

top_ten.write.option("header", True).csv(f"gs://{bucket}/citibikes_top_ten_start_station_ids")

Cloud SDK का इस्तेमाल करके, Serverless Spark में जॉब सबमिट करें. यह ऐप्लिकेशन, Cloud Shell में डिफ़ॉल्ट रूप से उपलब्ध होता है. अपने शेल में नीचे दिया गया कमांड चलाएं जो Serverless Spark जॉब सबमिट करने के लिए, Cloud SDK और Dataproc Batches API का इस्तेमाल करता है.

gcloud dataproc batches submit pyspark citibike.py \
  --batch=citibike-job \
  --region=${REGION} \
  --deps-bucket=gs://${BUCKET} \
  --jars=gs://spark-lib/bigquery/spark-bigquery-with-dependencies_2.12-0.26.0.jar \
--history-server-cluster=projects/${GOOGLE_CLOUD_PROJECT}/regions/${REGION}/clusters/${PHS_CLUSTER_NAME} \
  -- ${BUCKET}

इसके बारे में जानने के लिए:

gcloud dataproc batches submit में Dataproc Batches API का रेफ़रंस दिया गया है.
pyspark से पता चलता है कि आप एक PySpark जॉब सबमिट कर रहे हैं.
--batch नौकरी का नाम है. अगर यह उपलब्ध नहीं कराया जाता है, तो रैंडम तरीके से जनरेट किए गए यूयूआईडी का इस्तेमाल किया जाएगा.
--region=${REGION} वह भौगोलिक इलाका है जहां जॉब को प्रोसेस किया जाएगा.
--deps-bucket=${BUCKET} वह जगह है जहां सर्वरलेस एनवायरमेंट में चलने से पहले, आपकी लोकल Python फ़ाइल को अपलोड किया जाता है.
--jars=gs://spark-lib/bigquery/spark-bigquery-with-dependencies_2.12-0.26.0.jar में, स्पार्क रनटाइम एनवायरमेंट में spark-bigquery-connector के लिए जार शामिल होता है.
--history-server-cluster=projects/${GOOGLE_CLOUD_PROJECT}/regions/${REGION}/clusters/${PHS_CLUSTER}, परसिस्टेंट हिस्ट्री सर्वर का पूरी तरह क्वालिफ़ाइड नाम है. यही वह जगह है जहां Spark इवेंट डेटा (कंसोल आउटपुट से अलग) को स्टोर किया जाता है और Spark यूज़र इंटरफ़ेस (यूआई) से देखा जा सकता है.
पीछे वाला -- बताता है कि इसके अलावा जो कुछ भी होगा वह प्रोग्राम के लिए रनटाइम आर्ग होगा. इस मामले में, आप जॉब के लिए आवश्यक अपनी बकेट का नाम सबमिट कर रहे हैं.

बैच सबमिट किए जाने पर आपको यह आउटपुट दिखेगा.

Batch [citibike-job] submitted.

कुछ मिनटों के बाद, आपको जॉब के मेटाडेटा के साथ यह आउटपुट दिखेगा.

+----------------+------+
|start_station_id| count|
+----------------+------+
|             519|551078|
|             497|423334|
|             435|403795|
|             426|384116|
|             293|372255|
|             402|367194|
|             285|344546|
|             490|330378|
|             151|318700|
|             477|311403|
+----------------+------+

Batch [citibike-job] finished.

अगले सेक्शन में, आपको इस जॉब के लॉग खोजने का तरीका बताया जाएगा.

अतिरिक्त सुविधाएं

Spark Serverless के साथ, आपके पास अपने जॉब चलाने के लिए अतिरिक्त विकल्प होते हैं.

आप एक कस्टम डॉकर चित्र बना सकते हैं जिस पर आपका जॉब चलता है. यह Python और R लाइब्रेरी के साथ-साथ अन्य डिपेंडेंसी को शामिल करने का एक बेहतरीन तरीका है.
Hive मेटाडेटा को ऐक्सेस करने के लिए, Dataproc मेटास्टोर इंस्टेंस को अपने जॉब से कनेक्ट किया जा सकता है.
ज़्यादा कंट्रोल के लिए, Dataproc Serverless की मदद से स्पार्क प्रॉपर्टी के छोटे सेट को कॉन्फ़िगर किया जा सकता है.

4. डेटाप्रॉक मेट्रिक और निगरानी की सुविधा

Dataproc बैच कंसोल में, बिना सर्वर वाले सभी Dataproc जॉब की सूची होती है. कंसोल में, आपको हर काम का बैच आईडी, जगह, स्थिति, बनाने का समय, बीत चुका समय और टाइप दिखेगा. काम के बारे में ज़्यादा जानकारी देखने के लिए, अपने काम के बैच आईडी पर क्लिक करें.

इस पेज पर, आपको निगरानी जैसी जानकारी दिखेगी, जिससे यह पता चलता है कि समय के साथ, आपके काम में कितने Batch Spark एक्ज़िकेटर का इस्तेमाल हुआ. इससे यह पता चलता है कि यह कितने ऑटोस्केल हुआ है.

ब्यौरा टैब पर आपको काम के बारे में ज़्यादा मेटाडेटा दिखेगा. इसमें जॉब के साथ सबमिट किए गए सभी तर्क और पैरामीटर शामिल हैं.

इस पेज से सभी लॉग ऐक्सेस किए जा सकते हैं. जब Dataproc सर्वरलेस जॉब चलाए जाते हैं, तो लॉग के तीन अलग-अलग सेट जनरेट होते हैं:

सेवा स्तर
कंसोल आउटपुट
स्पार्क इवेंट लॉगिंग

सेवा-लेवल में ऐसे लॉग शामिल होते हैं जिन्हें Dataproc सर्वरलेस सेवा से जनरेट किया गया था. इनमें ये चीज़ें शामिल हैं: Dataproc सर्वरलेस, ऑटो स्केलिंग के लिए अतिरिक्त सीपीयू का अनुरोध करती है. इन्हें लॉग देखें पर क्लिक करके देखा जा सकता है. इससे क्लाउड Logging खुल जाएगा.

कंसोल आउटपुट को आउटपुट में देखा जा सकता है. यह जॉब से जनरेट किया गया आउटपुट होता है. इसमें जॉब की शुरुआत करते समय स्पार्क प्रिंट होने वाला मेटाडेटा या जॉब में शामिल किए गए कोई भी प्रिंट स्टेटमेंट शामिल होता है.

स्पार्क इवेंट लॉगिंग को Spark यूज़र इंटरफ़ेस (यूआई) से ऐक्सेस किया जा सकता है. आपने स्पार्क जॉब को स्थायी इतिहास सर्वर के साथ उपलब्ध कराया है, इसलिए आप स्पार्क इतिहास सर्वर देखें पर क्लिक करके, स्पार्क यूज़र इंटरफ़ेस (यूआई) को ऐक्सेस कर सकते हैं. इसमें पिछली बार चलाए गए Spark जॉब की जानकारी होती है. Spark यूज़र इंटरफ़ेस (यूआई) के बारे में ज़्यादा जानने के लिए, आधिकारिक Spark दस्तावेज़ देखें.

5. डेटाप्रॉक टेंप्लेट: BQ -> GCS

डेटाप्रॉक टेंप्लेट ओपन सोर्स टूल हैं. इनकी मदद से, इन-क्लाउड डेटा प्रोसेसिंग के टास्क को और आसान बनाया जा सकता है. ये तरीके, Dataproc Serverless के लिए रैपर की तरह काम करते हैं. साथ ही, डेटा इंपोर्ट और एक्सपोर्ट करने से जुड़े कई टास्क के लिए टेंप्लेट शामिल करते हैं. जैसे:

BigQuerytoGCS और GCStoBigQuery
GCStoBigTable
GCStoJDBC और JDBCtoGCS
HivetoBigQuery
MongotoGCS और GCStoMongo

पूरी सूची README उपलब्ध है.

इस सेक्शन में, BigQuery से GCS (जीसीएस) में डेटा एक्सपोर्ट करने के लिए, Dataproc टेंप्लेट का इस्तेमाल किया जाएगा.

रेपो का क्लोन बनाएं

रेपो का क्लोन बनाएं और इसे python फ़ोल्डर में बदलें.

git clone https://github.com/GoogleCloudPlatform/dataproc-templates.git
cd dataproc-templates/python

एनवायरमेंट को कॉन्फ़िगर करना

अब आपको एनवायरमेंट वैरिएबल सेट करने होंगे. Dataproc टेंप्लेट आपके प्रोजेक्ट आईडी के लिए, एनवायरमेंट वैरिएबल GCP_PROJECT का इस्तेमाल करता है. इसलिए, इसे GOOGLE_CLOUD_PROJECT. के बराबर सेट करें

export GCP_PROJECT=${GOOGLE_CLOUD_PROJECT}

आपका क्षेत्र पहले के एनवायरमेंट में सेट होना चाहिए. अगर ऐसा नहीं है, तो इसे यहां सेट करें.

export REGION=<region>

डेटाप्रॉक टेंप्लेट, BigQuery जॉब को प्रोसेस करने के लिए spark-bigquery-conector का इस्तेमाल करता है. साथ ही, यूआरआई को एनवायरमेंट वैरिएबल JARS में शामिल करना ज़रूरी है. JARS वैरिएबल सेट करें.

export JARS="gs://spark-lib/bigquery/spark-bigquery-with-dependencies_2.12-0.26.0.jar"

टेंप्लेट के पैरामीटर कॉन्फ़िगर करें

किसी सेवा का इस्तेमाल करने के लिए, स्टेजिंग बकेट का नाम सेट करें.

export GCS_STAGING_LOCATION=gs://${BUCKET}

इसके बाद, आपको नौकरी के हिसाब से कुछ वैरिएबल सेट करने होंगे. इनपुट टेबल के लिए, फिर से BigQuery NYC Citybike डेटासेट का रेफ़रंस दिया जाएगा.

BIGQUERY_GCS_INPUT_TABLE=bigquery-public-data.new_york_citibike.citibike_trips

csv, parquet, avro या json में से किसी एक को चुना जा सकता है. इस कोडलैब के लिए, CSV चुनें - अगले सेक्शन में, फ़ाइल टाइप को बदलने के लिए Dataproc टेंप्लेट का इस्तेमाल करने का तरीका जानें.

BIGQUERY_GCS_OUTPUT_FORMAT=csv

आउटपुट मोड को overwrite पर सेट करें. overwrite, append, ignore या errorifexists. में से कोई एक विकल्प चुना जा सकता है

BIGQUERY_GCS_OUTPUT_MODE=overwrite

GCS आउटपुट की जगह को अपने बकेट में पाथ के तौर पर सेट करें.

BIGQUERY_GCS_OUTPUT_LOCATION=gs://${BUCKET}/BQtoGCS

टेंप्लेट चलाएं

BIGQUERYTOGCS टेंप्लेट को चलाने के लिए, नीचे इसकी जानकारी दें और सेट किए गए इनपुट पैरामीटर उपलब्ध कराएं.

./bin/start.sh \
-- --template=BIGQUERYTOGCS \
        --bigquery.gcs.input.table=${BIGQUERY_GCS_INPUT_TABLE} \
        --bigquery.gcs.output.format=${BIGQUERY_GCS_OUTPUT_FORMAT} \
        --bigquery.gcs.output.mode=${BIGQUERY_GCS_OUTPUT_MODE} \
        --bigquery.gcs.output.location=${BIGQUERY_GCS_OUTPUT_LOCATION}

आउटपुट में काफ़ी शोर होगा, लेकिन करीब एक मिनट के बाद आपको ये नतीजे दिखेंगे.

Batch [5766411d6c78444cb5e80f305308d8f8] submitted.
...
Batch [5766411d6c78444cb5e80f305308d8f8] finished.

इन तरीकों का इस्तेमाल करके, पुष्टि की जा सकती है कि फ़ाइलें जनरेट की गई हैं.

gsutil ls ${BIGQUERY_GCS_OUTPUT_LOCATION}

Spark डिफ़ॉल्ट रूप से कई फ़ाइलों पर लिखता है. यह डेटा की मात्रा पर निर्भर करता है. इस मामले में, आपको जनरेट की गई करीब 30 फ़ाइलें दिखेंगी. स्पार्क आउटपुट फ़ाइल के नामों को part फ़ॉर्मैट में रखा जाता है. इसके बाद, पांच अंकों वाला नंबर (पार्ट नंबर दिखाता है) और एक हैश स्ट्रिंग होती है. ज़्यादा डेटा होने पर, Spark आम तौर पर कई फ़ाइलों को लिखेगा. उदाहरण के लिए, फ़ाइल का नाम part-00000-cbf69737-867d-41cc-8a33-6521a725f7a0-c000.csv है.

6. Dataproc टेंप्लेट: CSV से लकड़ी के तख्त

अब आपको GCSTOGCS का इस्तेमाल करके, GCS (जीसीएस) में मौजूद डेटा को एक फ़ाइल टाइप से दूसरे फ़ाइल टाइप में बदलने के लिए, Dataproc टेंप्लेट का इस्तेमाल करना होगा. यह टेंप्लेट SparkSQL का इस्तेमाल करता है. साथ ही, इसमें अतिरिक्त प्रोसेसिंग के लिए, ट्रांसफ़ॉर्मेशन के दौरान प्रोसेस की जाने वाली SparkSQL क्वेरी को भी सबमिट करने का विकल्प है.

एनवायरमेंट वैरिएबल की पुष्टि करें

पुष्टि करें कि GCP_PROJECT, REGION, और GCS_STAGING_BUCKET पिछले सेक्शन से सेट किए गए हैं.

echo ${GCP_PROJECT}
echo ${REGION}
echo ${GCS_STAGING_LOCATION}

टेंप्लेट के पैरामीटर सेट करें

अब आपको GCStoGCS के लिए कॉन्फ़िगरेशन पैरामीटर सेट करने होंगे. इनपुट फ़ाइलों की लोकेशन से शुरू करें. ध्यान दें कि यह एक डायरेक्ट्री है, न कि कोई खास फ़ाइल, क्योंकि डायरेक्ट्री में मौजूद सभी फ़ाइलें प्रोसेस की जाएंगी. इसे BIGQUERY_GCS_OUTPUT_LOCATION पर सेट करें.

GCS_TO_GCS_INPUT_LOCATION=${BIGQUERY_GCS_OUTPUT_LOCATION}

इनपुट फ़ाइल का फ़ॉर्मैट सेट करें.

GCS_TO_GCS_INPUT_FORMAT=csv

मनचाहा आउटपुट फ़ॉर्मैट सेट करें. आपके पास लकड़ी के फ़र्नीचर, JSON, avro या csv में से किसी एक को चुनने का विकल्प है.

GCS_TO_GCS_OUTPUT_FORMAT=parquet

GCS_TO_GCS_OUTPUT_MODE=overwrite

आउटपुट की जगह सेट करें.

GCS_TO_GCS_OUTPUT_LOCATION=gs://${BUCKET}/GCStoGCS

टेंप्लेट चलाएं

GCStoGCS टेंप्लेट चलाएं.

./bin/start.sh \
-- --template=GCSTOGCS \
        --gcs.to.gcs.input.location=${GCS_TO_GCS_INPUT_LOCATION} \
        --gcs.to.gcs.input.format=${GCS_TO_GCS_INPUT_FORMAT} \
        --gcs.to.gcs.output.format=${GCS_TO_GCS_OUTPUT_FORMAT} \
        --gcs.to.gcs.output.mode=${GCS_TO_GCS_OUTPUT_MODE} \
        --gcs.to.gcs.output.location=${GCS_TO_GCS_OUTPUT_LOCATION}

आउटपुट में काफ़ी शोर होगा, लेकिन करीब एक मिनट के बाद आपको नीचे जैसा एक सफल मैसेज दिखेगा.

Batch [c198787ba8e94abc87e2a0778c05ec8a] submitted.
...
Batch [c198787ba8e94abc87e2a0778c05ec8a] finished.

इन तरीकों का इस्तेमाल करके, पुष्टि की जा सकती है कि फ़ाइलें जनरेट की गई हैं.

gsutil ls ${GCS_TO_GCS_OUTPUT_LOCATION}

इस टेंप्लेट के साथ, आपके पास gcs.to.gcs.temp.view.name और gcs.to.gcs.sql.query को टेंप्लेट में पास करके SparkSQL क्वेरी को उपलब्ध कराने का भी विकल्प होता है. इससे GCS (जीसीएस) पर लिखने से पहले, डेटा पर SparkSQL क्वेरी चलाई जा सकती है.

7. संसाधनों का इस्तेमाल करना

कोडलैब का यह मॉड्यूल पूरा होने के बाद, आपके GCP खाते पर बेवजह शुल्क न लगे. इसके लिए:

अपने बनाए एनवायरमेंट के लिए, Cloud Storage बकेट मिटाएं.

gsutil rm -r gs://${BUCKET}

उस Dataproc क्लस्टर को मिटाएं जिसका इस्तेमाल स्थायी इतिहास सर्वर के लिए किया जाता है.

gcloud dataproc clusters delete ${PHS_CLUSTER_NAME} \
  --region=${REGION}

Dataproc सर्वर-लेस जॉब मिटाएं. बैच कंसोल पर जाएं. हर उस जॉब के बगल में मौजूद बॉक्स पर क्लिक करें जिसे आपको मिटाना है. इसके बाद, मिटाएं पर क्लिक करें.

अगर आपने सिर्फ़ इस कोडलैब के लिए कोई प्रोजेक्ट बनाया है, तो आपके पास उसे मिटाने का विकल्प भी होता है:

GCP कंसोल में, प्रोजेक्ट पेज पर जाएं.
प्रोजेक्ट की सूची में, वह प्रोजेक्ट चुनें जिसे आपको मिटाना है. इसके बाद, 'मिटाएं' पर क्लिक करें.
बॉक्स में, प्रोजेक्ट आईडी लिखें और फिर प्रोजेक्ट मिटाने के लिए शट डाउन करें पर क्लिक करें.

चेतावनी: किसी प्रोजेक्ट को मिटाने से ये असर होते हैं:

प्रोजेक्ट में मौजूद पूरा कॉन्टेंट मिटा दिया जाता है. अगर आपने इस ट्यूटोरियल के लिए किसी मौजूदा प्रोजेक्ट का इस्तेमाल किया था, तो उसे मिटाने पर, प्रोजेक्ट में आपका किया गया अन्य काम भी मिट जाएगा.
कस्टम प्रोजेक्ट आईडी मौजूद नहीं हैं. इस प्रोजेक्ट को बनाते समय, हो सकता है कि आपने ऐसा कस्टम प्रोजेक्ट आईडी बनाया हो जिसे आपको आने वाले समय में इस्तेमाल करना हो. प्रोजेक्ट आईडी का इस्तेमाल करने वाले यूआरएल, जैसे कि appspot.com के यूआरएल को सुरक्षित रखने के लिए, पूरे प्रोजेक्ट को मिटाने के बजाय, प्रोजेक्ट में चुने गए रिसॉर्स को मिटाएं.

8. आगे क्या करना है

इन संसाधनों में, Serverless Spark का फ़ायदा उठाने के और भी तरीके बताए गए हैं:

Cloud Composer का इस्तेमाल करके बिना सर्वर वाले Dataproc वर्कफ़्लो को व्यवस्थित करने का तरीका जानें.
Dataproc Serverless को Kubeflow पाइपलाइन के साथ इंटिग्रेट करने का तरीका जानें.