1. खास जानकारी
Cloud Data Loss Prevention (DLP), पूरी तरह से मैनेज की जाने वाली सेवा है. इसे संवेदनशील जानकारी का पता लगाने, उसे कैटगरी में बांटने, और सुरक्षित रखने के लिए डिज़ाइन किया गया है. इस कोडलैब में, Cloud DLP API की कुछ बुनियादी सुविधाओं के बारे में बताया जाएगा. साथ ही, यह दिखाया जाएगा कि डेटा को सुरक्षित रखने के लिए, इसका इस्तेमाल अलग-अलग तरीकों से कैसे किया जा सकता है.
आपको क्या करना होगा
- डीएलपी का इस्तेमाल करके, स्ट्रिंग और फ़ाइलों की जांच करें, ताकि यह पता लगाया जा सके कि उनमें जानकारी के टाइप मैच हो रहे हैं या नहीं
- पहचान से जुड़ी जानकारी हटाने के तरीकों के बारे में जानें और डेटा की पहचान से जुड़ी जानकारी हटाने के लिए, डीएलपी का इस्तेमाल करें
- फ़ॉर्मैट बनाए रखने वाले एन्क्रिप्शन (एफ़पीई) का इस्तेमाल करके, पहचान छिपाए गए डेटा की पहचान फिर से करने का तरीका जानें
- स्ट्रिंग और इमेज से जानकारी के टाइप छिपाने के लिए, डीएलपी का इस्तेमाल करना
आपको इन चीज़ों की ज़रूरत होगी
- बिलिंग की सुविधा वाला Google Cloud प्रोजेक्ट. अगर आपके पास Google खाता नहीं है, तो आपको एक खाता बनाना होगा.
2. सेट अप करना
इस कोडलैब को Google Cloud Platform पर पूरी तरह से चलाया जा सकता है. इसके लिए, किसी भी लोकल इंस्टॉलेशन या कॉन्फ़िगरेशन की ज़रूरत नहीं है.
Cloud Shell
इस कोडलैब में, हम Cloud Shell के ज़रिए कमांड लाइन का इस्तेमाल करके, अलग-अलग क्लाउड संसाधनों और सेवाओं को प्रोविज़न और मैनेज करेंगे.
साथी प्रोजेक्ट की रिपॉज़िटरी डाउनलोड करें:
git clone https://github.com/googleapis/nodejs-dlp
प्रोजेक्ट कोड डाउनलोड हो जाने के बाद, samples डायरेक्ट्री में जाएं और ज़रूरी Node.js पैकेज इंस्टॉल करें:
cd samples && npm install
पक्का करें कि आपने सही प्रोजेक्ट का इस्तेमाल किया हो. इसके लिए, gcloud कमांड का इस्तेमाल करके प्रोजेक्ट सेट करें:
gcloud config set project [PROJECT_ID]
एपीआई चालू करना
हमें अपने प्रोजेक्ट पर ये एपीआई चालू करने होंगे:
- Cloud Data Loss Prevention API - यह टेक्स्ट, इमेज, और Google Cloud Platform स्टोरेज रिपॉज़िटरी में मौजूद निजता से जुड़े संवेदनशील फ़्रैगमेंट का पता लगाने, जोखिम का विश्लेषण करने, और उनकी पहचान छिपाने के तरीके उपलब्ध कराता है
- Cloud Key Management Service (KMS) API - Google Cloud KMS की मदद से, ग्राहक एन्क्रिप्शन कुंजियों को मैनेज कर सकते हैं. साथ ही, उन कुंजियों के साथ क्रिप्टोग्राफ़िक ऑपरेशन कर सकते हैं.
नीचे दी गई gcloud कमांड का इस्तेमाल करके, ज़रूरी एपीआई चालू करें:
gcloud services enable dlp.googleapis.com cloudkms.googleapis.com \
--project ${GOOGLE_CLOUD_PROJECT}
3. स्ट्रिंग और फ़ाइलों की जांच करना
पिछले चरण में डाउनलोड किए गए प्रोजेक्ट की samples डायरेक्ट्री में कई 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
हम दोनों तरह की क्वेरी के लिए, नतीजों को उनकी संभावना या जानकारी के टाइप के हिसाब से सीमित कर सकते हैं. उदाहरण के लिए:
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
यहां एसिंक्रोनस फ़ंक्शन दिया गया है. यह इनपुट की जांच करने के लिए, एपीआई का इस्तेमाल करता है:
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, संवेदनशील डेटा की जांच करने और उसका पता लगाने के साथ-साथ, उसकी पहचान छिपाने का काम भी कर सकता है. पहचान छिपाने की प्रोसेस में, डेटा से पहचान करने वाली जानकारी को हटाया जाता है. एपीआई, जानकारी के टाइप के हिसाब से संवेदनशील डेटा का पता लगाता है. इसके बाद, पहचान छिपाने की प्रोसेस का इस्तेमाल करके, डेटा को मास्क करता है, मिटाता है या छिपाता है.
deid.js, पहचान छिपाने की प्रोसेस को कई तरीकों से दिखाएगा. पहचान छिपाने का सबसे आसान तरीका, मास्क का इस्तेमाल करना है:
node deid.js deidMask -c $GOOGLE_CLOUD_PROJECT \ "My order number is F12312399. Email me at anthony@somedomain.com"
मास्क करने की सुविधा का इस्तेमाल करने पर, एपीआई मैच करने वाले डेटा टाइप के वर्णों को किसी दूसरे वर्ण से बदल देगा. डिफ़ॉल्ट रूप से, यह वर्ण * होता है. आउटपुट यह होगा:
My order number is F12312399. Email me at *****************************
ध्यान दें कि स्ट्रिंग में मौजूद ईमेल पते को धुंधला कर दिया गया है, जबकि ऑर्डर नंबर में कोई बदलाव नहीं किया गया है. (कस्टम जानकारी के टाइप बनाए जा सकते हैं, लेकिन यह इस कोडलैब के दायरे से बाहर है).
मास्क लगाकर पहचान छिपाने के लिए, 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);
फ़ॉर्मैट बनाए रखने वाले एन्क्रिप्शन की मदद से पहचान छिपाना
डीएलपी एपीआई, क्रिप्टोग्राफ़िक कुंजी का इस्तेमाल करके संवेदनशील डेटा वैल्यू को एन्क्रिप्ट यानी सुरक्षित करने की सुविधा भी देता है.
हम 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`
अब हम अपनी केएमएस कुंजी की मदद से स्ट्रिंग को एन्क्रिप्ट (सुरक्षित) कर सकते हैं. इससे एक बाइनरी फ़ाइल जनरेट होगी. इसमें एन्क्रिप्ट (सुरक्षित) की गई स्ट्रिंग, सिफ़रटेक्स्ट के तौर पर मौजूद होगी:
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 ऑब्जेक्ट का इस्तेमाल, 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
) {
...
}
इसके बाद, आर्ग्युमेंट का इस्तेमाल एपीआई को किए गए अनुरोध में किया जाता है. इस बार, 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);
तारीख बदलने की सुविधा का इस्तेमाल करके तारीखों की पहचान छिपाना
कुछ मामलों में, तारीखों को संवेदनशील डेटा माना जा सकता है. ऐसे में, हम उन्हें छिपाना चाहेंगे. तारीख बदलने की सुविधा की मदद से, हम तारीखों को रैंडम तरीके से बढ़ा सकते हैं. हालांकि, इससे समय की अवधि और क्रम में कोई बदलाव नहीं होता. सेट में मौजूद हर तारीख को, उस एंट्री के हिसाब से तय की गई समयावधि के हिसाब से बदला जाता है. तारीख में बदलाव करके पहचान छिपाने का तरीका दिखाने के लिए, पहले तारीख की जानकारी वाली 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
डेटा में दो फ़ील्ड हैं, जिनमें तारीख में बदलाव किया जा सकता है: 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
जैसा कि बताया गया है, मांगी गई जानकारी को छिपाकर, redacted.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. व्यवस्थित करें
हमने यह पता लगाया है कि हम अपने डेटा से संवेदनशील जानकारी को छिपाने, उसकी पहचान मिटाने, और उसे हटाने के लिए, डीएलपी एपीआई का इस्तेमाल कैसे कर सकते हैं. अब हमने जो भी संसाधन बनाए हैं उन्हें अपने प्रोजेक्ट से हटाने का समय आ गया है.
प्रोजेक्ट मिटाना
GCP Console में, Cloud Resource Manager पेज पर जाएं:
प्रोजेक्ट की सूची में, उस प्रोजेक्ट को चुनें जिस पर हम काम कर रहे थे. इसके बाद, मिटाएं पर क्लिक करें. आपको प्रोजेक्ट आईडी डालने के लिए कहा जाएगा. इसे डालें और बंद करें पर क्लिक करें.
इसके अलावा, gcloud का इस्तेमाल करके, पूरे प्रोजेक्ट को सीधे Cloud Shell से मिटाया जा सकता है:
gcloud projects delete $GOOGLE_CLOUD_PROJECT
7. बधाई हो!
वाह! आपने कर दिखाया! Cloud DLP एक बेहतरीन टूल है. यह संवेदनशील डेटा की जांच करने, उसे कैटगरी में बांटने, और उसकी पहचान छिपाने के लिए एक बेहतरीन प्लैटफ़ॉर्म का ऐक्सेस देता है.
हमने क्या-क्या कवर किया है
- हमने देखा कि Cloud DLP API का इस्तेमाल, कई तरह की जानकारी के लिए स्ट्रिंग और फ़ाइलों की जांच करने के लिए कैसे किया जा सकता है
- हमने सीखा कि डीएलपी एपीआई, मास्क का इस्तेमाल करके स्ट्रिंग की पहचान कैसे छिपा सकता है, ताकि डेटा से मेल खाने वाली जानकारी के टाइप को छिपाया जा सके
- हमने डीएलपी एपीआई का इस्तेमाल करके, एन्क्रिप्शन की का इस्तेमाल किया. इससे डेटा की पहचान मिटाई गई और फिर से पहचान की गई
- हमने डीएलपी एपीआई का इस्तेमाल करके, स्ट्रिंग और इमेज से डेटा छिपाया है