Redigera känslig data från strömmande data i nästan realtid med Amazon Comprehend och Amazon Kinesis Data Firehose

Leverans i nästan realtid av data och insikter gör det möjligt för företag att snabbt svara på sina kunders behov. Realtidsdata kan komma från en mängd olika källor, inklusive sociala medier, IoT-enheter, infrastrukturövervakning, callcenterövervakning och mer. På grund av bredden och djupet av data som tas in från flera källor, letar företag efter lösningar för att skydda sina kunders integritet och förhindra att känslig data nås från slutsystem. Du var tidigare tvungen att förlita dig på regelmotorer för personligt identifierbar information (PII) som kunde flagga falska positiva eller missa data, eller så var du tvungen att bygga och underhålla anpassade maskininlärningsmodeller (ML) för att identifiera PII i din strömmande data. Du behövde också implementera och underhålla den infrastruktur som krävs för att stödja dessa motorer eller modeller.

För att effektivisera denna process och minska kostnaderna kan du använda Amazon Comprehend, en NLP-tjänst (natural language processing) som använder ML för att hitta insikter och relationer som människor, platser, känslor och ämnen i ostrukturerad text. Du kan nu använda Amazon Comprehend ML-funktioner för att upptäcka och redigera PII i kundmejl, supportbiljetter, produktrecensioner, sociala medier och mer. Ingen erfarenhet av ML krävs. Du kan till exempel analysera supportärenden och kunskapsartiklar för att upptäcka PII-enheter och redigera texten innan du indexerar dokumenten. Därefter är dokument fria från PII-enheter och användare kan konsumera data. Redigera PII-enheter hjälper dig att skydda din kunds integritet och följa lokala lagar och förordningar.

I det här inlägget lär du dig hur du implementerar Amazon Comprehend i dina streamingarkitekturer för att redigera PII-enheter i nästan realtid med hjälp av Amazon Kinesis Data Firehose med AWS Lambda.

Det här inlägget är fokuserat på att redigera data från utvalda fält som matas in i en strömningsarkitektur med Kinesis Data Firehose, där du vill skapa, lagra och underhålla ytterligare härledda kopior av data för konsumtion av slutanvändare eller nedströmsapplikationer. Om du använder Amazon Kinesis dataströmmar eller har ytterligare användningsfall utanför PII-redigering, se Översätt, redigera och analysera strömmande data med SQL-funktioner med Amazon Kinesis Data Analytics, Amazon Translate och Amazon Comprehend, där vi visar hur du kan använda Amazon Kinesis Data Analytics Studio drivs av Apache Zeppelin och Apache Flash för att interaktivt analysera, översätta och redigera textfält i strömmande data.

Lösningsöversikt

Följande figur visar ett exempel på arkitektur för att utföra PII-redaktion av strömmande data i realtid, med hjälp av Amazon enkel lagringstjänst (Amazon S3), Kinesis Data Firehose datatransformation, Amazon Comprehendoch AWS Lambda. Dessutom använder vi AWS SDK för Python (Boto3) för lambdafunktionerna. Som indikeras i diagrammet innehåller S3 rå hink icke-redigerad data, och S3 redigerad hink innehåller redigerad data efter användning av Amazon Comprehend DetectPiiEntities API inom en lambdafunktion.

Kostnader inblandade

Förutom kostnader för Kinesis Data Firehose, Amazon S3 och Lambda kommer denna lösning att medföra användningskostnader från Amazon Comprehend. Beloppet du betalar är en faktor av det totala antalet poster som innehåller PII och de tecken som bearbetas av Lambda-funktionen. För mer information, se Amazon Kinesis Data Firehose priser, Amazon Comprehend Prissättningoch AWS Lambda-prissättning.

Som ett exempel, låt oss anta att du har 10,000 500 loggposter och nyckelvärdet du vill redigera PII från är 10,000 tecken. Av de 50 XNUMX loggposterna identifieras XNUMX som innehållande PII. Kostnadsdetaljerna är följande:

Innehåller PII-kostnad:

• Storleken på varje nyckelvärde = 500 tecken (1 enhet = 100 tecken)
• Antal enheter (100 tecken) per post (minst 3 enheter) = 5
• Totalt antal enheter = 10,000 5 (poster) x 1 (enheter per post) x 50,000 (Amazon Comprehend-förfrågningar per post) = XNUMX XNUMX
• Pris per enhet = $ 0.000002
  • Total kostnad för att identifiera loggposter med PII med ContainsPiiEntities API = $0.1 [50,000 0.000002 enheter x $XNUMX] 

Redact PII-kostnad:

• Totalt antal enheter som innehåller PII = 50 (poster) x 5 (enheter per post) x 1 (Amazon Comprehend-förfrågningar per post) = 250
• Pris per enhet = $ 0.0001
  • Total kostnad för att identifiera platsen för PII med DetectPiiEntities API = [antal enheter] x [kostnad per enhet] = 250 x $0.0001 = $0.025

