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

บริการที่มีการจัดการสำหรับ Apache Spark

1. ภาพรวม - Serverless สำหรับ Apache Spark

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

Apache Spark ที่มีการจัดการมีให้บริการ 2 รูปแบบ ได้แก่

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

ใน 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 Private Access ในภูมิภาคที่จะเรียกใช้ 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)"

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

สร้างที่เก็บข้อมูลที่จะใช้จัดเก็บชิ้นงานที่สร้างขึ้นในโค้ดแล็บนี้

เลือกชื่อสำหรับ Bucket ชื่อ Bucket ต้องไม่ซ้ำกันทั่วโลกสำหรับผู้ใช้ทั้งหมด

export BUCKET=<your-bucket-name>

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

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

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

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

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

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

คุณจะเห็นเอาต์พุตต่อไปนี้เมื่อส่งชุด

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

4. เมตริกและการสังเกต Dataproc

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

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

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

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

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

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

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

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

จากนั้นคุณจะตั้งค่าตัวแปรเฉพาะงานบางอย่าง สำหรับตารางอินพุต คุณจะต้องอ้างอิงชุดข้อมูล NYC Citibike ของ BigQuery อีกครั้ง

BIGQUERY_GCS_INPUT_TABLE=bigquery-public-data.new_york_citibike.citibike_trips

คุณเลือกได้ว่าจะใช้ csv, parquet, avro หรือ json สำหรับ Codelab นี้ ให้เลือก CSV ในส่วนถัดไปเกี่ยวกับวิธีใช้ Dataproc Templates เพื่อแปลงประเภทไฟล์

BIGQUERY_GCS_OUTPUT_FORMAT=csv

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

BIGQUERY_GCS_OUTPUT_MODE=overwrite

ตั้งค่าตำแหน่งเอาต์พุต GCS ให้เป็นเส้นทางใน Bucket

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 นี้เสร็จแล้ว

ลบ Bucket ของ 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 Pipelines