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

เริ่มต้นใช้งานงาน Cloud Run

1. บทนำ

ภาพรวม

บริการ Cloud Run เหมาะกับคอนเทนเนอร์ที่ทำงานเพื่อรอดูคำขอ HTTP ไปเรื่อยๆ ส่วนงานของ Cloud Run เหมาะกับคอนเทนเนอร์ที่ทำงานจนเสร็จสิ้น (ปัจจุบันไม่เกิน 24 ชั่วโมง) และไม่มีบริการตามคำขอ เช่น การประมวลผลระเบียนจากฐานข้อมูล การประมวลผลรายการไฟล์จากที่เก็บข้อมูล Cloud Storage หรือการดำเนินการที่ใช้เวลานาน เช่น การคำนวณ Pi จะมีประสิทธิภาพดีหากใช้งานเป็นงาน Cloud Run

งานไม่มีความสามารถในการให้บริการหรือฟังคำขอบนพอร์ต ซึ่งหมายความว่างานต่างๆ ไม่ควรรวมกลุ่มเว็บเซิร์ฟเวอร์ไว้ด้วยกัน ซึ่งต่างจากบริการ Cloud Run คอนเทนเนอร์งานควรออกเมื่อเสร็จสิ้นแทน

ในงาน Cloud Run คุณจะเรียกใช้สำเนาคอนเทนเนอร์หลายรายการพร้อมกันได้โดยการระบุจำนวนงาน แต่ละงานจะแสดงสำเนาของคอนเทนเนอร์ที่ทำงานอยู่ 1 รายการ การใช้หลายงานจะมีประโยชน์หากแต่ละงานสามารถประมวลผลข้อมูลชุดย่อยของคุณได้อย่างอิสระ เช่น การประมวลผลระเบียน 10,000 รายการจาก Cloud SQL หรือ 10,000 ไฟล์จาก Cloud Storage จะทำได้เร็วขึ้นด้วยงาน 10 รายการที่ประมวลผลระเบียนหรือไฟล์ 1,000 รายการพร้อมกัน

การใช้งาน Cloud Run เป็นกระบวนการที่มี 2 ขั้นตอนดังนี้

สร้างงาน: สรุปการกำหนดค่าทั้งหมดที่จำเป็นในการเรียกใช้งาน เช่น อิมเมจคอนเทนเนอร์ ภูมิภาค และตัวแปรสภาพแวดล้อม
เรียกใช้งาน:ตัวเลือกนี้จะสร้างการเรียกใช้งานใหม่ ตั้งค่างานให้เรียกใช้ตามกำหนดเวลาโดยใช้ Cloud Scheduler (ไม่บังคับ)

ใน Codelab นี้ คุณจะได้สำรวจแอปพลิเคชัน Node.js ก่อนเพื่อถ่ายภาพหน้าจอของหน้าเว็บและจัดเก็บไว้ใน Cloud Storage จากนั้นคุณจะสร้างอิมเมจคอนเทนเนอร์สำหรับแอปพลิเคชัน เรียกใช้บนงาน Cloud Run, อัปเดตงานเพื่อประมวลผลหน้าเว็บเพิ่มเติม และเรียกใช้งานตามกำหนดการด้วย Cloud Scheduler

สิ่งที่คุณจะได้เรียนรู้

วิธีใช้แอปเพื่อถ่ายภาพหน้าจอของหน้าเว็บ
วิธีสร้างอิมเมจคอนเทนเนอร์สำหรับแอปพลิเคชัน
วิธีสร้างงาน Cloud Run สำหรับแอปพลิเคชัน
วิธีเรียกใช้แอปพลิเคชันเป็นงาน Cloud Run
วิธีอัปเดตงาน
วิธีกำหนดเวลางานด้วย Cloud Scheduler

2. การตั้งค่าและข้อกำหนด

การตั้งค่าสภาพแวดล้อมตามเวลาที่สะดวก

ลงชื่อเข้าใช้ Google Cloud Console และสร้างโปรเจ็กต์ใหม่หรือใช้โปรเจ็กต์ที่มีอยู่ซ้ำ หากยังไม่มีบัญชี Gmail หรือ Google Workspace คุณต้องสร้างบัญชี