Total kostnad för identifiering och redigering:

• Total kostnad: $0.1 (validering om fältet innehåller PII) + $0.025 (redigera fält som innehåller PII) = $0.125

Distribuera lösningen med AWS CloudFormation

För detta inlägg tillhandahåller vi en AWS molnformation redigering av strömmande data mall, som ger alla detaljer om implementeringen för att möjliggöra repeterbara distributioner. Vid implementering skapar den här mallen två S3-segment: en för att lagra råprovdata som tas in från Amazon Kinesis Data Generator (KDG), och en för att lagra den redigerade datan. Dessutom skapar den en Kinesis Data Firehose leveransström med DirectPUT som input, och en Lambda-funktion som anropar Amazon Comprehend Innehåller PiiEntities och DetectPiiEntities API för att identifiera och redigera PII-data. Lambdafunktionen förlitar sig på användarinmatning i miljövariablerna för att avgöra vilka nyckelvärden som behöver inspekteras för PII.

Lambdafunktionen i denna lösning har begränsade nyttolaststorlekar till 100 KB. Om en nyttolast tillhandahålls där texten är större än 100 KB kommer Lambdafunktionen att hoppa över den.

Så här distribuerar du lösningen:

1. Starta CloudFormation-stacken i US East (N. Virginia) us-east-1:
   
2. Ange ett stacknamn och lämna andra parametrar som standard
3. Välja Jag erkänner att AWS CloudFormation kan skapa IAM-resurser med anpassade namn.
4. Välja Skapa stack.

Distribuera resurser manuellt

Om du föredrar att bygga arkitekturen manuellt istället för att använda AWS CloudFormation, slutför stegen i det här avsnittet.

Skapa S3-hinkarna

Skapa dina S3-skopor med följande steg:

1. Välj på Amazon S3-konsolen Skopor i navigeringsfönstret.
2. Välja Skapa hink.
3. Skapa en hink för dina rådata och en för din redigerade data.
4. Notera namnen på hinkarna du just skapade.

Skapa Lambda-funktionen

För att skapa och distribuera Lambda-funktionen, utför följande steg:

1. Välj på Lambda-konsolen Skapa funktion.
2. Välja Författare från början.
3. För Funktionsnamn, stiga på AmazonComprehendPII-Redact.
4. För Runtimeväljer python 3.9.
5. För arkitektur, Välj x86_64.
6. För Utförande roll, Välj Skapa en ny roll med Lambda-behörigheter.
7. När du har skapat funktionen anger du följande kod:

   import json
   import boto3
   import os
   import base64
   import sys
   
   def lambda_handler(event, context):
       
       output = []
       
       for record in event['records']:
           
           # Gathers keys from enviroment variables and makes a list of desired keys to check for PII
           rawkeys = os.environ['keys']
           splitkeys = rawkeys.split(", ")
           print(splitkeys)
           #decode base64
           #Kinesis data is base64 encoded so decode here
           payloadraw=base64.b64decode(record["data"]).decode('utf-8')
           #Loads decoded payload into json
           payloadjsonraw = json.loads(payloadraw)
           
           # Creates Comprehend client
           comprehend_client = boto3.client('comprehend')
           
           
           # This codes handles the logic to check for keys, identify if PII exists, and redact PII if available. 
           for i in payloadjsonraw:
               # checks if the key found in the message matches a redact
               if i in splitkeys:
                   print("Redact key found, checking for PII")
                   payload = str(payloadjsonraw[i])
                   # check if payload size is less than 100KB
                   if sys.getsizeof(payload) < 99999:
                       print('Size is less than 100KB checking if value contains PII')
                       # Runs Comprehend ContainsPiiEntities API call to see if key value contains PII
                       pii_identified = comprehend_client.contains_pii_entities(Text=payload, LanguageCode='en')
                       
                       # If PII is not found, skip over key
                       if (pii_identified['Labels']) == []:
                           print('No PII found')
                       else:
                       # if PII is found, run through redaction logic
                           print('PII found redacting')
                           # Runs Comprehend DetectPiiEntities call to find exact location of PII
                           response = comprehend_client.detect_pii_entities(Text=payload, LanguageCode='en')
                           entities = response['Entities']
                           # creates redacted_payload which will be redacted
                           redacted_payload = payload
                           # runs through a loop that gathers necessary values from Comprehend API response and redacts values
                           for entity in entities:
                               char_offset_begin = entity['BeginOffset']
                               char_offset_end = entity['EndOffset']
                               redacted_payload = redacted_payload[:char_offset_begin] + '*'*(char_offset_end-char_offset_begin) + redacted_payload[char_offset_end:]
                           # replaces original value with redacted value
                           payloadjsonraw[i] = redacted_payload
                           print(str(payloadjsonraw[i]))
                   else:
                       print ('Size is more than 100KB, skipping inspection')
               else:
                   print("Key value not found in redaction list")
           
           redacteddata = json.dumps(payloadjsonraw)
           
           # adds inspected record to record
           output_record = {
               'recordId': record['recordId'],
               'result': 'Ok',
               'data' : base64.b64encode(redacteddata.encode('utf-8'))
           }
           output.append(output_record)
           print(output_record)
           
       print('Successfully processed {} records.'.format(len(event['records'])))
       
       return {'records': output}

