การจัดการและความปลอดภัยของคีย์ API

1. บทนำ

ในอดีต คีย์ API ของ Google ใช้เพื่อเข้าถึง Google API เมื่อไม่มีวิธีการอื่นๆ หรือเมื่อวิธีการอื่นๆ ไม่สะดวก กรณีการใช้งานยอดนิยมคือการเข้าถึง Google Maps API และ Google APIs ที่ Firebase แสดง การเปิดตัวโมเดล AI, เอเจนต์ AI เช่น Gemini รวมถึงเฟรมเวิร์กการพัฒนา AI Studio และเอเจนต์ เช่น Agent Development Kit ทำให้คีย์ API กลายเป็นวิธีหลักในการเข้าถึงโมเดลภาษาขนาดใหญ่ของ Google

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

ℹ️ หมายเหตุ: หากไม่ได้ใช้คีย์ API คุณจะรับเอาต์พุตที่ถูกต้องไม่ได้เมื่อทำตามขั้นตอนของ CodeLab นี้

สิ่งที่คุณต้องทำ

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

สิ่งที่คุณต้องมี

• เว็บเบราว์เซอร์รุ่นใหม่ (เช่น Chrome)
• บัญชี Google

2. ตั้งค่า

คำสั่งใน Codelab นี้ถือว่าคุณเรียกใช้คำสั่งใน Cloud Shell ในคอนโซล Google Cloud หากมี gcloud CLI ในสภาพแวดล้อมในเครื่อง คุณจะเรียกใช้คำสั่งได้ที่นั่น

แม้ว่าการดำเนินการในขั้นตอนต่างๆ จะทำได้โดยใช้ UI ของ Cloud Console แต่ก็มีวิธีการที่แตกต่างกัน Codelab นี้ใช้อินเทอร์เฟซบรรทัดคำสั่งเพื่อลดความซับซ้อนของการโต้ตอบและช่วยให้ผสานรวมกับ AI Agent สมัยใหม่ (เช่น Antigravity CLI) ได้ง่ายขึ้น

เริ่มเทอร์มินัล Cloud Shell

1. เปิดคอนโซล Google Cloud โดยใช้ https://console.cloud.google.com/ ในหน้าต่างเบราว์เซอร์ใหม่ ขอแนะนำให้ใช้ Chrome เพื่อประสบการณ์ของผู้ใช้ที่ดีที่สุด
2. ลงชื่อเข้าใช้บัญชี Google ใน Google Cloud
3. คลิกเปิดใช้งาน Cloud Shell ที่ด้านบนของคอนโซล Google Cloud
   หากแสดง ให้คลิกผ่านหน้าต่างต่อไปนี้
   • ดำเนินการต่อผ่านหน้าต่างข้อมูล Cloud Shell
   • ให้สิทธิ์ Cloud Shell ในการใช้ข้อมูลเข้าสู่ระบบเพื่อทำการเรียก API ของ Google Cloud

เลือกโปรเจ็กต์ที่อยู่ใน Google Cloud

หลังจากเปิด Cloud Console แล้ว ระบบจะตรวจสอบสิทธิ์ของคุณ และโดยปกติจะมีตัวเลือกโปรเจ็กต์ให้คุณเลือกใช้ในการทำงาน รหัสโปรเจ็กต์คือลำดับอักขระ 6-30 ตัวซึ่งประกอบด้วยตัวอักษรพิมพ์เล็ก ตัวเลข และสัญลักษณ์ขีดกลาง เช่น qwiklabs-gcp-04-3075fc9fd77f เทอร์มินัล Cloud Shell จะกำหนดค่า gcloud CLI ด้วยโปรเจ็กต์ที่เลือก คุณจะเห็นเอาต์พุตในลักษณะนี้

Your Cloud Platform project in this session is set to qwiklabs-gcp-04-3075fc9fd77f

ซึ่งหมายความว่าคำสั่งเพิ่มเติมที่คุณส่งไปยัง gcloud จะใช้รหัสโปรเจ็กต์ qwiklabs-gcp-04-3075fc9fd77f

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

gcloud projects list

• แทนที่ your-project-id แล้วเรียกใช้คำสั่งหากต้องการใช้รหัสโปรเจ็กต์ที่แตกต่างจากที่กำหนดค่าไว้ใน gcloud

  export PROJECT_ID="your-project-id"
  

  ตัวอย่างเช่น

  export PROJECT_ID="qwiklabs-gcp-04-3075fc9fd77f"
  