ชื่อโครงการคือชื่อที่แสดงของผู้เข้าร่วมโปรเจ็กต์นี้ เป็นสตริงอักขระที่ Google APIs ไม่ได้ใช้ โดยคุณจะอัปเดตวิธีการชำระเงินได้ทุกเมื่อ
รหัสโปรเจ็กต์จะไม่ซ้ำกันในทุกโปรเจ็กต์ของ Google Cloud และจะเปลี่ยนแปลงไม่ได้ (เปลี่ยนแปลงไม่ได้หลังจากตั้งค่าแล้ว) Cloud Console จะสร้างสตริงที่ไม่ซ้ำกันโดยอัตโนมัติ ปกติแล้วคุณไม่สนว่าอะไรเป็นอะไร ใน Codelab ส่วนใหญ่ คุณจะต้องอ้างอิงรหัสโปรเจ็กต์ (โดยปกติจะระบุเป็น PROJECT_ID) หากคุณไม่ชอบรหัสที่สร้างขึ้น คุณสามารถสร้างรหัสแบบสุ่มอื่นได้ หรือคุณจะลองดำเนินการเองแล้วดูว่าพร้อมให้ใช้งานหรือไม่ คุณจะเปลี่ยนแปลงหลังจากขั้นตอนนี้ไม่ได้และจะยังคงอยู่ตลอดระยะเวลาของโปรเจ็กต์
สำหรับข้อมูลของคุณ ค่าที่ 3 คือหมายเลขโปรเจ็กต์ ซึ่ง API บางตัวใช้ ดูข้อมูลเพิ่มเติมเกี่ยวกับค่าทั้ง 3 ค่าได้ในเอกสารประกอบ

ถัดไป คุณจะต้องเปิดใช้การเรียกเก็บเงินใน Cloud Console เพื่อใช้ทรัพยากร/API ของระบบคลาวด์ การใช้งาน Codelab นี้จะไม่มีค่าใช้จ่ายใดๆ หากมี หากต้องการปิดทรัพยากรเพื่อหลีกเลี่ยงการเรียกเก็บเงินที่นอกเหนือจากบทแนะนำนี้ คุณสามารถลบทรัพยากรที่คุณสร้างหรือลบโปรเจ็กต์ได้ ผู้ใช้ Google Cloud ใหม่มีสิทธิ์เข้าร่วมโปรแกรมช่วงทดลองใช้ฟรี$300 USD

เริ่มต้น Cloud Shell

แม้ว่าคุณจะดำเนินการ Google Cloud จากระยะไกลได้จากแล็ปท็อป แต่คุณจะใช้ Google Cloud Shell ซึ่งเป็นสภาพแวดล้อมแบบบรรทัดคำสั่งที่ทำงานในระบบคลาวด์ใน Codelab นี้

จากคอนโซล Google Cloud ให้คลิกไอคอน Cloud Shell ในแถบเครื่องมือด้านขวาบน ดังนี้

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

เครื่องเสมือนนี้เต็มไปด้วยเครื่องมือการพัฒนาทั้งหมดที่คุณต้องการ โดยมีไดเรกทอรีหลักขนาด 5 GB ที่ใช้งานได้ต่อเนื่องและทำงานบน Google Cloud ซึ่งช่วยเพิ่มประสิทธิภาพของเครือข่ายและการตรวจสอบสิทธิ์ได้อย่างมาก งานทั้งหมดใน Codelab นี้ทำได้ในเบราว์เซอร์ คุณไม่จำเป็นต้องติดตั้งอะไรเลย

ตั้งค่า gcloud

ตั้งค่ารหัสโปรเจ็กต์และภูมิภาคที่ต้องการทำให้งาน Cloud Run ใช้งานได้ใน Cloud Shell บันทึกเป็นตัวแปร PROJECT_ID และ REGION ในอนาคต คุณจะเลือกภูมิภาคได้จากตำแหน่ง Cloud Run ใดตำแหน่งหนึ่ง

PROJECT_ID=[YOUR-PROJECT-ID]
REGION=us-central1
gcloud config set core/project $PROJECT_ID

เปิดใช้ API

เปิดใช้บริการที่จำเป็นทั้งหมด

gcloud services enable \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com \
  run.googleapis.com

3. รับโค้ด

คุณสำรวจแอปพลิเคชัน Node.js ก่อนเพื่อถ่ายภาพหน้าจอของหน้าเว็บและจัดเก็บไว้ใน Cloud Storage หลังจากนั้น คุณสร้างอิมเมจคอนเทนเนอร์สำหรับแอปพลิเคชันและเรียกใช้เป็นงานบน Cloud Run ได้

