หน้านี้ได้รับการแปลโดย Cloud Translation API

Dataproc Serverless

1. ภาพรวม - Google Dataproc

Dataproc เป็นบริการที่มีการจัดการครบวงจรและรองรับการปรับขนาดได้สูงสำหรับการเรียกใช้ Apache Spark, Apache Flink, Presto รวมถึงเครื่องมือและเฟรมเวิร์กโอเพนซอร์สอื่นๆ อีกมากมาย ใช้ Dataproc สำหรับการปรับที่เก็บข้อมูลขนาดใหญ่ให้ทันสมัย, ETL / ELT และวิทยาศาสตร์ข้อมูลที่ปลอดภัยในสเกลระดับโลก นอกจากนี้ Dataproc ยังผสานรวมกับบริการ Google Cloud มากมายอย่างเต็มรูปแบบ ซึ่งรวมถึง BigQuery, Cloud Storage, Vertex AI และ Dataplex

Dataproc มี 3 รสชาติ ได้แก่

Dataproc Serverless ช่วยให้คุณเรียกใช้งาน PySpark ได้โดยไม่ต้องกำหนดค่าโครงสร้างพื้นฐานและการปรับขนาดอัตโนมัติ Dataproc Serverless รองรับภาระงานแบบกลุ่มและเซสชัน / สมุดบันทึกของ PySpark
Dataproc บน Google Compute Engine ช่วยให้คุณจัดการคลัสเตอร์ Hadoop YARN สำหรับภาระงาน Spark ที่ใช้ YARN นอกเหนือจากเครื่องมือโอเพนซอร์ส เช่น Flink และ Presto คุณปรับแต่งคลัสเตอร์ในระบบคลาวด์ด้วยการปรับขนาดแนวตั้งหรือแนวนอนได้มากเท่าที่ต้องการ รวมถึงการปรับขนาดอัตโนมัติ
Dataproc บน Google Kubernetes Engine ช่วยให้คุณกำหนดค่าคลัสเตอร์เสมือนของ Dataproc ในโครงสร้างพื้นฐาน GKE เพื่อส่งงาน Spark, PySpark, SparkR หรือ Spark SQL

ใน Codelab นี้ คุณจะได้เรียนรู้วิธีการต่างๆ ในการใช้ Dataproc Serverless ได้

เดิมที Apache Spark สร้างขึ้นให้ทำงานบนคลัสเตอร์ Hadoop และใช้ YARN เป็นผู้จัดการทรัพยากร การดูแลคลัสเตอร์ Hadoop ต้องใช้ความเชี่ยวชาญที่เฉพาะเจาะจงและตรวจสอบว่าได้กำหนดค่าปุ่มต่างๆ ของคลัสเตอร์อย่างถูกต้องแล้ว ซึ่งเป็นชุดลูกบิดแยกชุดที่ Spark กำหนดให้ผู้ใช้ตั้งค่าเองด้วย ซึ่งนำไปสู่สถานการณ์มากมายที่นักพัฒนาซอฟต์แวร์ใช้เวลามากขึ้นในการกำหนดค่าโครงสร้างพื้นฐานโดยไม่ต้องดำเนินการกับโค้ด Spark เลย

Dataproc Serverless ทำให้ไม่จำเป็นต้องกำหนดค่าคลัสเตอร์ Hadoop หรือ Spark ด้วยตนเอง Dataproc Serverless ไม่ได้ทำงานบน Hadoop และใช้การจัดสรรทรัพยากรแบบไดนามิกของตนเองในการกำหนดข้อกำหนดด้านทรัพยากร รวมถึงการปรับขนาดอัตโนมัติ พร็อพเพอร์ตี้ Spark กลุ่มเล็กๆ ยังคงปรับแต่งได้ด้วย Dataproc Serverless แต่ในกรณีส่วนใหญ่ คุณจะไม่จำเป็นต้องปรับเปลี่ยนการตั้งค่าเหล่านี้

2. ตั้งค่า

คุณจะเริ่มต้นด้วยการกำหนดค่าสภาพแวดล้อมและทรัพยากรที่ใช้ใน Codelab นี้

สร้างโปรเจ็กต์ Google Cloud คุณใช้ตัวเลือกที่มีอยู่ได้

เปิด Cloud Shell โดยคลิกที่แถบเครื่องมือของ Cloud Console

Cloud Shell มีสภาพแวดล้อม Shell ที่พร้อมใช้งานซึ่งคุณใช้สำหรับ Codelab นี้ได้

Cloud Shell จะตั้งชื่อโปรเจ็กต์โดยค่าเริ่มต้น โปรดตรวจสอบอีกครั้งโดยเรียกใช้ echo $GOOGLE_CLOUD_PROJECT ตั้งค่ารหัสหากไม่เห็นรหัสโปรเจ็กต์ในเอาต์พุต