• เรียกใช้คำสั่งต่อไปนี้หากต้องการใช้รหัสโปรเจ็กต์ที่เลือก

  export PROJECT_ID=$(gcloud config get project)
  

3. จำกัดคีย์ API ใหม่

ในอดีต ผู้ใช้สามารถสร้างคีย์ API ที่ไม่มีข้อจำกัดใดๆ ได้ คีย์ที่ไม่มีข้อจำกัดสามารถใช้เรียก Google API ใดก็ได้ที่เปิดใช้ในโปรเจ็กต์ที่สร้างคีย์ แม้ว่าคอนโซล Google Cloud จะป้องกันไม่ให้ผู้ใช้สร้างคีย์ที่ไม่จำกัด แต่ก็ยังสามารถสร้างได้โดยใช้ gcloudCLI หรือใช้การเรียก API โดยตรง

ขั้นตอนต่อไปนี้แสดงวิธีสร้างคีย์ API ที่จำกัดซึ่งจำกัดการใช้งานไว้ที่ API ที่เฉพาะเจาะจงและเว็บไซต์ที่ระบุ

1. หากต้องการสร้างคีย์ API ใหม่ที่จำกัดให้ใช้กับ Google Map Geolocation API เท่านั้น ให้เรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัลเชลล์

   gcloud services api-keys create --key-id=restricted-api-key \
     --display-name="restricted api key" \
     --api-target=service=geolocation.googleapis.com \
     --project=${PROJECT_ID}
   

   คำสั่งนี้จะสร้างคีย์ API ใหม่ที่ใช้ได้เฉพาะในการเรียกใช้บริการระบุตำแหน่งทางภูมิศาสตร์ของ Google Maps

   ℹ️ หมายเหตุ: คุณเพิ่ม API หลายรายการลงในรายการที่ถูกจำกัดได้ ใช้พารามิเตอร์ --api-target หลายรายการที่มีค่า =service=SERVICE.googleapis.com โดยที่ SERVICE คือบริการของ Google อย่างใดอย่างหนึ่ง

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

   gcloud services api-keys update restricted-api-key \
     --location=global \
     --allowed-referrers="example.com/*" \
     --project=${PROJECT_ID}
   

   คุณสามารถใช้ --allowed-application เพื่อกำหนดแอปพลิเคชัน Android ที่อนุญาตหรือallowed-ips เพื่อกำหนดที่อยู่ IP ที่อนุญาตแทนการอนุญาตให้ใช้คีย์กับเว็บไซต์ที่เฉพาะเจาะจง ดูตัวเลือกทั้งหมดได้ในเอกสารประกอบฉบับสมบูรณ์

   ℹ️ หมายเหตุ: คุณเพิ่มข้อจำกัดของแอปพลิเคชันประเภทเดียวกันได้มากกว่า 1 รายการโดยระบุพารามิเตอร์หลายรายการ (เช่น --allowed-referrers) การเพิ่มข้อจำกัดของแอปพลิเคชันหลายประเภทจะบันทึกเฉพาะประเภทล่าสุดในรายการพารามิเตอร์

ล้างข้อมูล

ลบคีย์ API ที่คุณสร้างขึ้น เว้นแต่คุณวางแผนที่จะใช้คีย์ดังกล่าว

gcloud services api-keys delete --key-id=restricted-api-key \
  --project=${PROJECT_ID}

4. จัดทำแคตตาล็อกคีย์ API

ในขั้นตอนนี้ คุณจะใช้ gcloudCLI เพื่อดูรายการคีย์ API รายการที่ได้จะแสดงคีย์ API ทั้งหมดที่ใช้งานอยู่ (ไม่ได้ถูกลบ) ซึ่งคุณมีสิทธิ์เข้าถึง

⚠️ ข้อควรระวัง: คุณจะดูคีย์ได้เฉพาะในโปรเจ็กต์ Google Cloud ที่คุณมีสิทธิ์เข้าถึง หากคุณสร้างคีย์ API (เช่น คีย์ Google Maps) โดยใช้อินเทอร์เฟซที่จัดการโปรเจ็กต์ในนามของคุณโดยไม่ได้ให้สิทธิ์เข้าถึง คุณจะดูคีย์ในโปรเจ็กต์นั้นโดยใช้ gcloud CLI ไม่ได้