จาก Cloud Shell ให้เรียกใช้คำสั่งต่อไปนี้เพื่อโคลนโค้ดของแอปพลิเคชันจากที่เก็บนี้

git clone https://github.com/GoogleCloudPlatform/jobs-demos.git

ไปที่ไดเรกทอรีที่มีแอปพลิเคชันด้วยคำสั่งต่อไปนี้

cd jobs-demos/screenshot

คุณควรจะเห็นเลย์เอาต์ไฟล์นี้

screenshot
 |
 ├── Dockerfile
 ├── README.md
 ├── screenshot.js
 ├── package.json

ต่อไปนี้เป็นคำอธิบายสั้นๆ ของแต่ละไฟล์

screenshot.js มีโค้ด Node.js สำหรับแอปพลิเคชัน
package.json กำหนดทรัพยากร Dependency ของไลบรารี
Dockerfile กำหนดอิมเมจคอนเทนเนอร์

4. สำรวจโค้ด

หากต้องการสำรวจโค้ด ให้ใช้ตัวแก้ไขข้อความในตัวโดยคลิกปุ่ม Open Editor ที่ด้านบนของหน้าต่าง Cloud Shell

ต่อไปนี้เป็นคำอธิบายสั้นๆ ของแต่ละไฟล์

screenshot.js

screenshot.js จะเพิ่ม Puppeteer และ Cloud Storage เป็นทรัพยากร Dependency ก่อน Puppeteer เป็นไลบรารี Node.js ที่ใช้จับภาพหน้าจอของหน้าเว็บ

const puppeteer = require('puppeteer');
const {Storage} = require('@google-cloud/storage');

มีฟังก์ชัน initBrowser ในการเริ่มต้นฟังก์ชัน Puppeteer และ takeScreenshot เพื่อถ่ายภาพหน้าจอของ URL ที่ระบุ ดังนี้

async function initBrowser() {
  console.log('Initializing browser');
  return await puppeteer.launch();
}

async function takeScreenshot(browser, url) {
  const page = await browser.newPage();

  console.log(`Navigating to ${url}`);
  await page.goto(url);

  console.log(`Taking a screenshot of ${url}`);
  return await page.screenshot({
    fullPage: true
  });
}

ถัดไป มีฟังก์ชันสำหรับรับหรือสร้างที่เก็บข้อมูล Cloud Storage และอีกฟังก์ชันสำหรับอัปโหลดภาพหน้าจอของหน้าเว็บไปยังที่เก็บข้อมูล

async function createStorageBucketIfMissing(storage, bucketName) {
  console.log(`Checking for Cloud Storage bucket '${bucketName}' and creating if not found`);
  const bucket = storage.bucket(bucketName);
  const [exists] = await bucket.exists();
  if (exists) {
    // Bucket exists, nothing to do here
    return bucket;
  }

  // Create bucket
  const [createdBucket] = await storage.createBucket(bucketName);
  console.log(`Created Cloud Storage bucket '${createdBucket.name}'`);
  return createdBucket;
}

async function uploadImage(bucket, taskIndex, imageBuffer) {
  // Create filename using the current time and task index
  const date = new Date();
  date.setMinutes(date.getMinutes() - date.getTimezoneOffset());
  const filename = `${date.toISOString()}-task${taskIndex}.png`;

  console.log(`Uploading screenshot as '${filename}'`)
  await bucket.file(filename).save(imageBuffer);
}

สุดท้าย ฟังก์ชัน main คือจุดแรกเข้า

async function main(urls) {
  console.log(`Passed in urls: ${urls}`);

  const taskIndex = process.env.CLOUD_RUN_TASK_INDEX || 0;
  const url = urls[taskIndex];
  if (!url) {
    throw new Error(`No url found for task ${taskIndex}. Ensure at least ${parseInt(taskIndex, 10) + 1} url(s) have been specified as command args.`);
  }
  const bucketName = process.env.BUCKET_NAME;
  if (!bucketName) {
    throw new Error('No bucket name specified. Set the BUCKET_NAME env var to specify which Cloud Storage bucket the screenshot will be uploaded to.');
  }

  const browser = await initBrowser();
  const imageBuffer = await takeScreenshot(browser, url).catch(async err => {
    // Make sure to close the browser if we hit an error.
    await browser.close();
    throw err;
  });
  await browser.close();

  console.log('Initializing Cloud Storage client')
  const storage = new Storage();
  const bucket = await createStorageBucketIfMissing(storage, bucketName);
  await uploadImage(bucket, taskIndex, imageBuffer);

  console.log('Upload complete!');
}

