Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Managed Service for Apache Spark

1. खास जानकारी - Serverless for Apache Spark

Managed Service for Apache Spark, Apache Spark, Apache Flink, Presto, और कई अन्य ओपन सोर्स टूल और फ़्रेमवर्क को चलाने के लिए, पूरी तरह से मैनेज की जाने वाली और बहुत ज़्यादा स्केलेबल सेवा है. डेटा लेक को बेहतर बनाने, ईटीएल / ईएलटी, और सुरक्षित डेटा साइंस के लिए, मैनेज किए गए Apache Spark का इस्तेमाल करें. Managed Apache Spark को Google Cloud की कई सेवाओं के साथ पूरी तरह से इंटिग्रेट किया गया है. इनमें BigQuery, Cloud Storage, Gemini Enterprise Agent Engine, और Knowledge Catalog शामिल हैं.

मैनेज किए जा रहे Apache Spark की सुविधा दो वर्शन में उपलब्ध है:

मैनेज किया गया Apache Spark Serverless की मदद से, इंफ़्रास्ट्रक्चर और ऑटोस्केलिंग को कॉन्फ़िगर किए बिना PySpark जॉब चलाए जा सकते हैं. मैनेज किए गए Apache Spark में, PySpark बैच वर्कलोड और सेशन / नोटबुक का इस्तेमाल किया जा सकता है.
मैनेज किए गए Apache Spark क्लस्टर की मदद से, YARN पर आधारित Spark वर्कलोड के लिए Hadoop YARN क्लस्टर को मैनेज किया जा सकता है. इसके अलावा, Flink और Presto जैसे ओपन सोर्स टूल भी मैनेज किए जा सकते हैं. अपनी ज़रूरत के हिसाब से, क्लाउड पर आधारित क्लस्टर को वर्टिकल या हॉरिज़ॉन्टल तौर पर स्केल किया जा सकता है. इसमें ऑटो स्केलिंग भी शामिल है.

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

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

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

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 Private Access चालू करने की ज़रूरत होती है जहां आपको Spark जॉब चलाने हैं. ऐसा इसलिए, क्योंकि Spark ड्राइवर और एक्ज़ीक्यूटर के पास सिर्फ़ प्राइवेट आईपी होते हैं. इसे default सबनेट में चालू करने के लिए, यहां दिया गया कमांड चलाएं.

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

इस बात की पुष्टि की जा सकती है कि Google Private Access चालू है या नहीं. इसके लिए, यहां दिए गए तरीके का इस्तेमाल करें. इससे 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 Serverless की पूरी हो चुकी नौकरियों के लिए Spark यूज़र इंटरफ़ेस (यूआई) देखने के लिए, आपको एक नोड वाला 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

इस कोडलैब में, Spark UI और परसिस्टेंट हिस्ट्री सर्वर के बारे में ज़्यादा जानकारी बाद में दी जाएगी.

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

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

नीचे दिए गए Github repo और 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 Shell में उपलब्ध Cloud SDK का इस्तेमाल करके, सर्वर का इस्तेमाल किए बिना Spark को जॉब सबमिट करें. अपने शेल में यह निर्देश चलाएं. यह Cloud SDK और Dataproc Batches API का इस्तेमाल करके, Serverless Spark जॉब सबमिट करता है.

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 फ़ाइल अपलोड की जाती है. इसके बाद, इसे Serverless एनवायरमेंट में चलाया जाता है.
--jars=gs://spark-lib/bigquery/spark-bigquery-with-dependencies_2.12-0.26.0.jar में Spark रनटाइम एनवायरमेंट में spark-bigquery-connector के लिए जार शामिल है.
--history-server-cluster=projects/${GOOGLE_CLOUD_PROJECT}/regions/${REGION}/clusters/${PHS_CLUSTER}, परसिस्टेंट हिस्ट्री सर्वर का पूरी तरह क्वालिफ़ाइड नाम है. यहां Spark इवेंट का डेटा (कंसोल आउटपुट से अलग) सेव किया जाता है. इसे Spark UI से देखा जा सकता है.
आखिर में मौजूद -- से पता चलता है कि इसके बाद मौजूद कोई भी चीज़, प्रोग्राम के लिए रनटाइम आर्ग्युमेंट होगी. इस मामले में, आपको अपनी बकेट का नाम सबमिट करना होगा. यह काम के लिए ज़रूरी है.

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

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 Metastore इंस्टेंस से कनेक्ट किया जा सकता है.
ज़्यादा कंट्रोल के लिए, Dataproc Serverless में Spark प्रॉपर्टी के छोटे सेट को कॉन्फ़िगर करने की सुविधा मिलती है.

4. Dataproc की मेट्रिक और ऑब्ज़र्वअबिलिटी

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

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

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

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

सेवा-लेवल
कंसोल आउटपुट
Spark इवेंट की लॉगिंग

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

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

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

5. Dataproc टेंप्लेट: BQ -> GCS

Dataproc टेंप्लेट ओपन सोर्स टूल हैं. ये क्लाउड में डेटा प्रोसेसिंग के टास्क को और भी आसान बनाने में मदद करते हैं. ये 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>

Dataproc टेंप्लेट, 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 Citibike डेटासेट का रेफ़रंस देना होगा.

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

6. Dataproc टेंप्लेट: CSV से Parquet फ़ाइल में बदलना

अब आपको GCS में मौजूद डेटा को एक फ़ाइल टाइप से दूसरे फ़ाइल टाइप में बदलने के लिए, Dataproc टेंप्लेट का इस्तेमाल करना होगा. इसके लिए, GCSTOGCS का इस्तेमाल करें. यह टेंप्लेट 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

आउटपुट का फ़ॉर्मैट सेट करें. आपके पास parquet, 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}

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

7. संसाधन मिटाना

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

आपने जिस एनवायरमेंट के लिए Cloud Storage बकेट बनाया है उसे मिटाएं.

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

Dataproc क्लस्टर मिटाएं, जिसका इस्तेमाल परसिस्टेंट हिस्ट्री सर्वर के लिए किया गया था.

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

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

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

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

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

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

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

यहां दिए गए संसाधनों से, Serverless Spark का फ़ायदा पाने के अन्य तरीकों के बारे में ज़्यादा जानकारी मिलती है:

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