1. เรียกใช้คำสั่งต่อไปนี้เพื่อดูชื่อคีย์ รหัส และวันที่สร้างทั้งหมด

   gcloud services api-keys list --project=${PROJECT_ID} \
     --format='value(displayName,name.basename(),createTime.date())'
   

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

   api key 1	api-key-1	2024-05-10T07:53:24
   api key 2	api-key-2	2025-06-12T14:47:57
   

2. เลือกคีย์รหัสใดรหัสหนึ่งและวางคำสั่งต่อไปนี้เพื่อตรวจสอบว่าคีย์มีข้อจำกัดหรือไม่ แทนที่ your-key-id ด้วยค่าของรหัสคีย์ที่เลือก

   gcloud services api-keys describe "your-key-id" --project=${PROJECT_ID}
   

เอาต์พุต (ใน YAML) จะมีรายการข้อจำกัดภายใต้ restrictions

createTime: '2024-05-10T07:53:24.986528Z'
displayName: api key 1
etag: W/"u1WuY41K2tPKUZd7cfLoKg=="
name: projects/123456789012/locations/global/keys/api-key-1
restrictions:
  apiTargets:
  - service: geolocation.googleapis.com
  browserKeyRestrictions:
    allowedReferrers:
    - https://example.com/*
uid: 1a2b3c4d-1234-abcd-1234-a1b2c3d4e5f6
updateTime: '2024-05-10T07:53:24.071228Z'

โปรดทราบว่าหากไม่เคยอัปเดตคีย์ ฟิลด์ createTime และ updateTime จะมีการประทับเวลาเดียวกัน

‼️ ข้อควรระวัง: หากเอาต์พุตไม่มีฟิลด์ restrictions แสดงว่าคีย์ API นี้ไม่ได้ถูกจำกัด

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

   curl -fsSL -o unrestricted_api_keys.sh \
     "https://github.com/GoogleCloudPlatform/devrel-demos/blob/main/security/api-key-audit/unrestricted_api_keys.sh"
   chmod +x unrestricted_api_keys.sh
   ./unrestricted_api_keys.sh
   

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

   DISPLAY NAME    KEY ID    PROJECT ID    CREATION DATE
   Key 1    1a2b3c4d-1234-abcd-1234-a1b2c3d4e5f6    my-project-1    2024-05-10T07:53:24.071228Z
   

   คุณดูสคริปต์ทั้งหมดที่ใช้ใน Codelab นี้ได้ที่โฟลเดอร์ความปลอดภัยในที่เก็บ devrel-demos บน GitHub

5. ค้นพบการใช้งานคีย์ API

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

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

1. ใช้รหัสคีย์เดียวกันกับที่ใช้ในขั้นตอนก่อนหน้าหรือเลือกรหัสคีย์อื่น แทนที่ your-key-id ด้วยรหัสคีย์ที่เลือกในคำสั่งต่อไปนี้

   export KEY_UID=$(
      gcloud services api-keys describe "your-key-id" \
      --format='value(uid)' \
      --project=${PROJECT_ID})
   

2. ตั้งค่าการค้นหาให้ดูประวัติการใช้งานย้อนหลัง 1 ปี หากต้องการค้นหาระยะเวลาที่นานขึ้นหรือสั้นลง ให้แทนที่ 365 (จํานวนวัน) ด้วยตัวเลขบวกอื่น

   export DAYS=365
   

3. รีเฟรชข้อมูลรับรองเริ่มต้นของแอปพลิเคชัน (ADC) เพื่อเปิดใช้การเรียก Cloud Monitoring API โดยตรง เรียกใช้คำสั่งต่อไปนี้และทำตามวิธีการในเทอร์มินัล

   gcloud auth application-default login
   

4. เรียกใช้คำสั่งต่อไปนี้เพื่อส่งคำขอข้อมูลเมตริกการใช้งานบริการไปยัง Cloud Monitoring API

curl -s -G -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  --data-urlencode "filter=metric.type=\"serviceruntime.googleapis.com/api/request_count\" AND resource.labels.credential_id=\"apikey:${KEY_UID}\"" \
  --data-urlencode "interval.startTime=$(date -u -d "${DAYS} days ago" +%Y-%m-%dT%H:%M:%SZ)" \
  --data-urlencode "interval.endTime=$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
  "https://monitoring.googleapis.com/v3/projects/${PROJECT_ID}/timeSeries" \
  | jq -r '.timeSeries[]?.resource.labels.service' | sort -u