main(process.argv.slice(2)).catch(err => {
  console.error(JSON.stringify({severity: 'ERROR', message: err.message}));
  process.exit(1);
});

โปรดสังเกตสิ่งต่อไปนี้เกี่ยวกับเมธอด main

ระบบจะส่ง URL เป็นอาร์กิวเมนต์
ระบบจะส่งชื่อที่เก็บข้อมูลเป็นตัวแปรสภาพแวดล้อม BUCKET_NAME ที่กำหนดโดยผู้ใช้ ชื่อที่เก็บข้อมูลต้องไม่ซ้ำกันทั่วโลกใน Google Cloud
งาน Cloud Run จะส่งตัวแปรสภาพแวดล้อม CLOUD_RUN_TASK_INDEX งาน Cloud Run เรียกใช้สำเนาของแอปพลิเคชันเป็นงานที่ไม่ซ้ำกันได้หลายสำเนา CLOUD_RUN_TASK_INDEX แสดงดัชนีของงานที่กำลังทำงานอยู่ ค่าเริ่มต้นเป็น 0 เมื่อเรียกใช้โค้ดนอกงาน Cloud Run เมื่อแอปพลิเคชันทำงานหลายรายการ งาน/คอนเทนเนอร์แต่ละรายการจะรับ URL ที่รับผิดชอบ ถ่ายภาพหน้าจอ และบันทึกภาพลงในที่เก็บข้อมูล

package.json

ไฟล์ package.json จะกำหนดแอปพลิเคชันและระบุทรัพยากร Dependency สำหรับ Cloud Storage และ Puppeteer ดังนี้

{
  "name": "screenshot",
  "version": "1.0.0",
  "description": "Create a job to capture screenshots",
  "main": "screenshot.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "Google LLC",
  "license": "Apache-2.0",
  "dependencies": {
    "@google-cloud/storage": "^5.18.2",
    "puppeteer": "^13.5.1"
  }
}

Dockerfile

Dockerfile จะกำหนดอิมเมจคอนเทนเนอร์สำหรับแอปพลิเคชันด้วยไลบรารีและทรัพยากร Dependency ทั้งหมดที่จำเป็น

FROM ghcr.io/puppeteer/puppeteer:16.1.0
COPY package*.json ./
RUN npm ci --omit=dev
COPY . .
ENTRYPOINT ["node", "screenshot.js"]

5. ทำให้งานใช้งานได้

ก่อนสร้างงาน คุณต้องสร้างบัญชีบริการที่จะใช้เพื่อเรียกใช้งาน

gcloud iam service-accounts create screenshot-sa --display-name="Screenshot app service account"

มอบบทบาท storage.admin ให้กับบัญชีบริการเพื่อให้ใช้บทบาทดังกล่าวเพื่อสร้างที่เก็บข้อมูลและออบเจ็กต์ได้

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --role roles/storage.admin \
  --member serviceAccount:screenshot-sa@$PROJECT_ID.iam.gserviceaccount.com

ตอนนี้คุณพร้อมที่จะทำให้งาน Cloud Run ใช้งานได้ซึ่งมีการกำหนดค่าที่จำเป็นต่อการเรียกใช้งานแล้ว

gcloud beta run jobs deploy screenshot \
  --source=. \
  --args="https://example.com" \
  --args="https://cloud.google.com" \
  --tasks=2 \
  --task-timeout=5m \
  --region=$REGION \
  --set-env-vars=BUCKET_NAME=screenshot-$PROJECT_ID \
  --service-account=screenshot-sa@$PROJECT_ID.iam.gserviceaccount.com

การดำเนินการนี้ใช้การทำให้ใช้งานได้ตามแหล่งที่มาและสร้างงาน Cloud Run โดยไม่ต้องเรียกใช้งาน

สังเกตวิธีที่ระบบส่งหน้าเว็บเป็นอาร์กิวเมนต์ ระบบจะส่งชื่อที่เก็บข้อมูลที่จะบันทึกภาพหน้าจอเป็นตัวแปรสภาพแวดล้อม