8. Välja Distribuera.
9. Välj i navigeringsfönstret Konfiguration.
10. Navigera till Miljövariabler.
11. Välja Redigera.
12. För Nyckel, stiga på keys.
13. För Värde, ange nyckelvärdena som du vill redigera PII från, separerade med kommatecken och mellanslag. Ange till exempel Tweet1, Tweet2 om du använder provdata som tillhandahålls i nästa avsnitt av det här inlägget.
14. Välja Save.
15. Navigera till Allmän konfiguration.
16. Välja Redigera.
17. Ändra värdet på Timeout till 1 minut.
18. Välja Save.
19. Navigera till behörigheter.
20. Välj rollnamnet under Utförande roll.
    Du omdirigeras till AWS identitets- och åtkomsthantering (IAM) -konsol.
21. För Lägg till behörigheterväljer Bifoga policyer.
22. ange Comprehend i sökfältet och välj policy ComprehendFullAccess.
23. Välja Bifoga policyer.

Skapa Firehose leveransström

Utför följande steg för att skapa din Firehose-leveransström:

1. Välj Kinesis Data Firehose-konsolen Skapa leveransström.
2. För Källa, Välj Direkt PUT.
3. För Destination, Välj Amazon S3.
4. För Namn på leveransström, stiga på ComprehendRealTimeBlog.
5. Enligt Förvandla källposter med AWS Lambda, Välj Aktiverat.
6. För AWS Lambda-funktion, ange ARN för funktionen du skapade, eller bläddra till funktionen AmazonComprehendPII-Redact.
7. För Buffertstorlek, ställ in värdet på 1 MB.
8. För Buffertintervall, låt det vara 60 sekunder.
9. Enligt Destinationsinställningar, välj den S3-bucket du skapade för den redigerade informationen.
10. Enligt Backup-inställningar, välj S3-bucket som du skapade för råposterna.
11. Enligt tillstånd, antingen skapa eller uppdatera en IAM-roll, eller välj en befintlig roll med rätt behörigheter.
12. Välja Skapa leveransström.

Implementera strömmande datalösning med Kinesis Data Generator

Du kan använda Kinesis Data Generator (KDG) för att mata in provdata till Kinesis Data Firehose och testa lösningen. För att förenkla denna process tillhandahåller vi en Lambda-funktion och CloudFormation-mall för att skapa en Amazon Cognito användare och tilldela lämpliga behörigheter för att använda KDG.

1. På Amazon Kinesis Data Generator-sidaväljer Skapa en Cognito-användare med CloudFormation.Du omdirigeras till AWS CloudFormation-konsolen för att skapa din stack.
2. Ange ett användarnamn och lösenord för användaren som du loggar in på KDG med.
3. Lämna de andra inställningarna på sina standardinställningar och skapa din stack.
4. På Utgångarna fliken, välj länken KDG UI.
5. Ange ditt användarnamn och lösenord för att logga in.

Skicka testposter och validera redigering i Amazon S3

Gör följande för att testa lösningen:

1. Logga in på KDG URL som du skapade i föregående steg.
2. Välj den region där AWS CloudFormation-stacken distribuerades.
3. För Stream/leveransström, välj den leveransström du skapade (om du använde mallen har den formatet accountnumber-awscomprehend-blog).
4. Lämna de andra inställningarna på sina standardinställningar.
5. För postmallen kan du skapa dina egna tester eller använda följande mall. Om du använder de medföljande exempeldata nedan för testning, bör du ha uppdaterade miljövariabler i AmazonComprehendPII-Redact Lambdafunktion till Tweet1, Tweet2. Om den distribueras via CloudFormation, uppdatera miljövariabler till Tweet1, Tweet2 inom den skapade Lambdafunktionen. Exempel på testdata är nedan:

   {"User":"12345", "Tweet1":" Good morning, everybody. My name is Van Bokhorst Serdar, and today I feel like sharing a whole lot of personal information with you. Let's start with my Email address SerdarvanBokhorst@dayrep.com. My address is 2657 Koontz Lane, Los Angeles, CA. My phone number is 818-828-6231.", "Tweet2": "My Social security number is 548-95-6370. My Bank account number is 940517528812 and routing number 195991012. My credit card number is 5534816011668430, Expiration Date 6/1/2022, my C V V code is 121, and my pin 123456. Well, I think that's it. You know a whole lot about me. And I hope that Amazon comprehend is doing a good job at identifying PII entities so you can redact my personal information away from this streaming record. Let's check"}