คำสั่งจะค้นหาเมตริกในตัว serviceruntime/api/request_count สำหรับจุดข้อมูลที่มีป้ายกำกับ credential_id ซึ่งตรงกับรหัสที่ไม่ซ้ำกันของคีย์ API ที่เลือก จากนั้นจะดึงค่าสำหรับป้ายกำกับ service และพิมพ์ค่าโดยไม่ให้มีค่าซ้ำ

การปิดช่องโหว่คีย์ API

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

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

1. เรียกใช้คำสั่งต่อไปนี้เพื่อดึงข้อมูลรายการ Google APIs ที่เรียกใช้โดยใช้คีย์ API

SERVICES=$(curl -s -G -H "Authorization: Bearer $(gcloud auth application-default print-access-token)"
–data-urlencode "filter=metric.type="serviceruntime.googleapis.com/api/request_count" AND resource.labels.credential_id="apikey:${KEY_UID}""
–data-urlencode "interval.startTime=$(date -u -d "${DAYS} days ago" +%Y-%m-%dT%H:%M:%SZ)"
–data-urlencode "interval.endTime=$(date -u +%Y-%m-%dT%H:%M:%SZ)"
"https://monitoring.googleapis.com/v3/projects/${PROJECT_ID}/timeSeries"
| jq -r ‘.timeSeries[]?.resource.labels.service' | sort -u)

1. Build the list of arguments to restrict the API usage for the API key based
on the retrieved list.

```shell
API_TARGET_ARGS=()
for SERVICE in $SERVICES; do
  API_TARGET_ARGS+=("--api-target=service=${SERVICE}")
done

1. แทนที่รายการ API ที่ถูกจำกัดสำหรับรายการที่ไม่ว่างเปล่า

   if [ ${#API_TARGET_ARGS[@]} -gt 0 ]; then
       gcloud services api-keys update "projects/${PROJECT_ID}/locations/global/keys/${KEY_UID}" \
       ${API_TARGET_ARGS}
   fi
   

6. กำหนดการตรวจจับการใช้งานที่ผิดปกติ

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

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

วิธีการต่อไปนี้จะสร้างการแจ้งเตือนที่เริ่มทำงานเมื่ออัตราการเรียก API ที่ใช้คีย์ API เพิ่มขึ้นมากกว่า 10% ในช่วง 5 นาทีที่ผ่านมา ระบบจะกำหนดค่าการแจ้งเตือนให้ทริกเกอร์สคริปต์ Cloud Build ซึ่งจะลบคีย์ API เพื่อป้องกันการใช้งานเพิ่มเติม คุณจะกู้คืนคีย์ได้ภายใน 30 วันข้างหน้า ดูวิธีเลิกการลบคีย์ได้ในเอกสารประกอบ

‼️ ข้อควรระวัง: เวิร์กโฟลว์ไม่ใช่แบบอะตอม ตั้งแต่ตรวจพบการใช้งานที่ผิดปกติจนกว่าสคริปต์ Cloud Build จะลบคีย์ อาจใช้เวลาหลายนาที

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

1. เรียกใช้สคริปต์ต่อไปนี้เพื่อสร้างไฟล์นโยบายการแจ้งเตือน

   cat <<EOF > alert_policy.json
   {
     "displayName": "Credential API Request Count Increase Alert (Project: ${PROJECT_ID})",
     "combiner": "OR",
     "conditions": [
       {
         "displayName": "API Request Count Increase > 10% in 5m with Min Volume",
         "conditionPrometheusQueryLanguage": {
           "query": "(sum(increase(serviceruntime_googleapis_com:api_request_count{metric_label_credential_id=\\"apikey:${KEY_UID}\\"}[5m])) / (sum(increase(serviceruntime_googleapis_com:api_request_count{metric_label_credential_id=\\"apikey:${KEY_UID}\\"}[5m] offset 5m)) or on() vector(1)) > 1.10) and (sum(increase(serviceruntime_googleapis_com:api_request_count{metric_label_credential_id=\\"apikey:${KEY_UID}\\"}[5m])) > 50)",
           "duration": "0s",
           "evaluationInterval": "60s"
         }
       }
     ],
     "enabled": true
   }
   EOF
   

   นโยบายการแจ้งเตือนใช้ตัวกรอง PromQL ต่อไปนี้เพื่อทริกเกอร์การแจ้งเตือน

    (sum(
      increase(
        serviceruntime_googleapis_com:api_request_count{metric_label_credential_id="API_KEY_UID"}[5m])
    ) /
    (sum(
      increase(
        serviceruntime_googleapis_com:api_request_count{metric_label_credential_id="API_KEY_UID"}[5m] offset 5m)
    ) or on() vector(1)) > 1.10)
   and
    (sum(
      increase(
        serviceruntime_googleapis_com:api_request_count{metric_label_credential_id=\"YOUR_CREDENTIAL_ID_HERE\"}[5m])) > 50)
   

   โดยจะคำนวณอัตราการเพิ่มขึ้นและเปรียบเทียบกับกรอบเวลาก่อนหน้า และทริกเกอร์การแจ้งเตือนก็ต่อเมื่อมากกว่า 10% หากต้องการหลีกเลี่ยงการทริกเกอร์การแจ้งเตือนเมื่อจำนวนการโทรทั้งหมดไม่สำคัญ ระบบจะกำหนดเงื่อนไขการทริกเกอร์ให้มีการเรียก API มากกว่า 50 ครั้งในหน้าต่าง เพื่อหลีกเลี่ยงการคำนวณ NaN (ลบด้วย 0) เมื่ออัตรา 5 นาทีก่อนหน้าเป็น 0 ระบบจะแทนที่ตัวส่วนด้วย 1 หากอัตราหน้าต่างก่อนหน้าเป็น 0 คุณสามารถเปลี่ยนพารามิเตอร์การแจ้งเตือน เช่น ความยาวของหน้าต่าง (5m) เกณฑ์ขั้นต่ำ (50) หรือเกณฑ์การเพิ่มขึ้น 10% (1.10) พารามิเตอร์นโยบายเพิ่มเติมจะกำหนดว่าเมื่อถึงเงื่อนไขแล้ว ระบบควรทริกเกอร์การแจ้งเตือน (duration) และควรตรวจสอบเงื่อนไขทุกๆ 60 วินาที (evaluationInterval)
2. เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างหัวข้อ PubSub ที่จะใช้ในการโพสต์การแจ้งเตือน

   gcloud pubsub topics create api-key-alert-notifications --project=$PROJECT_ID
   

3. เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างช่องทางการแจ้งเตือนสำหรับการแจ้งเตือนที่ใช้ PubSub

   CHANNEL_NAME=$(gcloud beta monitoring channels create \
     --display-name="Pub/Sub Alert Channel" \
     --type="pubsub" \
     --channel-labels="topic=projects/$PROJECT_ID/topics/api-key-alert-notifications" \
     --format='value(name)' \
     --project=$PROJECT_ID)
   

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

   gcloud monitoring policies create --policy-from-file=alert_policy.json \
     --project=$PROJECT_ID
   

5. เรียกใช้คำสั่งต่อไปนี้เพื่อมอบสิทธิ์ของบริการ Cloud Build ในการลบคีย์ API ในโปรเจ็กต์

   PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com" \
     --role="roles/apikeys.admin"
   

   คุณสามารถจำกัดบทบาท apikeys.admin ให้จัดการเฉพาะอินสแตนซ์ที่เฉพาะเจาะจงของคีย์ API ได้ ดูรายละเอียดเพิ่มเติมได้ที่เงื่อนไข IAM
6. เรียกใช้สคริปต์ต่อไปนี้เพื่อสร้างทริกเกอร์ Cloud Build ที่ลบคีย์ API

   cat <<EOF > trigger_config.yaml
   name: "delete-compromised-api-key"
   description: "Triggered by Pub/Sub alert to automatically delete the leaking API Key"
   pubsubConfig:
     topic: "projects/${PROJECT_ID}/topics/api-key-alert-notifications"
   build:
     steps:
     - name: "gcr.io/google.com/cloudsdktool/cloud-sdk:slim"
       args:
       - "gcloud"
       - "services"
       - "api-keys"
       - "delete"
       - "${KEY_UID}"
       - "--quiet"
   EOF
   

7. เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างทริกเกอร์การแจ้งเตือนการตรวจสอบใหม่

   gcloud builds triggers create pubsub \
     --trigger-config=trigger_config.yaml \
     --project=$PROJECT_ID
   

ตอนนี้คุณลบไฟล์การกำหนดค่านโยบายการแจ้งเตือนและทริกเกอร์บิลด์ Cloud Build ได้แล้ว โดยทำดังนี้

rm alert_policy.json trigger_config.yaml

หรือจะตั้งค่าการทำงานอัตโนมัตินี้โดยใช้แผน Terraform ก็ได้ ดาวน์โหลดไฟล์ Terraform จากโฟลเดอร์ abnormal-usage-detection ในที่เก็บ Google Cloud DevRel โดยแพ็กเกจจะยอมรับรหัสโปรเจ็กต์และ UID ของคีย์ API เป็นพารามิเตอร์อินพุต และตั้งค่าทรัพยากรและการกำหนดค่าที่คุณเห็นในขั้นตอนนี้

7. ล้างข้อมูล

โปรดอย่าลืมลบหัวข้อ Pub/Sub, ทริกเกอร์บิลด์ Cloud Build และนโยบายการแจ้งเตือนที่สร้างขึ้นระหว่างการฝึกนี้ เพื่อหลีกเลี่ยงการเรียกเก็บเงินที่ไม่คาดคิดในบัญชี Google Cloud

เรียกใช้คำสั่งต่อไปนี้เพื่อลบทรัพยากรทั้งหมดที่คุณสร้างขึ้น

gcloud builds triggers delete delete-compromised-api-key \
  --project=$PROJECT_ID
gcloud beta monitoring channels delete $CHANNEL_NAME \
  --project=$PROJECT_ID \
  --quiet
gcloud pubsub topics delete api-key-alert-notifications \
  --project=$PROJECT_ID
gcloud projects remove-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com" \
  --role="roles/apikeys.admin"

8. สรุป

ใน Codelab นี้ คุณได้ใช้เฟรมเวิร์กการรักษาความปลอดภัยและการทำงานอัตโนมัติแบบครบวงจรที่แข็งแกร่งสำหรับคีย์ API ของ Google Cloud ดังนี้

1. การกำหนดค่าเริ่มต้นที่เพิ่มความปลอดภัย: คุณสร้างและจำกัดคีย์ API เพื่อจำกัดการเข้าถึงเฉพาะ API ที่จำเป็นและแพลตฟอร์มที่เชื่อถือได้ (เช่น ผู้อ้างอิง HTTP ที่เฉพาะเจาะจง)
2. ตรวจสอบคลังคีย์: คุณสแกนสภาพแวดล้อมของโปรเจ็กต์เพื่อตรวจหาและแยกคีย์ที่ไม่จำกัดซึ่งมีความเสี่ยงด้านความปลอดภัยในทันที
3. ข้อมูลการใช้งานที่วิเคราะห์แล้ว: คุณได้ค้นหาข้อมูลเมตริกของ Cloud Monitoring โดยใช้โปรแกรมเพื่อสร้างโปรไฟล์การใช้คีย์ที่ผ่านมา ซึ่งช่วยให้คุณจำกัดคีย์ตามร่องรอยการใช้งานที่ยืนยันแล้วได้
4. การลดความเสี่ยงจากภัยคุกคามอัตโนมัติ: คุณสร้าง "เซอร์กิตเบรกเกอร์" แบบรีแอกทีฟโดยเชื่อมโยงนโยบายการแจ้งเตือนของ Cloud Monitoring กับหัวข้อ Pub/Sub และทริกเกอร์ Cloud Build ซึ่งช่วยให้คุณลบคีย์ที่ถูกบุกรุกโดยอัตโนมัติในระหว่างที่มีการเพิ่มขึ้นของการเข้าชมที่ผิดปกติ

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

• ใช้การจำกัดกับคีย์ API ทั้งหมด: ใช้สิ่งที่ได้เรียนรู้ในแล็บนี้เพื่อตรวจหาคีย์ API ที่มีการจำกัดบางส่วนหรือไม่มีการจำกัดทั้งหมด แล้วใช้การจำกัด API และไคลเอ็นต์
• ตั้งค่า "เบรกเกอร์" ในคีย์ API: ปกป้องคีย์ API เพิ่มเติมจากการใช้งานที่ไม่คาดคิดโดยการตั้งค่าการลบคีย์อัตโนมัติในกรณีที่การใช้งานเพิ่มขึ้นอย่างฉับพลัน ใช้gcloudคำสั่งหรือ Terraform ที่แสดงในแล็บ พิจารณาเพิ่มความเข้มงวดของสิทธิ์โดยใช้เงื่อนไข IAM
• สำรวจการแจ้งเตือนของ Monitoring: ดูข้อมูลเพิ่มเติมเกี่ยวกับการตั้งค่าการแจ้งเตือนโดยใช้บริการ Google Cloud Monitoring
• ดูข้อมูลเพิ่มเติมเกี่ยวกับการควบคุมการเข้าถึงที่มีใน Google Cloud: อ่านนโยบายขอบเขตการเข้าถึงและการเผยแพร่การเปลี่ยนแปลงการเข้าถึง