คุณเรียกใช้สำเนาคอนเทนเนอร์หลายรายการพร้อมกันได้โดยระบุจำนวนงานที่จะทำงานด้วย Flag --tasks แต่ละงานจะแสดงสำเนาของคอนเทนเนอร์ที่ทำงานอยู่ 1 รายการ การใช้หลายงานจะมีประโยชน์หากแต่ละงานสามารถประมวลผลข้อมูลชุดย่อยของคุณได้อย่างอิสระ งานแต่ละรายการจะคำนึงถึงดัชนีซึ่งจัดเก็บไว้ในตัวแปรสภาพแวดล้อม CLOUD_RUN_TASK_INDEX เพื่อช่วยอำนวยความสะดวกในเรื่องนี้ โค้ดจะมีหน้าที่กำหนดว่างานใดจัดการชุดย่อยของข้อมูล ให้สังเกต --tasks=2 ในตัวอย่างนี้ วิธีนี้จะทำให้คอนเทนเนอร์ 2 รายการทำงานสำหรับ URL 2 รายการที่เราต้องการประมวลผล

แต่ละงานจะทํางานได้นานสูงสุด 24 ชั่วโมง คุณสามารถลดระยะหมดเวลานี้โดยใช้แฟล็ก --task-timeout ได้ ตามที่เราทำในตัวอย่างนี้ งานทั้งหมดต้องสำเร็จเพื่อให้งานเสร็จสมบูรณ์ โดยค่าเริ่มต้น ระบบจะไม่ลองทำงานที่ล้มเหลวซ้ำ คุณสามารถกำหนดค่างานให้ลองทำซ้ำเมื่อล้มเหลวได้ หากงานใดเกินจำนวนการลองใหม่ งานทั้งหมดจะล้มเหลว

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

6. เรียกใช้งาน

ก่อนที่จะเรียกใช้งาน ให้ระบุงานเพื่อดูว่ามีการสร้างงานแล้ว ดังนี้

gcloud run jobs list

✔
JOB: screenshot
REGION: us-central
LAST RUN AT:
CREATED: 2022-02-22 12:20:50 UTC

เรียกใช้งานด้วยคำสั่งต่อไปนี้

gcloud run jobs execute screenshot --region=$REGION

การดำเนินการนี้จะเรียกใช้งาน คุณสามารถระบุการดำเนินการปัจจุบันและในอดีตได้ ดังนี้

gcloud run jobs executions list --job screenshot --region=$REGION

...
JOB: screenshot
EXECUTION: screenshot-znkmm
REGION: $REGION
RUNNING: 1
COMPLETE: 1 / 2
CREATED: 2022-02-22 12:40:42 UTC

อธิบายการดำเนินการ คุณควรเห็นเครื่องหมายถูกสีเขียวและข้อความ tasks completed successfully รายการ

gcloud run jobs executions describe screenshot-znkmm --region=$REGION

✔ Execution screenshot-znkmm in region $REGION
2 tasks completed successfully


Image:           $REGION-docker.pkg.dev/$PROJECT_ID/containers/screenshot at 311b20d9...
Tasks:           2
Args:            https://example.com https://cloud.google.com
Memory:          1Gi
CPU:             1000m
Task Timeout:    3600s
Parallelism:     2
Service account: 11111111-compute@developer.gserviceaccount.com
Env vars:
  BUCKET_NAME    screenshot-$PROJECT_ID

คุณยังตรวจสอบหน้างาน Cloud Run ของ Cloud Console เพื่อดูสถานะได้ดังนี้

หากเลือกที่เก็บข้อมูล Cloud Storage คุณควรเห็นไฟล์ภาพหน้าจอ 2 ไฟล์ที่สร้างขึ้นต่อไปนี้

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

หากต้องการหยุดการดำเนินการของงาน คุณต้องลบการดำเนินการดังนี้

gcloud run jobs executions delete screenshot-znkmm --region=$REGION

7. อัปเดตงาน

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

ในทำนองเดียวกัน คุณจะต้องอัปเดตงานด้วยหากต้องการอัปเดตตัวแปรการกำหนดค่าบางรายการ การดำเนินการงานต่อๆ ไปจะใช้การตั้งค่าคอนเทนเนอร์และการกำหนดค่าใหม่

อัปเดตงานและเปลี่ยนหน้าที่แอปถ่ายภาพหน้าจอใน Flag --args อัปเดตแฟล็ก --tasks เพื่อแสดงจำนวนหน้าด้วย

