Rediger følsomme data fra streamingdata i næsten realtid ved hjælp af Amazon Comprehend og Amazon Kinesis Data Firehose

Levering af data og indsigt næsten i realtid gør det muligt for virksomheder at reagere hurtigt på deres kunders behov. Realtidsdata kan komme fra en række forskellige kilder, herunder sociale medier, IoT-enheder, infrastrukturovervågning, callcenterovervågning og mere. På grund af bredden og dybden af ​​data, der indtages fra flere kilder, leder virksomheder efter løsninger til at beskytte deres kunders privatliv og forhindre, at følsomme data bliver tilgået fra slutsystemer. Du var tidligere nødt til at stole på reglermotorer for personligt identificerbare oplysninger (PII), der kunne markere falske positiver eller gå glip af data, eller du var nødt til at bygge og vedligeholde tilpassede maskinlæringsmodeller (ML) for at identificere PII i dine streamingdata. Du skulle også implementere og vedligeholde den nødvendige infrastruktur til at understøtte disse motorer eller modeller.

For at hjælpe med at strømline denne proces og reducere omkostningerne, kan du bruge Amazon Comprehend, en NLP-tjeneste (natural language processing), der bruger ML til at finde indsigt og relationer som mennesker, steder, følelser og emner i ustruktureret tekst. Du kan nu bruge Amazon Comprehend ML-funktioner til at opdage og redigere PII i kunde-e-mails, supportbilletter, produktanmeldelser, sociale medier og mere. Ingen ML erfaring er påkrævet. For eksempel kan du analysere supportbilletter og vidensartikler for at opdage PII-enheder og redigere teksten, før du indekserer dokumenterne. Derefter er dokumenter fri for PII-enheder, og brugere kan forbruge dataene. Redigering af PII-enheder hjælper dig med at beskytte din kundes privatliv og overholde lokale love og regler.

I dette indlæg lærer du, hvordan du implementerer Amazon Comprehend i dine streamingarkitekturer for at redigere PII-enheder i næsten realtid ved hjælp af Amazon Kinesis Data Firehose med AWS Lambda.

Dette indlæg er fokuseret på at redigere data fra udvalgte felter, der indsættes i en streamingarkitektur ved hjælp af Kinesis Data Firehose, hvor du vil oprette, gemme og vedligeholde yderligere afledte kopier af dataene til forbrug af slutbrugere eller downstream-applikationer. Hvis du bruger Amazon Kinesis datastrømme eller har yderligere use cases uden for PII-redaktion, se Oversæt, redaktér og analyser streamingdata ved hjælp af SQL-funktioner med Amazon Kinesis Data Analytics, Amazon Translate og Amazon Comprehend, hvor vi viser, hvordan du kan bruge Amazon Kinesis Data Analytics Studio drives af Apache Zeppelin , Apache Flash til interaktivt at analysere, oversætte og redigere tekstfelter i streamingdata.

Løsningsoversigt

Følgende figur viser et eksempel på arkitektur til at udføre PII-redaktion af streamingdata i realtid ved hjælp af Amazon Simple Storage Service (Amazon S3), Kinesis Data Firehose datatransformation, Amazon Comprehendog AWS Lambda. Derudover bruger vi AWS SDK til Python (Boto3) til Lambda-funktionerne. Som angivet i diagrammet indeholder S3-råbøtten ikke-redigerede data, og den S3-redakterede bøtte indeholder redigerede data efter brug af Amazon Comprehend DetectPiiEntities API i en Lambda-funktion.

Omkostninger involveret

Ud over omkostningerne til Kinesis Data Firehose, Amazon S3 og Lambda, vil denne løsning medføre brugsomkostninger fra Amazon Comprehend. Det beløb, du betaler, er en faktor af det samlede antal poster, der indeholder PII, og de tegn, der behandles af Lambda-funktionen. For mere information, se Amazon Kinesis Data Firehose-priser, Amazon forstå priserog AWS Lambda-priser.

Lad os som et eksempel antage, at du har 10,000 logposter, og den nøgleværdi, du vil redigere PII fra, er 500 tegn. Ud af de 10,000 logposter er 50 identificeret som indeholdende PII. Prisoplysningerne er som følger:

Indeholder PII-omkostninger:

• Størrelse af hver nøgleværdi = 500 tegn (1 enhed = 100 tegn)
• Antal enheder (100 tegn) pr. post (minimum er 3 enheder) = 5
• Samlede enheder = 10,000 (poster) x 5 (enheder pr. post) x 1 (Amazon Comprehend-anmodninger pr. post) = 50,000
• Pris pr. enhed = $0.000002
  • Samlede omkostninger for at identificere logposter med PII ved hjælp af ContainsPiiEntities API = $0.1 [50,000 enheder x $0.000002] 

Redakt PII-omkostninger:

• Samlede enheder indeholdende PII = 50 (poster) x 5 (enheder pr. post) x 1 (Amazon Comprehend-anmodninger pr. post) = 250
• Pris pr. enhed = $0.0001
  • Samlede omkostninger for at identificere placeringen af ​​PII ved hjælp af DetectPiiEntities API = [antal enheder] x [pris pr. enhed] = 250 x $0.0001 = $0.025