export GOOGLE_CLOUD_PROJECT=<your-project-id>

กำหนดภูมิภาคของ Compute Engine สำหรับทรัพยากร เช่น us-central1 หรือ europe-west2

export REGION=<your-region>

เปิดใช้ API

Codelab ใช้ API ต่อไปนี้

BigQuery
Dataproc

เปิดใช้ API ที่จำเป็น ซึ่งจะใช้เวลาประมาณ 1 นาที และข้อความแสดงสําเร็จจะปรากฏขึ้นเมื่อดำเนินการเสร็จสมบูรณ์แล้ว

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)"

สร้างที่เก็บข้อมูลของพื้นที่เก็บข้อมูล

สร้างที่เก็บข้อมูลของพื้นที่เก็บข้อมูลที่จะใช้จัดเก็บเนื้อหาที่สร้างใน Codelab นี้

เลือกชื่อสำหรับที่เก็บข้อมูลของคุณ ชื่อที่เก็บข้อมูลต้องไม่ซ้ำกันสำหรับผู้ใช้ทั้งหมดทั่วโลก

export BUCKET=<your-bucket-name>

สร้างที่เก็บข้อมูลในภูมิภาคที่คุณต้องการเรียกใช้งาน Spark

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

คุณจะเห็นว่าที่เก็บข้อมูลพร้อมใช้งานใน คอนโซล Cloud Storage คุณยังเรียกใช้ gsutil ls เพื่อดูที่เก็บข้อมูลได้ด้วย

สร้างเซิร์ฟเวอร์ประวัติถาวร

Spark UI มีชุดเครื่องมือแก้ไขข้อบกพร่องและข้อมูลเชิงลึกเกี่ยวกับงาน Spark ที่สมบูรณ์ หากต้องการดู Spark UI สำหรับงาน Dataproc Serverless ที่เสร็จสมบูรณ์ คุณต้องสร้างคลัสเตอร์ 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 และเซิร์ฟเวอร์ประวัติถาวรใน Codelab ในภายหลัง

3. เรียกใช้งาน Serverless Spark ด้วยกลุ่ม Dataproc

ในตัวอย่างนี้ คุณจะได้ทำงานร่วมกับชุดข้อมูลจากชุดข้อมูลสาธารณะของ Citicycle Trips ในนิวยอร์กซิตี (NYC) NYC Citicycles เป็นระบบแชร์จักรยานแบบชำระเงินในนิวยอร์ก จากนั้นคุณจะต้องเปลี่ยนรูปแบบง่ายๆ แล้วพิมพ์รหัสสถานีจักรยานซิตี้จักรยานที่ได้รับความนิยมสูงสุด 10 รหัส ตัวอย่างนี้ยังใช้ spark-bigquery-connector โอเพนซอร์สเพื่ออ่านและเขียนข้อมูลระหว่าง Spark และ BigQuery อย่างราบรื่นด้วย

โคลนที่เก็บ 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")

ส่งงานไปยัง Serverless Spark โดยใช้ Cloud SDK ที่มีอยู่ใน Cloud Shell โดยค่าเริ่มต้น เรียกใช้คำสั่งต่อไปนี้ใน Shell ที่ใช้ 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 คือชื่อของงาน หากไม่ระบุ ระบบจะใช้ UUID ที่สร้างขึ้นแบบสุ่ม
--region=${REGION} คือภูมิภาคทางภูมิศาสตร์ที่จะมีการประมวลผลข้อมูลงาน
--deps-bucket=${BUCKET} เป็นที่ที่จะอัปโหลดไฟล์ Python ในเครื่องก่อนจะเรียกใช้ในสภาพแวดล้อมแบบ Serverless
--jars=gs://spark-lib/bigquery/spark-bigquery-with-dependencies_2.12-0.26.0.jar รวม Jar สำหรับ spark-bigquery-connector ในสภาพแวดล้อมรันไทม์ของ Spark
--history-server-cluster=projects/${GOOGLE_CLOUD_PROJECT}/regions/${REGION}/clusters/${PHS_CLUSTER} คือชื่อแบบเต็มของเซิร์ฟเวอร์ประวัติถาวร ซึ่งจะเป็นที่เก็บและดูข้อมูลเหตุการณ์ Spark (แยกจากเอาต์พุตคอนโซล) จาก Spark UI
-- ต่อท้ายหมายความว่าสิ่งอื่นๆ นอกเหนือจากนี้จะเป็นอาร์กิวเมนต์รันไทม์สำหรับโปรแกรม ในกรณีนี้ คุณกำลังส่งชื่อของที่เก็บข้อมูลตามที่งานกำหนด

คุณจะเห็นผลลัพธ์ต่อไปนี้เมื่อส่งกลุ่ม

Batch [citibike-job] submitted.