gcloud run jobs update screenshot \
  --args="https://www.pinterest.com" \
  --args="https://www.apartmenttherapy.com" \
  --args="https://www.google.com" \
  --region=$REGION \
  --tasks=3

เรียกใช้งานอีกครั้ง เวลาที่ผ่านไปในแฟล็ก --wait เพื่อรอให้การดำเนินการเสร็จสิ้น:

gcloud run jobs execute screenshot --region=$REGION --wait

หลังจากผ่านไป 2-3 วินาที คุณจะเห็นภาพหน้าจออีก 3 ภาพเพิ่มลงในที่เก็บข้อมูล ดังนี้

8. กำหนดเวลางาน

ถึงตอนนี้คุณกำลังเรียกใช้งานด้วยตนเอง ในสถานการณ์จริง คุณอาจต้องเรียกใช้งานตามเหตุการณ์หรือตามตารางเวลา มาดูวิธีเรียกใช้งานภาพหน้าจอตามกำหนดการโดยใช้ Cloud Scheduler กัน

ก่อนอื่นให้ตรวจสอบว่า Cloud Scheduler API เปิดใช้อยู่ โดยทำดังนี้

gcloud services enable cloudscheduler.googleapis.com

ไปที่หน้ารายละเอียดงาน Cloud Run แล้วคลิกส่วน Triggers

เลือกปุ่ม Add Scheduler Trigger:

จากนั้นแผงจะเปิดขึ้นทางด้านขวา สร้างงานเครื่องจัดตารางเวลาเพื่อเรียกใช้ทุกวัน เวลา 9:00 น. ด้วยการกำหนดค่านี้และเลือก Continue

ในหน้าถัดไป ให้เลือกบัญชีบริการเริ่มต้นของ Compute แล้วเลือก Create:

ตอนนี้คุณควรเห็นทริกเกอร์ Cloud Scheduler ใหม่แล้ว:

คลิก View Details เพื่อไปที่หน้า Cloud Scheduler

คุณจะรอจนถึง 9:00 น. เพื่อให้เครื่องจัดตารางเวลาเริ่มทำงาน หรือจะเรียกใช้ Cloud Scheduler ด้วยตนเองโดยเลือก Force Run ได้ดังนี้

หลังจากผ่านไป 2-3 วินาที คุณควรเห็นว่างาน Cloud Scheduler ดำเนินการสำเร็จแล้ว:

คุณควรเห็นภาพหน้าจออีก 3 ภาพเพิ่มเข้ามาจากการโทรจาก Cloud Scheduler ดังนี้

9. ขอแสดงความยินดี

ยินดีด้วย คุณศึกษา Codelab จบแล้ว

ทำความสะอาด (ไม่บังคับ)

คุณควรล้างทรัพยากรเพื่อหลีกเลี่ยงการเรียกเก็บเงิน

หากคุณไม่ต้องการใช้โปรเจ็กต์ ก็ลบโปรเจ็กต์ได้เลย โดยทำดังนี้

gcloud projects delete $PROJECT_ID

หากต้องการใช้โปรเจ็กต์ คุณจะลบทรัพยากรทีละรายการได้

ลบซอร์สโค้ด โดยทำดังนี้

rm -rf ~/jobs-demos/

ลบที่เก็บ Artifact Registry ด้วยคำสั่งต่อไปนี้

gcloud artifacts repositories delete containers --location=$REGION

ลบบัญชีบริการ

gcloud iam service-accounts delete screenshot-sa@$PROJECT_ID.iam.gserviceaccount.com

ลบงาน Cloud Run:

gcloud run jobs delete screenshot --region=$REGION

ลบงาน Cloud Scheduler:

gcloud scheduler jobs delete screenshot-scheduler-trigger --location=$REGION

ลบที่เก็บข้อมูล Cloud Storage โดยทำดังนี้

gcloud storage rm --recursive gs://screenshot-$PROJECT_ID

สรุปประเด็นที่ได้พูดถึง

วิธีใช้แอปเพื่อถ่ายภาพหน้าจอของหน้าเว็บ
วิธีสร้างอิมเมจคอนเทนเนอร์สำหรับแอปพลิเคชัน
วิธีสร้างงาน Cloud Run สำหรับแอปพลิเคชัน
วิธีเรียกใช้แอปพลิเคชันเป็นงาน Cloud Run
วิธีอัปเดตงาน
วิธีกำหนดเวลางานด้วย Cloud Scheduler