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

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

1. บทนำ

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

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

สิ่งที่คุณจะได้ทำ

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

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

เว็บเบราว์เซอร์ที่ทันสมัย (เช่น Chrome)
บัญชี Google

2. ตั้งค่า

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

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

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

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

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

หลังจากเปิดคอนโซล Cloud คุณจะได้รับการตรวจสอบสิทธิ์ และโดยปกติจะมีตัวเลือกโปรเจ็กต์สำหรับงานของคุณ รหัสโปรเจ็กต์คือลำดับอักขระตัวพิมพ์เล็ก ตัวเลข และสัญลักษณ์ขีดกลาง 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 ที่ไม่มีข้อจำกัดใดๆ ได้ คีย์ที่ไม่มีข้อจำกัดสามารถใช้เรียก API ของ Google ที่เปิดใช้ในโปรเจ็กต์ที่สร้างคีย์ได้ แม้ว่าคอนโซล Google Cloud จะป้องกันไม่ให้ผู้ใช้สร้างคีย์ที่ไม่มีข้อจำกัด แต่ก็ยังสามารถทำได้โดยใช้ gcloud CLI หรือใช้การเรียก API โดยตรง

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

หากต้องการสร้างคีย์ 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 Map
ℹ️ หมายเหตุ: คุณสามารถเพิ่ม API หลายรายการลงในรายการที่จำกัดได้ ใช้พารามิเตอร์ --api-target หลายรายการที่มีค่า =service=SERVICE.googleapis.com โดยที่ SERVICE คือบริการหนึ่งของ Google
เพิ่มความปลอดภัยของคีย์โดยเพิ่มการจำกัดแอปพลิเคชัน จำกัดการใช้คีย์ไว้สำหรับเส้นทางทั้งหมดภายในเว็บไซต์ 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

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

เรียกใช้คำสั่งต่อไปนี้เพื่อดูชื่อคีย์ รหัส และวันที่สร้างทั้งหมด
```
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
```
เลือกรหัสคีย์รายการใดรายการหนึ่ง แล้ววางคำสั่งต่อไปนี้เพื่อตรวจสอบว่าคีย์มีข้อจำกัดหรือไม่ แทนที่ 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 จะมีการประทับเวลาเดียวกัน

ดาวน์โหลดและเรียกใช้สคริปต์ที่จะตรวจสอบ โปรเจ็กต์ทั้งหมด และพิมพ์คีย์ 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 นี้ได้ที่โฟลเดอร์ Securityในที่เก็บ devrel-demos ใน GitHub

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

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

ใช้รหัสคีย์เดียวกับที่ใช้ในขั้นตอนก่อนหน้าหรือเลือกใช้รหัสคีย์อื่น แทนที่ your-key-id ด้วยรหัสคีย์ที่เลือกในคำสั่งต่อไปนี้
```
export KEY_UID=$(
   gcloud services api-keys describe "your-key-id" \
   --format='value(uid)' \
   --project=${PROJECT_ID})
```
ตั้งค่าการค้นหาให้ดูประวัติการใช้งานย้อนหลัง 1 ปี หากต้องการดูประวัติการใช้งานในช่วงเวลาที่นานกว่าหรือสั้นกว่านี้ ให้แทนที่ 365 (จำนวนวัน) ด้วยตัวเลขบวกอื่น
```
export DAYS=365
```
รีเฟรชข้อมูลรับรองเริ่มต้นของแอปพลิเคชัน (ADC) เพื่อเปิดใช้การเรียก Cloud Monitoring API โดยตรง เรียกใช้คำสั่งต่อไปนี้และทำตามคำแนะนำในเทอร์มินัล
```
gcloud auth application-default login
```
เรียกใช้คำสั่งต่อไปนี้เพื่อส่งคำขอข้อมูลเมตริกการใช้งานบริการไปยัง 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 แล้ว

เรียกใช้คำสั่งต่อไปนี้เพื่อดึงรายการ Google API ที่เรียกใช้โดยใช้คีย์ 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

แทนที่รายการ 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 ขั้นตอนนี้แสดงวิธีทำให้การตอบสนองต่อการใช้งานคีย์ที่เพิ่มขึ้นอย่างไม่คาดคิดเป็นไปโดยอัตโนมัติด้วยความช่วยเหลือจากการแจ้งเตือนของ Monitoring

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

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

เรียกใช้สคริปต์ต่อไปนี้เพื่อสร้างไฟล์นโยบายการแจ้งเตือน
```
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)
เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างหัวข้อ Pub/Sub ที่จะใช้โพสต์การแจ้งเตือน
```
gcloud pubsub topics create api-key-alert-notifications --project=$PROJECT_ID
```
เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างช่องทางการแจ้งเตือนสำหรับการแจ้งเตือนที่ใช้ Pub/Sub
```
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 ในขั้นตอนการล้างข้อมูล
เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างการแจ้งเตือนของ Monitoring ใหม่
```
gcloud monitoring policies create --policy-from-file=alert_policy.json \
  --project=$PROJECT_ID
```
เรียกใช้คำสั่งต่อไปนี้เพื่อให้สิทธิ์บริการ 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

เรียกใช้สคริปต์ต่อไปนี้เพื่อสร้างทริกเกอร์ 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

เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างทริกเกอร์การแจ้งเตือนของ Monitoring ใหม่
```
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 repository แผนนี้รับรหัสโปรเจ็กต์และ 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

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

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

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