หลังจากผ่านไป 2-3 นาที คุณจะเห็นเอาต์พุตต่อไปนี้พร้อมข้อมูลเมตาจากงาน

+----------------+------+
|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 คุณจะมีตัวเลือกเพิ่มเติมในการทำงาน

คุณสร้างอิมเมจ Docker ที่กำหนดเองสำหรับใช้ในงานได้ นี่เป็นวิธีที่ยอดเยี่ยมในการรวมทรัพยากร Dependency เพิ่มเติม รวมถึงไลบรารี Python และ R
คุณเชื่อมต่ออินสแตนซ์ Dataproc Metastore กับงานเพื่อเข้าถึงข้อมูลเมตาของ Hive ได้
Dataproc Serverless รองรับการกำหนดค่าพร็อพเพอร์ตี้ Spark จำนวนหนึ่งเพื่อให้ควบคุมได้มากขึ้น

4. เมตริกและความสามารถในการสังเกตของ Dataproc

คอนโซล Dataproc Batches จะแสดงรายการงาน Dataproc Serverless ทั้งหมด ในคอนโซล คุณจะเห็นรหัสกลุ่ม สถานที่ตั้ง สถานะ เวลาที่สร้าง เวลาที่ผ่านไป และประเภทของแต่ละงาน คลิก Batch ID ของงานเพื่อดูข้อมูลเพิ่มเติม

ในหน้านี้ คุณจะเห็นข้อมูล เช่น Monitoring ซึ่งแสดงจำนวน Batch Spark Executor ที่งานของคุณใช้ตลอดไป (ระบุจำนวนงานที่มีการปรับสเกลอัตโนมัติ)

ในแท็บรายละเอียด คุณจะเห็นข้อมูลเมตาเพิ่มเติมเกี่ยวกับงาน รวมถึงอาร์กิวเมนต์และพารามิเตอร์ที่ส่งไปพร้อมกับงาน

นอกจากนี้ คุณยังเข้าถึงบันทึกทั้งหมดได้จากหน้านี้ เมื่อเรียกใช้งาน Dataproc Serverless ระบบจะสร้างบันทึกที่แตกต่างกัน 3 ชุด ได้แก่

ระดับบริการ
เอาต์พุตของคอนโซล
การบันทึกเหตุการณ์ Spark

ระดับบริการจะรวมบันทึกที่บริการ Dataproc Serverless สร้างขึ้น ซึ่งรวมถึง Dataproc Serverless ที่ขอ CPU เพิ่มเติมสำหรับการปรับขนาดอัตโนมัติ คุณดูบันทึกเหล่านี้ได้โดยคลิกดูบันทึก ซึ่งจะเปิด Cloud Logging

ดูเอาต์พุตของคอนโซลได้ในส่วนเอาต์พุต นี่เป็นเอาต์พุตที่งานสร้างขึ้น รวมถึงข้อมูลเมตาที่ Spark พิมพ์เมื่อเริ่มงานหรือข้อความการพิมพ์ใดๆ ที่รวมอยู่ในงาน

เข้าถึงการบันทึกเหตุการณ์ Spark ได้จาก Spark UI เนื่องจากคุณระบุงาน Spark ด้วยเซิร์ฟเวอร์ประวัติถาวร คุณจึงสามารถเข้าถึง Spark UI ได้โดยคลิกดูเซิร์ฟเวอร์ประวัติ Spark ซึ่งมีข้อมูลงาน Spark ที่คุณเรียกใช้ไว้ก่อนหน้านี้ ดูข้อมูลเพิ่มเติมเกี่ยวกับ Spark UI ได้จากเอกสารอย่างเป็นทางการของ Spark

5. เทมเพลต Dataproc: BQ -> GCS

เทมเพลต Dataproc เป็นเครื่องมือแบบโอเพนซอร์สที่ช่วยลดความซับซ้อนของงานการประมวลผลข้อมูลในระบบคลาวด์ ซึ่งจะทำหน้าที่เป็น Wrapper สำหรับ Dataproc Serverless และมีเทมเพลตสำหรับงานนำเข้าและส่งออกข้อมูลจำนวนมาก ได้แก่

BigQuerytoGCS และ GCStoBigQuery
GCStoBigTable
GCStoJDBC และ JDBCtoGCS
HivetoBigQuery
MongotoGCS และ GCStoMongo

ดูรายการทั้งหมดได้ที่ README

ในส่วนนี้ คุณจะได้ใช้เทมเพลต Dataproc เพื่อส่งออกข้อมูลจาก BigQuery ไปยัง GCS

โคลนที่เก็บ

โคลนที่เก็บและเปลี่ยนไปยังโฟลเดอร์ 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 ใช้ spark-bigquery-conector ในการประมวลผลงาน BigQuery และกําหนดให้รวม URI ไว้ในตัวแปรสภาพแวดล้อม 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 ก็ได้ สำหรับ Codelab นี้ ให้เลือก 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}

