1. ภาพรวม
การป้องกันข้อมูลรั่วไหล (DLP) ใน Cloud เป็นบริการที่มีการจัดการครบวงจรซึ่งออกแบบมาเพื่อช่วยค้นหา แยกประเภท และปกป้องข้อมูลที่ละเอียดอ่อน Codelab นี้จะแนะนำความสามารถพื้นฐานบางอย่างของ Cloud DLP API และสาธิตวิธีต่างๆ ที่สามารถนำไปใช้เพื่อปกป้องข้อมูล
สิ่งที่คุณจะต้องทำ
- ใช้ DLP เพื่อตรวจสอบสตริงและไฟล์สำหรับประเภทข้อมูลที่ตรงกัน
- ดูข้อมูลเกี่ยวกับเทคนิคการลบการระบุตัวตนและใช้ DLP เพื่อลบการระบุตัวตนในข้อมูล
- ดูวิธีระบุข้อมูลที่ลบการระบุตัวตนไปแล้วอีกครั้งโดยใช้การเข้ารหัสการเก็บรักษารูปแบบ (FPE)
- ใช้ DLP เพื่อปกปิดประเภทข้อมูลจากสตริงและรูปภาพ
สิ่งที่คุณต้องมี
- โปรเจ็กต์ Google Cloud ที่มีการตั้งค่าการเรียกเก็บเงิน หากยังไม่มีบัญชี คุณจะต้องสร้างบัญชี
2. การตั้งค่า
Codelab นี้สามารถทำงานบน Google Cloud Platform ได้โดยสมบูรณ์โดยไม่ต้องมีการติดตั้งหรือกำหนดค่าภายในเครื่อง
Cloud Shell
ตลอด Codelab นี้ เราจะจัดสรรและจัดการทรัพยากรและบริการระบบคลาวด์ต่างๆ โดยใช้บรรทัดคำสั่งผ่าน Cloud Shell
ดาวน์โหลดที่เก็บโปรเจ็กต์ที่ใช้ร่วมกัน ดังนี้
git clone https://github.com/googleapis/nodejs-dlp
เมื่อดาวน์โหลดรหัสโปรเจ็กต์แล้ว ให้เปลี่ยนในไดเรกทอรีตัวอย่างและติดตั้งแพ็กเกจ Node.js ที่จำเป็น
cd samples && npm install
โปรดตรวจสอบว่าคุณกำลังใช้โปรเจ็กต์ที่ถูกต้องโดยการตั้งค่าโปรเจ็กต์ด้วยคำสั่ง gcloud ต่อไปนี้
gcloud config set project [PROJECT_ID]
เปิดใช้ API
ต่อไปนี้คือ API ที่เราจะต้องเปิดใช้ในโปรเจ็กต์ของเรา
- Cloud Data Loss Prevention API - มอบวิธีตรวจจับ วิเคราะห์ความเสี่ยง และการลบการระบุตัวตนของส่วนที่ละเอียดอ่อนด้านความเป็นส่วนตัวในข้อความ รูปภาพ และที่เก็บพื้นที่เก็บข้อมูลของ Google Cloud Platform
- Cloud Key Management Service (KMS) API - Google Cloud KMS ช่วยให้ลูกค้าจัดการคีย์การเข้ารหัสและดำเนินการเข้ารหัสด้วยคีย์เหล่านั้นได้
เปิดใช้ API ที่จำเป็นด้วยคำสั่ง gcloud ต่อไปนี้
gcloud services enable dlp.googleapis.com cloudkms.googleapis.com \
--project ${GOOGLE_CLOUD_PROJECT}
3. ตรวจสอบสตริงและไฟล์
ไดเรกทอรีตัวอย่างของโปรเจ็กต์ที่ดาวน์โหลดในขั้นตอนก่อนหน้ามีไฟล์ JavaScript หลายไฟล์ที่ใช้ฟังก์ชันที่แตกต่างกันของ Cloud DLP inspect.js จะตรวจสอบสตริงหรือไฟล์ที่ระบุเพื่อหาประเภทข้อมูลที่ละเอียดอ่อน
หากต้องการทดสอบ ให้ระบุตัวเลือก string และสตริงตัวอย่างพร้อมข้อมูลที่อาจละเอียดอ่อน
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'My email address is jenny@somedomain.com and you can call me at 555-867-5309'
ผลลัพธ์ควรแจ้งให้เราทราบถึงผลการสืบค้นสำหรับข้อมูลที่ตรงกันแต่ละประเภท ดังต่อไปนี้
ข้อความที่ยกมา: เทมเพลตจะระบุ
InfoType: ประเภทข้อมูลที่ตรวจพบสำหรับสตริงส่วนนั้น ดูรายการประเภทข้อมูลทั้งหมดที่เป็นไปได้ได้ที่นี่ โดยค่าเริ่มต้น inspect.js จะตรวจสอบเฉพาะข้อมูลประเภท CREDIT_CARD_NUMBER, PHONE_NUMBER และ EMAIL_ADDRESS
ความเป็นไปได้: ผลลัพธ์จะได้รับการจัดหมวดหมู่ตามความเป็นไปได้ของผลลัพธ์แต่ละรายการ โอกาสอาจมีได้ตั้งแต่ VERY_UNLIKELY ถึง VERY_LIKELY
ผลการสืบค้นสำหรับคำขอคำสั่งข้างต้นมีดังนี้
Findings:
Quote: jenny@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
Quote: 555-867-5309
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
ในทำนองเดียวกัน เราสามารถตรวจสอบไฟล์เพื่อหาประเภทข้อมูลได้ ตรวจสอบตัวอย่างไฟล์ accounts.txt:
resources/accounts.txt
My credit card number is 1234 5678 9012 3456, and my CVV is 789.
เรียกใช้ inspect.js อีกครั้ง โดยครั้งนี้มีตัวเลือกไฟล์ดังนี้
node inspect.js -c $GOOGLE_CLOUD_PROJECT file resources/accounts.txt
ผลลัพธ์ที่ได้
Findings:
Quote: 5678 9012 3456
Info type: CREDIT_CARD_NUMBER
Likelihood: VERY_LIKELY
สําหรับการค้นหาทั้ง 2 ประเภท เราอาจจํากัดผลลัพธ์ตามแนวโน้มหรือประเภทข้อมูล เช่น
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'Call 900-649-2568 or email me at anthony@somedomain.com' \ -m VERY_LIKELY
เมื่อระบุ VERY_LIKELY เป็นแนวโน้มขั้นต่ำ ระบบจะยกเว้นการจับคู่ที่น้อยกว่า VERY_LIKELY
Findings:
Quote: 900-649-2568
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
ผลลัพธ์ทั้งหมดที่ไม่มีข้อจำกัดจะมีลักษณะดังนี้
Findings:
Quote: 900-649-2568
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
Quote: anthony@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
ในทำนองเดียวกัน เราอาจระบุประเภทข้อมูลที่จะตรวจสอบ ดังนี้
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'Call 900-649-2568 or email me at anthony@somedomain.com' \ -t EMAIL_ADDRESS
ระบบจะแสดงเฉพาะประเภทข้อมูลที่ระบุ หากพบรายละเอียดต่อไปนี้
Findings:
Quote: anthony@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
ด้านล่างนี้เป็นฟังก์ชันอะซิงโครนัสที่ใช้ API เพื่อตรวจสอบอินพุต
inspect.js
async function inspectString(
callingProjectId,
string,
minLikelihood,
maxFindings,
infoTypes,
customInfoTypes,
includeQuote
) {
...
}
อาร์กิวเมนต์ที่ระบุสำหรับพารามิเตอร์ข้างต้นใช้ในการสร้างออบเจ็กต์คำขอ จากนั้นระบบจะส่งคำขอนั้นไปยังฟังก์ชัน inspectContent เพื่อได้รับการตอบกลับที่เป็นผลลัพธ์ของเรา
inspect.js
// Construct item to inspect
const item = {value: string};
// Construct request
const request = {
parent: dlp.projectPath(callingProjectId),
inspectConfig: {
infoTypes: infoTypes,
customInfoTypes: customInfoTypes,
minLikelihood: minLikelihood,
includeQuote: includeQuote,
limits: {
maxFindingsPerRequest: maxFindings,
},
},
item: item,
};
...
...
const [response] = await dlp.inspectContent(request);
4. การลบการระบุตัวตน
นอกจากการตรวจสอบและตรวจจับข้อมูลที่ละเอียดอ่อนแล้ว Cloud DLP ยังสามารถลบการระบุตัวตนได้อีกด้วย การลบการระบุตัวตนเป็นกระบวนการนำข้อมูลที่ระบุตัวตนออกจากข้อมูล API จะตรวจหาข้อมูลที่ละเอียดอ่อนตามที่กำหนดโดยประเภทข้อมูล จากนั้นจะใช้การเปลี่ยนรูปแบบการลบการระบุตัวตนเพื่อมาสก์ ลบ หรือปิดบังข้อมูล
deid.js จะแสดงการลบการระบุตัวตนได้หลายวิธี วิธีลบการระบุตัวตนที่ง่ายที่สุดคือการสวมหน้ากากอนามัย
node deid.js deidMask -c $GOOGLE_CLOUD_PROJECT \ "My order number is F12312399. Email me at anthony@somedomain.com"
เมื่อมาสก์ API จะแทนที่อักขระของประเภทข้อมูลที่ตรงกันด้วยอักขระอื่น * โดยค่าเริ่มต้น เอาต์พุตจะมีลักษณะดังนี้
My order number is F12312399. Email me at *****************************
โปรดทราบว่าอีเมลในสตริงจะมีการปรับให้ยากต่อการอ่าน (Obfuscate) ในขณะที่หมายเลขคำสั่งซื้อที่กำหนดเองยังคงเดิม (อาจมีประเภทข้อมูลที่กำหนดเอง แต่อยู่นอกขอบเขตของ Codelab นี้)
ลองดูฟังก์ชันที่ใช้ DLP API เพื่อลบการระบุตัวตนด้วยมาสก์
deid.js
async function deidentifyWithMask(
callingProjectId,
string,
maskingCharacter,
numberToMask
) {
...
}
จะใช้อาร์กิวเมนต์เหล่านี้ในการสร้างออบเจ็กต์คำขออีกครั้ง เวลานี้จะอยู่ในฟังก์ชัน deidentifyContent:
deid.js
// Construct deidentification request
const item = {value: string};
const request = {
parent: dlp.projectPath(callingProjectId),
deidentifyConfig: {
infoTypeTransformations: {
transformations: [
{
primitiveTransformation: {
characterMaskConfig: {
maskingCharacter: maskingCharacter,
numberToMask: numberToMask,
},
},
},
],
},
},
item: item,
};
...
...
const [response] = await dlp.deidentifyContent(request);
ลบการระบุตัวตนด้วยการเข้ารหัสเพื่อเก็บรักษารูปแบบ
DLP API ยังมีความสามารถในการเข้ารหัสค่าข้อมูลที่ละเอียดอ่อนโดยใช้คีย์การเข้ารหัส
เราจะเริ่มต้นโดยใช้ Cloud KMS เพื่อสร้างคีย์ริง ดังนี้
gcloud kms keyrings create dlp-keyring --location global
ตอนนี้เราสามารถสร้างคีย์ที่จะใช้เข้ารหัสข้อมูลได้แล้ว
gcloud kms keys create dlp-key \ --purpose='encryption' \ --location=global \ --keyring=dlp-keyring
DLP API จะยอมรับคีย์ที่ปกปิดด้วยคีย์ KMS ที่เราสร้างขึ้น เราสร้างสตริงแบบสุ่มที่จะนำไปรวมได้ เราจำเป็นต้องใช้ข้อมูลนี้ในภายหลังเพื่อยืนยันข้อมูลต่อไปนี้
export AES_KEY=`head -c16 < /dev/random | base64 -w 0`
ตอนนี้เราเข้ารหัสสตริงด้วยคีย์ KMS ได้แล้ว การดำเนินการนี้จะสร้างไฟล์ไบนารีที่มีสตริงที่เข้ารหัสในรูปแบบข้อความเข้ารหัส:
echo -n $AES_KEY | gcloud kms encrypt \ --location global \ --keyring dlp-keyring \ --key dlp-key \ --plaintext-file - \ --ciphertext-file ./ciphertext.bin
เมื่อใช้ deid.js ตอนนี้เราสามารถลบการระบุตัวตนของหมายเลขโทรศัพท์ในสตริงตัวอย่างด้านล่างโดยใช้การเข้ารหัส
node deid.js deidFpe -c $GOOGLE_CLOUD_PROJECT \
"My client's cell is 9006492568" `base64 -w 0 ciphertext.bin` \
projects/${GOOGLE_CLOUD_PROJECT}/locations/global/keyRings/dlp-keyring/cryptoKeys/dlp-key \
-s PHONE_NUMBER
เอาต์พุตจะแสดงสตริงที่มีประเภทข้อมูลที่ตรงกันซึ่งแทนที่ด้วยสตริงที่เข้ารหัส และมีประเภทข้อมูลที่ระบุไว้ด้วยแฟล็ก -s ดังนี้
My client's cell is PHONE_NUMBER(10):vSt55z79nR
ลองดูฟังก์ชันที่เราใช้ในการระบุสตริง
deid.js
async function deidentifyWithFpe(
callingProjectId,
string,
alphabet,
surrogateType,
keyName,
wrappedKey
) {
...
}
อาร์กิวเมนต์ใช้เพื่อสร้างออบเจ็กต์ cryptoReplaceFfxFpeConfig ดังนี้
deid.js
const cryptoReplaceFfxFpeConfig = {
cryptoKey: {
kmsWrapped: {
wrappedKey: wrappedKey,
cryptoKeyName: keyName,
},
},
commonAlphabet: alphabet,
};
if (surrogateType) {
cryptoReplaceFfxFpeConfig.surrogateInfoType = {
name: surrogateType,
};
}
ในทางกลับกัน จะมีการนำออบเจ็กต์ cryptoReplaceFfxFpeConfig ไปใช้ในคำขอไปยัง API ผ่านฟังก์ชัน deidentifyContent:
deid.js
// Construct deidentification request
const item = {value: string};
const request = {
parent: dlp.projectPath(callingProjectId),
deidentifyConfig: {
infoTypeTransformations: {
transformations: [
{
primitiveTransformation: {
cryptoReplaceFfxFpeConfig: cryptoReplaceFfxFpeConfig,
},
},
],
},
},
item: item,
};
try {
// Run deidentification request
const [response] = await dlp.deidentifyContent(request);
ระบุตัวตนข้อมูลอีกครั้ง
DLP API จะใช้ข้อความเข้ารหัสที่เราสร้างในขั้นตอนก่อนหน้าในการระบุข้อมูลอีกครั้ง
node deid.js reidFpe -c $GOOGLE_CLOUD_PROJECT \
"<YOUR_DEID_OUTPUT>" \
PHONE_NUMBER `base64 -w 0 ciphertext.bin` \
projects/${GOOGLE_CLOUD_PROJECT}/locations/global/keyRings/dlp-keyring/cryptoKeys/dlp-key
เอาต์พุตจะเป็นสตริงต้นฉบับที่ไม่มีการระบุประเภทการปกปิดหรือประเภทตัวแทน
My client's cell is 9006492568
ฟังก์ชันที่ใช้ในการระบุตัวตนข้อมูลจะคล้ายกับฟังก์ชันที่ใช้ในการลบการระบุตัวตน
deid.js
async function reidentifyWithFpe(
callingProjectId,
string,
alphabet,
surrogateType,
keyName,
wrappedKey
) {
...
}
และใช้อาร์กิวเมนต์ในคำขอที่ส่งไปยัง API อีกครั้ง ซึ่งคราวนี้จะเป็นฟังก์ชัน reidentifyContent
deid.js
// Construct deidentification request
const item = {value: string};
const request = {
parent: dlp.projectPath(callingProjectId),
reidentifyConfig: {
infoTypeTransformations: {
transformations: [
{
primitiveTransformation: {
cryptoReplaceFfxFpeConfig: {
cryptoKey: {
kmsWrapped: {
wrappedKey: wrappedKey,
cryptoKeyName: keyName,
},
},
commonAlphabet: alphabet,
surrogateInfoType: {
name: surrogateType,
},
},
},
},
],
},
},
inspectConfig: {
customInfoTypes: [
{
infoType: {
name: surrogateType,
},
surrogateType: {},
},
],
},
item: item,
};
try {
// Run reidentification request
const [response] = await dlp.reidentifyContent(request);
ลบการระบุตัวตนวันที่ด้วยการเปลี่ยนวันที่
ในบางบริบท วันที่อาจถือเป็นข้อมูลที่ละเอียดอ่อนที่เราอาจต้องการปรับให้ยากต่อการอ่าน (Obfuscate) การเปลี่ยนวันที่ช่วยให้เราเลื่อนวันที่ทีละส่วนโดยการสุ่มเก็บลำดับและระยะเวลาของระยะเวลาได้ แต่ละวันที่ในชุดจะถูกเลื่อนตามเวลาที่ไม่ซ้ำกันสำหรับรายการนั้น หากต้องการแสดงการลบการระบุตัวตนผ่านการเปลี่ยนวันที่ ก่อนอื่นให้ดูตัวอย่างไฟล์ CSV ที่มีข้อมูลวันที่ โดยทำดังนี้
resources/dates.csv
name,birth_date,register_date,credit_card
Ann,01/01/1980,07/21/1996,4532908762519852
James,03/06/1988,04/09/2001,4301261899725540
Dan,08/14/1945,11/15/2011,4620761856015295
Laura,11/03/1992,01/04/2017,4564981067258901
ข้อมูลมี 2 ช่องที่เราสามารถใช้การเปลี่ยนแปลงวันที่ ได้แก่ birth_date และ register_date deid.js จะยอมรับค่าขอบเขตล่างและค่าขอบเขตบนเพื่อกำหนดช่วงเพื่อเลือกจำนวนวันแบบสุ่มที่จะใช้เปลี่ยนวันที่
node deid.js deidDateShift -c $GOOGLE_CLOUD_PROJECT resources/dates.csv datesShifted.csv 30 90 birth_date
ระบบจะสร้างไฟล์ชื่อ datesShifted.csv โดยมีวันที่เลื่อนแบบสุ่มเป็นจำนวนวันตั้งแต่ 30 ถึง 90 วัน ตัวอย่างของเอาต์พุตที่สร้างขึ้นมีดังนี้
name,birth_date,register_date,credit_card
Ann,2/6/1980,7/21/1996,4532908762519852
James,5/18/1988,4/9/2001,4301261899725540
Dan,9/16/1945,11/15/2011,4620761856015295
Laura,12/16/1992,1/4/2017,4564981067258901
สังเกตว่าเราสามารถระบุคอลัมน์วันที่ในไฟล์ CSV ที่ต้องการเปลี่ยนแปลงได้ ฟิลด์ birth_date ฟิลด์ register_date จะไม่เปลี่ยนแปลง
ลองดูฟังก์ชันที่จัดการการลบการระบุตัวตนด้วยการเปลี่ยนวันที่
deid.js
async function deidentifyWithDateShift(
callingProjectId,
inputCsvFile,
outputCsvFile,
dateFields,
lowerBoundDays,
upperBoundDays,
contextFieldId,
wrappedKey,
keyName
) {
...
}
โปรดสังเกตว่าฟังก์ชันนี้สามารถยอมรับคีย์ที่ปกปิดและชื่อคีย์ คล้ายกับการลบการระบุตัวตนด้วย FPE เราจึงมีตัวเลือกในการระบุคีย์การเข้ารหัสซ้ำเพื่อระบุการเปลี่ยนวันที่ อาร์กิวเมนต์ที่เราสร้างให้ออบเจ็กต์ dateShiftConfig มีดังนี้
deid.js
// Construct DateShiftConfig
const dateShiftConfig = {
lowerBoundDays: lowerBoundDays,
upperBoundDays: upperBoundDays,
};
if (contextFieldId && keyName && wrappedKey) {
dateShiftConfig.context = {name: contextFieldId};
dateShiftConfig.cryptoKey = {
kmsWrapped: {
wrappedKey: wrappedKey,
cryptoKeyName: keyName,
},
};
} else if (contextFieldId || keyName || wrappedKey) {
throw new Error(
'You must set either ALL or NONE of {contextFieldId, keyName, wrappedKey}!'
);
}
// Construct deidentification request
const request = {
parent: dlp.projectPath(callingProjectId),
deidentifyConfig: {
recordTransformations: {
fieldTransformations: [
{
fields: dateFields,
primitiveTransformation: {
dateShiftConfig: dateShiftConfig,
},
},
],
},
},
item: tableItem,
};
5. ปกปิดสตริงและรูปภาพ
การสร้างความสับสนให้กับข้อมูลที่ละเอียดอ่อนอีกวิธีหนึ่งคือการปกปิดข้อมูล การปกปิดจะแทนที่การจับคู่ด้วยประเภทข้อมูลที่พบว่าตรงกัน redact.js แสดงการปกปิด:
node redact.js -c $GOOGLE_CLOUD_PROJECT \ string "Please refund the purchase to my credit card 4012888888881881" \ -t 'CREDIT_CARD_NUMBER'
เอาต์พุตจะแทนที่หมายเลขบัตรเครดิตตัวอย่างด้วยประเภทข้อมูล CREDIT_CARD_NUMBER:
Please refund the purchase on my credit card [CREDIT_CARD_NUMBER]
วิธีนี้มีประโยชน์หากคุณต้องการซ่อนข้อมูลที่ละเอียดอ่อน แต่ยังคงระบุประเภทข้อมูลที่ต้องการนำออกได้ ในทำนองเดียวกัน DLP API ก็สามารถปกปิดข้อมูลจากรูปภาพที่มีข้อความได้ มาดูตัวอย่างรูปภาพเพื่อสาธิตกัน
resources/test.png
วิธีปกปิดหมายเลขโทรศัพท์และอีเมลในรูปภาพด้านบน
node redact.js -c $GOOGLE_CLOUD_PROJECT \ image resources/test.png ./redacted.png \ -t PHONE_NUMBER -t EMAIL_ADDRESS
ตามที่ระบุไว้ ระบบจะสร้างภาพใหม่ที่ชื่อว่าredad.png พร้อมข้อมูลที่ร้องขอที่ถูกปิดทับ:
ฟังก์ชันที่ใช้ในการปกปิดสตริงมีดังนี้
redact.js
async function redactText(
callingProjectId,
string,
minLikelihood,
infoTypes
) {
...}
และต่อไปนี้คือคำขอที่จะส่งไปยังฟังก์ชัน deidentifyContent
redact.js
const request = {
parent: dlp.projectPath(callingProjectId),
item: {
value: string,
},
deidentifyConfig: {
infoTypeTransformations: {
transformations: [replaceWithInfoTypeTransformation],
},
},
inspectConfig: {
minLikelihood: minLikelihood,
infoTypes: infoTypes,
},
};
ในทำนองเดียวกัน ฟังก์ชันสำหรับการปกปิดรูปภาพมีดังนี้
redact.js
async function redactImage(
callingProjectId,
filepath,
minLikelihood,
infoTypes,
outputPath
) {
...}
และต่อไปนี้คือคำขอที่จะส่งไปยังฟังก์ชัน redactImage
redact.js
// Construct image redaction request
const request = {
parent: dlp.projectPath(callingProjectId),
byteItem: {
type: fileTypeConstant,
data: fileBytes,
},
inspectConfig: {
minLikelihood: minLikelihood,
infoTypes: infoTypes,
},
imageRedactionConfigs: imageRedactionConfigs,
};
6. ล้างข้อมูล
เราได้สำรวจวิธีใช้ DLP API เพื่อมาสก์ ลบการระบุตัวตน และปรับปรุงข้อมูลที่ละเอียดอ่อนจากข้อมูลของเรา คราวนี้ก็ถึงเวลาจัดระเบียบทรัพยากรทั้งหมดที่ได้สร้างไว้ในโปรเจ็กต์
ลบโปรเจ็กต์
ในคอนโซล GCP ให้ไปที่หน้า Cloud Resource Manager
ในรายการโปรเจ็กต์ ให้เลือกโปรเจ็กต์ที่เรากำลังดำเนินการอยู่ แล้วคลิกลบ ระบบจะแจ้งให้คุณพิมพ์รหัสโปรเจ็กต์ ป้อนรหัสและคลิกปิด
หรือคุณจะลบทั้งโปรเจ็กต์จาก Cloud Shell โดยตรงด้วย gcloud ก็ได้โดยทำดังนี้
gcloud projects delete $GOOGLE_CLOUD_PROJECT
7. ยินดีด้วย
แจ่มแจ๋ว! สำเร็จแล้ว! Cloud DLP เป็นเครื่องมืออันทรงพลังซึ่งให้สิทธิ์เข้าถึงแพลตฟอร์มการตรวจสอบ การแยกประเภท และการลบการระบุตัวตนในข้อมูลที่ละเอียดอ่อนที่มีประสิทธิภาพ
สรุปประเด็นที่ได้พูดถึง
- เราเห็นวิธีใช้ Cloud DLP API เพื่อตรวจสอบสตริงและไฟล์สำหรับข้อมูลหลายประเภทแล้ว
- เราได้เรียนรู้ว่า DLP API จะลบการระบุตัวตนของสตริงด้วยมาสก์เพื่อซ่อนประเภทข้อมูลการจับคู่ข้อมูลได้อย่างไร
- เราใช้ DLP API เพื่อใช้คีย์การเข้ารหัสเพื่อลบการระบุตัวตนแล้วระบุข้อมูลอีกครั้ง
- เราใช้ DLP API เพื่อปกปิดข้อมูลจากสตริงและรูปภาพ