6. Välja Skicka data, och låt några sekunder innan poster skickas till din stream.
7. Efter några sekunder, stoppa KDG-generatorn och kontrollera dina S3-hinkar för de levererade filerna.

Följande är ett exempel på rådata i den råa S3-hinken:

{"User":"12345", "Tweet1":" Good morning, everybody. My name is Van Bokhorst Serdar, and today I feel like sharing a whole lot of personal information with you. Let's start with my Email address SerdarvanBokhorst@dayrep.com. My address is 2657 Koontz Lane, Los Angeles, CA. My phone number is 818-828-6231.", "Tweet2": "My Social security number is 548-95-6370. My Bank account number is 940517528812 and routing number 195991012. My credit card number is 5534816011668430, Expiration Date 6/1/2022, my C V V code is 121, and my pin 123456. Well, I think that's it. You know a whole lot about me. And I hope that Amazon comprehend is doing a good job at identifying PII entities so you can redact my personal information away from this streaming record. Let's check"}

Följande är ett exempel på redigerad data i den redigerade S3-hinken:

{"User":"12345", "Tweet1":"Good morning, everybody. My name is *******************, and today I feel like sharing a whole lot of personal information with you. Let's start with my Email address ****************************. My address is ********************************** My phone number is ************.", "Tweet"2: "My Social security number is ***********. My Bank account number is ************ and routing number *********. My credit card number is ****************, Expiration Date ********, my C V V code is ***, and my pin ******. Well, I think that's it. You know a whole lot about me. And I hope that Amazon comprehend is doing a good job at identifying PII entities so you can redact my personal information away from this streaming record. Let's check"}

Den känsliga informationen har tagits bort från de redigerade meddelandena, vilket ger förtroende för att du kan dela denna data med slutsystem.

Städa

När du är klar med att experimentera med den här lösningen, rensa upp dina resurser genom att använda AWS CloudFormation-konsolen för att ta bort alla resurser som distribueras i det här exemplet. Om du följde de manuella stegen måste du manuellt ta bort de två hinkarna, den AmazonComprehendPII-Redact funktion, den ComprehendRealTimeBlog stream, logggruppen för ComprehendRealTimeBlog stream och eventuella IAM-roller som skapades.

Slutsats

Det här inlägget visade dig hur du integrerar PII-redaktion i din strömningsarkitektur i nästan realtid och minskar databehandlingstiden genom att utföra redaktion under flygning. I det här scenariot tillhandahåller du den redigerade datan till dina slutanvändare och en datasjö-administratör säkrar den råa hinken för senare användning. Du kan också bygga ytterligare bearbetning med Amazon Comprehend för att identifiera ton eller känsla, identifiera enheter i data och klassificera varje meddelande.

Vi tillhandahöll individuella steg för varje tjänst som en del av det här inlägget, och inkluderade även en CloudFormation-mall som låter dig tillhandahålla de nödvändiga resurserna i ditt konto. Den här mallen bör endast användas för bevis på koncept eller testscenarier. Se utvecklarguiderna för Amazon Comprehend, Lambdaoch Kinesis Data Brandslang för eventuella servicegränser.

För att komma igång med PII-identifiering och redaktion, se Personligt identifierbar information (PII). Med exempelarkitekturen i det här inlägget kan du integrera vilken som helst av Amazon Comprehend API:er med nästan realtidsdata med hjälp av Kinesis Data Firehose-datatransformation. För att lära dig mer om vad du kan bygga med dina nästan realtidsdata med Kinesis Data Firehose, se Amazon Kinesis Data Firehose Developer Guide. Denna lösning är tillgänglig i alla AWS-regioner där Amazon Comprehend och Kinesis Data Firehose är tillgängliga.

Om författarna

Joe Morotti är en lösningsarkitekt på Amazon Web Services (AWS) och hjälper företagskunder över hela Mellanvästern i USA. Han har haft ett brett utbud av tekniska roller och tycker om att visa kundens konst av det möjliga. På fritiden tycker han om att tillbringa kvalitetstid med sin familj för att utforska nya platser och överanalysera sitt idrottslags prestation

Sriharsh Adari är Senior Solutions Architect på Amazon Web Services (AWS), där han hjälper kunder att arbeta baklänges från affärsresultat för att utveckla innovativa lösningar på AWS. Under åren har han hjälpt flera kunder med transformationer av dataplattformar över branschvertikaler. Hans kärnexpertisområde inkluderar teknologistrategi, dataanalys och datavetenskap. På fritiden tycker han om att spela tennis, titta på tv-program och spela Tabla.