เอาต์พุตจะมีเสียงดังพอสมควร แต่หลังจากผ่านไปประมาณ 1 นาที คุณจะเห็นสิ่งต่อไปนี้

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

คุณยืนยันได้ว่าไฟล์สร้างขึ้นโดยเรียกใช้โค้ดต่อไปนี้

gsutil ls ${BIGQUERY_GCS_OUTPUT_LOCATION}

โดยค่าเริ่มต้น Spark จะเขียนไปยังหลายไฟล์โดยขึ้นอยู่กับปริมาณข้อมูล ในกรณีนี้ คุณจะเห็นไฟล์ที่สร้างขึ้นประมาณ 30 ไฟล์ ชื่อไฟล์เอาต์พุต Spark จะอยู่ในรูปแบบ part ตามด้วยตัวเลข 5 หลัก (ระบุหมายเลขส่วน) และสตริงแฮช สำหรับข้อมูลปริมาณมาก โดยปกติ Spark จะเขียนออกมาเป็นไฟล์หลายๆ ไฟล์ ตัวอย่างชื่อไฟล์คือ part-00000-cbf69737-867d-41cc-8a33-6521a725f7a0-c000.csv

6. เทมเพลต Dataproc: เปลี่ยนจาก CSV เป็น Parquet

ตอนนี้คุณจะใช้เทมเพลต Dataproc เพื่อแปลงข้อมูลใน GCS จากไฟล์ประเภทหนึ่งไปเป็นอีกประเภทหนึ่งโดยใช้ 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

ตั้งค่าโหมดเอาต์พุตเป็น overwrite คุณเลือกได้ระหว่าง overwrite, append, ignore หรือ errorifexists.

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}

ผลที่ได้ค่อนข้างจะเสียงดัง แต่หลังจากผ่านไปประมาณ 1 นาที คุณควรเห็นข้อความความสำเร็จดังด้านล่างนี้

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 ไปยังเทมเพลต ซึ่งทำให้เรียกใช้การค้นหา SparkSQL กับข้อมูลก่อนเขียนไปยัง GCS ได้

7. ล้างทรัพยากร

ทำตามขั้นตอนต่อไปนี้เพื่อหลีกเลี่ยงไม่ให้เกิดการเรียกเก็บเงินที่ไม่จำเป็นในบัญชี GCP หลังจากทำ Codelab เสร็จสิ้น

ลบที่เก็บข้อมูล Cloud Storage สำหรับสภาพแวดล้อมที่คุณสร้างขึ้น

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

ลบคลัสเตอร์ Dataproc ที่ใช้สำหรับเซิร์ฟเวอร์ประวัติถาวร

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

ลบงาน Dataproc Serverless ไปที่คอนโซลกลุ่ม คลิกช่องข้างงานที่ต้องการลบ แล้วคลิกลบ

หากสร้างโปรเจ็กต์สำหรับ Codelab นี้โดยเฉพาะ คุณจะเลือกลบโปรเจ็กต์ได้ด้วย โดยทำดังนี้

ในคอนโซล GCP ให้ไปที่หน้าโปรเจ็กต์
ในรายการโปรเจ็กต์ ให้เลือกโปรเจ็กต์ที่ต้องการลบ แล้วคลิกลบ
พิมพ์รหัสโปรเจ็กต์ในช่อง แล้วคลิกปิดเพื่อลบโปรเจ็กต์

ข้อควรระวัง: การลบโครงการจะมีผลกระทบดังต่อไปนี้

ทุกอย่างในโปรเจ็กต์จะถูกลบ หากคุณใช้โปรเจ็กต์ที่มีอยู่สำหรับบทแนะนำนี้ เมื่อคุณลบโปรเจ็กต์ดังกล่าว คุณจะลบงานอื่นๆ ที่เคยทำในโปรเจ็กต์แล้วด้วย
รหัสโปรเจ็กต์ที่กำหนดเองสูญหาย เมื่อสร้างโปรเจ็กต์นี้ คุณอาจสร้างรหัสโปรเจ็กต์ที่กําหนดเองที่ต้องการใช้ในอนาคต หากต้องการเก็บ URL ที่ใช้รหัสโปรเจ็กต์ เช่น URL ของ appspot.com ไว้ ให้ลบทรัพยากรที่เลือกภายในโปรเจ็กต์แทนการลบทั้งโปรเจ็กต์

8. ขั้นตอนถัดไป

แหล่งข้อมูลต่อไปนี้แสดงวิธีอื่นๆ ในการใช้ประโยชน์จาก Serverless Spark

ดูวิธีจัดการเวิร์กโฟลว์ Dataproc Serverless โดยใช้ Cloud Composer
ดูวิธีผสานรวม Dataproc Serverless กับไปป์ไลน์ Kubeflow