Samlede omkostninger til identifikation og redaktion:

• Samlede omkostninger: $0.1 (validering, hvis feltet indeholder PII) + $0.025 (rediger felter, der indeholder PII) = $0.125

Implementer løsningen med AWS CloudFormation

Til dette indlæg giver vi en AWS CloudFormation redaktion af streaming af data skabelon, som giver de fulde detaljer om implementeringen for at muliggøre gentagelige implementeringer. Ved implementering opretter denne skabelon to S3-buckets: en til at gemme de rå prøvedata indtaget fra Amazon Kinesis Data Generator (KDG), og en til at gemme de redigerede data. Derudover opretter det en Kinesis Data Firehose leveringsstrøm med DirectPUT som input, og en Lambda-funktion, der kalder Amazon Comprehend IndeholderPiiEntities , DetectPiiEntities API til at identificere og redigere PII-data. Lambdafunktionen er afhængig af brugerinput i miljøvariablerne for at bestemme, hvilke nøgleværdier der skal inspiceres for PII.

Lambdafunktionen i denne løsning har begrænset nyttelaststørrelser til 100 KB. Hvis der leveres en nyttelast, hvor teksten er større end 100 KB, springer Lambda-funktionen over den.

Udfør følgende trin for at implementere løsningen:

1. Start CloudFormation-stakken i US East (N. Virginia) us-east-1:
   
2. Indtast et staknavn, og lad andre parametre stå som standard
3. Type Jeg anerkender, at AWS CloudFormation kan skabe IAM-ressourcer med brugerdefinerede navne.
4. Vælg Opret stak.

Implementer ressourcer manuelt

Hvis du foretrækker at bygge arkitekturen manuelt i stedet for at bruge AWS CloudFormation, skal du fuldføre trinene i dette afsnit.

Opret S3-bøtterne

Opret dine S3-spande med følgende trin:

1. På Amazon S3-konsollen skal du vælge spande i navigationsruden.
2. Vælg Opret spand.
3. Opret én bøtte til dine rådata og én til dine redigerede data.
4. Bemærk navnene på de spande, du lige har oprettet.

Opret Lambda-funktionen

For at oprette og implementere Lambda-funktionen skal du udføre følgende trin:

1. Vælg på Lambda-konsollen Opret funktion.
2. Vælg Forfatter fra bunden.
3. Til Funktionsnavn, gå ind AmazonComprehendPII-Redact.
4. Til Runtime, vælg Python 3.9.
5. Til arkitektur, Vælg x86_64.
6. Til Udførelsesrolle, Vælg Opret en ny rolle med Lambda-tilladelser.
7. Når du har oprettet funktionen, skal du indtaste følgende kode:

   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ælg Implementer.
9. Vælg i navigationsruden Konfiguration.
10. Naviger til Miljøvariabler.
11. Vælg Redigere.
12. Til Nøgle, gå ind keys.
13. Til Værdi, indtast de nøgleværdier, du vil redigere PII fra, adskilt af et komma og mellemrum. Indtast f.eks Tweet1, Tweet2 hvis du bruger prøvedataene i det næste afsnit af dette indlæg.
14. Vælg Gem.
15. Naviger til Generel konfiguration.
16. Vælg Redigere.
17. Skift værdien af Timeout til 1 minut.
18. Vælg Gem.
19. Naviger til Tilladelser.
20. Vælg rollenavnet under Udførelsesrolle.
    Du bliver omdirigeret til AWS identitets- og adgangsstyring (IAM) konsol.
21. Til Tilføj tilladelser, vælg Vedhæft politikker.
22. Indtast Comprehend i søgefeltet og vælg politikken ComprehendFullAccess.
23. Vælg Vedhæft politikker.

Opret Firehose-leveringsstrømmen

Udfør følgende trin for at oprette din Firehose-leveringsstream:

1. På Kinesis Data Firehose-konsollen skal du vælge Opret leveringsstrøm.
2. Til Kilde, Vælg Direkte PUT.
3. Til Bestemmelsessted, Vælg Amazon S3.
4. Til Navn på leveringsstrøm, gå ind ComprehendRealTimeBlog.
5. Under Transform kildeposter med AWS Lambda, Vælg Aktiveret.
6. Til AWS Lambda funktion, indtast ARN for den funktion, du oprettede, eller browse til funktionen AmazonComprehendPII-Redact.
7. Til Buffer Size, indstil værdien til 1 MB.
8. Til Bufferinterval, lad det være 60 sekunder.
9. Under Destinationsindstillinger, skal du vælge den S3-bøtte, du oprettede til de redigerede data.
10. Under Sikkerhedskopieringsindstillinger, skal du vælge den S3-bøtte, du har oprettet til råregistreringerne.
11. Under Tilladelse, enten oprette eller opdatere en IAM-rolle, eller vælg en eksisterende rolle med de korrekte tilladelser.
12. Vælg Opret leveringsstrøm.

Implementer streamingdataløsningen med Kinesis Data Generator

