เริ่มต้นใช้งานงาน 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 Jobs มี 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 ของ Cloud การทำตาม Codelab นี้จะไม่เสียค่าใช้จ่ายมากนัก หรืออาจไม่เสียเลย หากต้องการปิดทรัพยากรเพื่อหลีกเลี่ยงการเรียกเก็บเงินนอกเหนือจากบทแนะนำนี้ คุณสามารถลบทรัพยากรที่สร้างขึ้นหรือลบโปรเจ็กต์ได้ ผู้ใช้ Google Cloud รายใหม่มีสิทธิ์เข้าร่วมโปรแกรมช่วงทดลองใช้ฟรีมูลค่า$300 USD

เริ่มต้น Cloud Shell

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

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

เปิดใช้งาน Cloud Shell

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

ภาพหน้าจอของเทอร์มินัล Google Cloud Shell ที่แสดงว่าสภาพแวดล้อมเชื่อมต่อแล้ว

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

ตั้งค่า gcloud

ใน Cloud Shell ให้ตั้งค่ารหัสโปรเจ็กต์และภูมิภาคที่คุณต้องการทำให้งาน Cloud Run ใช้งานได้ บันทึกเป็นตัวแปร 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 จะกำหนดอิมเมจคอนเทนเนอร์สำหรับแอปพลิเคชันที่มีไลบรารีและการอ้างอิงที่จำเป็นทั้งหมด

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-$RANDOM \
  --service-account=screenshot-sa@$PROJECT_ID.iam.gserviceaccount.com

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

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

คุณเรียกใช้สำเนาคอนเทนเนอร์หลายรายการพร้อมกันได้โดยระบุจำนวนงานที่จะเรียกใช้ด้วยแฟล็ก --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-$RANDOM

นอกจากนี้ คุณยังตรวจสอบสถานะได้ในหน้างาน Cloud Run ของ Cloud Console

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

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

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

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

7. อัปเดตงาน

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

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

อัปเดตงานและเปลี่ยนหน้าที่แอปจะถ่ายภาพหน้าจอใน--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

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

8. ตั้งเวลางาน

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

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

gcloud services enable cloudscheduler.googleapis.com

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

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

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

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

ตอนนี้คุณควรเห็นทริกเกอร์ Cloud Scheduler ใหม่ที่สร้างขึ้น

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

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

หลังจากผ่านไปสักครู่ คุณควรเห็นว่างาน 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