Du kan bruge Kinesis Data Generator (KDG) til at indlæse prøvedata til Kinesis Data Firehose og teste løsningen. For at forenkle denne proces tilbyder vi en Lambda-funktion og CloudFormation-skabelon til at oprette en Amazon Cognito bruger og tildel passende tilladelser til at bruge KDG.

1. På Amazon Kinesis Data Generator-side, vælg Opret en Cognito-bruger med CloudFormation.Du bliver omdirigeret til AWS CloudFormation-konsollen for at oprette din stak.
2. Angiv et brugernavn og en adgangskode til den bruger, som du logger ind på KDG med.
3. Lad de andre indstillinger være standard, og opret din stak.
4. På Udgange fanen, skal du vælge KDG UI-linket.
5. Indtast dit brugernavn og din adgangskode for at logge ind.

Send testposter og valider redaktion i Amazon S3

For at teste løsningen skal du udføre følgende trin:

1. Log ind på den KDG URL, du oprettede i det forrige trin.
2. Vælg den region, hvor AWS CloudFormation-stakken blev installeret.
3. Til Stream/leveringsstream, vælg den leveringsstrøm, du har oprettet (hvis du brugte skabelonen, har den formatet accountnumber-awscomprehend-blog).
4. Lad de andre indstillinger stå på deres standardindstillinger.
5. Til registreringsskabelonen kan du oprette dine egne tests eller bruge følgende skabelon. Hvis du bruger de angivne eksempeldata nedenfor til test, bør du have opdaterede miljøvariabler i AmazonComprehendPII-Redact Lambda funktion til Tweet1, Tweet2. Hvis det implementeres via CloudFormation, skal du opdatere miljøvariabler til Tweet1, Tweet2 inden for den oprettede Lambda-funktion. Eksempler på testdata er nedenfor:

   {"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ælg Send data, og giv et par sekunder til at sende poster til din stream.
7. Efter et par sekunder skal du stoppe KDG-generatoren og tjekke dine S3-bøtter for de leverede filer.

Følgende er et eksempel på de rå data i den rå S3-bøtte:

{"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ølgende er et eksempel på de redigerede data i den redigerede S3-bøtte:

{"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"}

De følsomme oplysninger er blevet fjernet fra de redigerede meddelelser, hvilket giver tillid til, at du kan dele disse data med slutsystemer.

Ryd op

Når du er færdig med at eksperimentere med denne løsning, skal du rydde op i dine ressourcer ved at bruge AWS CloudFormation-konsollen til at slette alle de ressourcer, der er implementeret i dette eksempel. Hvis du fulgte de manuelle trin, skal du manuelt slette de to spande, den AmazonComprehendPII-Redact funktion, den ComprehendRealTimeBlog stream, loggruppen for ComprehendRealTimeBlog stream og eventuelle IAM-roller, der blev oprettet.

Konklusion

Dette indlæg viste dig, hvordan du integrerer PII-redaktion i din streamingarkitektur i næsten realtid og reducerer databehandlingstiden ved at udføre redaktion under flyvning. I dette scenarie leverer du de redigerede data til dine slutbrugere, og en datasø-administrator sikrer den rå bucket til senere brug. Du kan også bygge yderligere behandling med Amazon Comprehend for at identificere tone eller stemning, identificere enheder i dataene og klassificere hver besked.

Vi leverede individuelle trin for hver tjeneste som en del af dette indlæg og inkluderede også en CloudFormation-skabelon, der giver dig mulighed for at levere de nødvendige ressourcer på din konto. Denne skabelon bør kun bruges til proof of concept eller testscenarier. Se udviklervejledningerne for Amazon Comprehend, Lambdaog Kinesis Data Brandslange for eventuelle servicegrænser.

For at komme i gang med PII-identifikation og redaktion, se Personligt identificerbare oplysninger (PII). Med eksempelarkitekturen i dette indlæg kan du integrere enhver af Amazon Comprehend API'erne med næsten-realtidsdata ved hjælp af Kinesis Data Firehose-datatransformation. For at lære mere om, hvad du kan bygge med dine næsten-realtidsdata med Kinesis Data Firehose, se Amazon Kinesis Data Firehose Developer Guide. Denne løsning er tilgængelig i alle AWS-regioner, hvor Amazon Comprehend og Kinesis Data Firehose er tilgængelige.

Om forfatterne

Joe Morotti er Solutions Architect hos Amazon Web Services (AWS), der hjælper Enterprise-kunder i hele Midtvesten i USA. Han har haft en bred vifte af tekniske roller og nyder at vise kundens kunst af det mulige. I sin fritid nyder han at bruge kvalitetstid sammen med sin familie på at udforske nye steder og overanalysere sit sportsholds præstationer

Sriharsh Adari er Senior Solutions Architect hos Amazon Web Services (AWS), hvor han hjælper kunder med at arbejde baglæns fra forretningsresultater for at udvikle innovative løsninger på AWS. I årenes løb har han hjulpet adskillige kunder med transformationer af dataplatforme på tværs af brancher. Hans kerneområde omfatter teknologistrategi, dataanalyse og datavidenskab. I sin fritid kan han lide at spille tennis, se tv-serier og spille Tabla.