Levering av data og innsikt nesten i sanntid gjør det mulig for virksomheter å reagere raskt på kundenes behov. Sanntidsdata kan komme fra en rekke kilder, inkludert sosiale medier, IoT-enheter, infrastrukturovervåking, callsenterovervåking og mer. På grunn av bredden og dybden av data som inntas fra flere kilder, ser bedrifter etter løsninger for å beskytte kundenes personvern og hindre at sensitive data blir tilgang til fra sluttsystemer. Du måtte tidligere stole på regelmotorer for personlig identifiserbar informasjon (PII) som kunne flagge falske positiver eller gå glipp av data, eller du måtte bygge og vedlikeholde tilpassede maskinlæringsmodeller (ML) for å identifisere PII i strømmedataene dine. Du trengte også å implementere og vedlikeholde infrastrukturen som er nødvendig for å støtte disse motorene eller modellene.

For å effektivisere denne prosessen og redusere kostnadene, kan du bruke Amazon Comprehend, en naturlig språkbehandlingstjeneste (NLP) som bruker ML for å finne innsikt og relasjoner som mennesker, steder, følelser og emner i ustrukturert tekst. Du kan nå bruke Amazon Comprehend ML-funksjoner til å oppdage og redigere PII i kunde-e-poster, supportbilletter, produktanmeldelser, sosiale medier og mer. Ingen ML-erfaring kreves. Du kan for eksempel analysere støttebilletter og kunnskapsartikler for å oppdage PII-enheter og redigere teksten før du indekserer dokumentene. Etter det er dokumenter fri for PII-enheter og brukere kan konsumere dataene. Redigere PII-enheter hjelper deg med å beskytte kundens personvern og overholde lokale lover og forskrifter.

I dette innlegget lærer du hvordan du implementerer Amazon Comprehend i strømmearkitekturene dine for å redigere PII-enheter i nesten sanntid ved å bruke Amazon Kinesis Data Firehose med AWS Lambda.

Dette innlegget er fokusert på å redigere data fra utvalgte felt som tas inn i en strømmearkitektur ved hjelp av Kinesis Data Firehose, hvor du ønsker å opprette, lagre og vedlikeholde ytterligere avledede kopier av dataene for forbruk av sluttbrukere eller nedstrømsapplikasjoner. Hvis du bruker Amazon Kinesis datastrømmer eller har flere brukstilfeller utenfor PII-redigering, se Oversett, redakter og analyser strømmedata ved hjelp av SQL-funksjoner med Amazon Kinesis Data Analytics, Amazon Translate og Amazon Comprehend, hvor vi viser hvordan du kan bruke Amazon Kinesis Data Analytics Studio drevet av Apache Zeppelin og Apache Flash å interaktivt analysere, oversette og redigere tekstfelt i strømmedata.

Løsningsoversikt

Følgende figur viser en eksempelarkitektur for å utføre PII-redaksjon av strømmedata i sanntid, ved hjelp av Amazon enkel lagringstjeneste (Amazon S3), Kinesis Data Firehose datatransformasjon, Amazon Comprehendog AWS Lambda. I tillegg bruker vi AWS SDK for Python (Boto3) for Lambda-funksjonene. Som angitt i diagrammet inneholder S3-råbøtten ikke-redigerte data, og den S3-redigerte bøtten inneholder redigerte data etter bruk av Amazon Comprehend DetectPiiEntities API i en Lambda-funksjon.

Kostnader involvert

I tillegg til kostnadene for Kinesis Data Firehose, Amazon S3 og Lambda, vil denne løsningen pådra seg brukskostnader fra Amazon Comprehend. Beløpet du betaler er en faktor av det totale antallet poster som inneholder PII og tegnene som behandles av Lambda-funksjonen. For mer informasjon, se Amazon Kinesis Data Firehose-priser, Amazon Comprehend Pricingog AWS Lambda Priser.

Som et eksempel, la oss anta at du har 10,000 500 loggposter, og nøkkelverdien du vil redigere PII fra er 10,000 tegn. Av de 50 XNUMX loggpostene er XNUMX identifisert som å inneholde PII. Kostnadsdetaljene er som følger:

Inneholder PII-kostnad:

• Størrelsen på hver nøkkelverdi = 500 tegn (1 enhet = 100 tegn)
• Antall enheter (100 tegn) per post (minimum er 3 enheter) = 5
• Totale enheter = 10,000 5 (poster) x 1 (enheter per post) x 50,000 (Amazon Comprehend-forespørsler per post) = XNUMX XNUMX
• Pris per enhet = $ 0.000002
  • Total kostnad for å identifisere loggposter med PII ved hjelp av ContainsPiiEntities API = $0.1 [50,000 0.000002 enheter x $XNUMX] 

Redact PII-kostnad:

• Totale enheter som inneholder PII = 50 (poster) x 5 (enheter per post) x 1 (Amazon Comprehend-forespørsler per post) = 250
• Pris per enhet = $ 0.0001
  • Total kostnad for å identifisere plasseringen av PII ved hjelp av DetectPiiEntities API = [antall enheter] x [kostnad per enhet] = 250 x $0.0001 = $0.025

Totalkostnad for identifikasjon og redaksjon:

• Total kostnad: $0.1 (validering hvis feltet inneholder PII) + $0.025 (rediger felt som inneholder PII) = $0.125

Distribuer løsningen med AWS CloudFormation

For dette innlegget gir vi en AWS skyformasjon redaksjon av strømmedata mal, som gir alle detaljer om implementeringen for å muliggjøre repeterbare distribusjoner. Ved distribusjon oppretter denne malen to S3-bøtter: en for å lagre råprøvedataene som er inntatt fra Amazon Kinesis Data Generator (KDG), og en for å lagre de redigerte dataene. I tillegg oppretter den en Kinesis Data Firehose-leveringsstrøm med DirectPUT som input, og en Lambda-funksjon som kaller Amazon Comprehend InneholderPiiEntities og DetectPiiEntities API for å identifisere og redigere PII-data. Lambda-funksjonen er avhengig av brukerinndata i miljøvariablene for å bestemme hvilke nøkkelverdier som må inspiseres for PII.

Lambda-funksjonen i denne løsningen har begrensede nyttelaststørrelser til 100 KB. Hvis en nyttelast leveres der teksten er større enn 100 KB, vil Lambda-funksjonen hoppe over den.

Gjør følgende for å distribuere løsningen:

1. Start CloudFormation-stabelen i US East (N. Virginia) us-east-1:
   
2. Skriv inn et stabelnavn, og la andre parametere stå som standard
3. Plukke ut Jeg erkjenner at AWS CloudFormation kan lage IAM-ressurser med tilpassede navn.
4. Velg Lag stabel.

Distribuer ressurser manuelt

Hvis du foretrekker å bygge arkitekturen manuelt i stedet for å bruke AWS CloudFormation, fullfør trinnene i denne delen.

Lag S3-bøttene

Lag S3-bøtter med følgende trinn:

1. Velg på Amazon S3-konsollen Bøtter i navigasjonsruten.
2. Velg Lag bøtte.
3. Lag én bøtte for rådataene dine og én for de redigerte dataene dine.
4. Legg merke til navnene på bøttene du nettopp har laget.

Lag Lambda-funksjonen

For å opprette og distribuere Lambda-funksjonen, fullfør følgende trinn:

1. Velg Lambda-konsollen Opprett funksjon.
2. Velg Forfatter fra bunnen av.
3. Til Funksjonsnavn, Tast inn AmazonComprehendPII-Redact.
4. Til Runtime, velg Python 3.9.
5. Til arkitektur, plukke ut x86_64.
6. Til Utførelsesrolle, plukke ut Opprett en ny rolle med Lambda-tillatelser.
7. Etter at du har opprettet funksjonen, skriv inn 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. Velg Distribuer.
9. Velg i navigasjonsruten Konfigurasjon.
10. naviger til Miljøvariabler.
11. Velg Rediger.
12. Til nøkkel, Tast inn keys.
13. Til Verdi, skriv inn nøkkelverdiene du vil redigere PII fra, atskilt med komma og mellomrom. For eksempel, enter Tweet1, Tweet2 hvis du bruker prøvedataene i neste del av dette innlegget.
14. Velg Spar.
15. naviger til Generell konfigurasjon.
16. Velg Rediger.
17. Endre verdien av Timeout til 1 minutt.
18. Velg Spar.
19. naviger til Tillatelser.
20. Velg rollenavnet under Gjennomføringsrolle.
    Du blir omdirigert til AWS identitets- og tilgangsadministrasjon (IAM) konsoll.
21. Til Legg til tillatelser, velg Legg ved retningslinjer.
22. Enter Comprehend inn i søkefeltet og velg policyen ComprehendFullAccess.
23. Velg Legg ved retningslinjer.

Opprett Firehose-leveringsstrømmen

For å opprette Firehose-leveringsstrømmen, fullfør følgende trinn:

1. På Kinesis Data Firehose-konsollen velger du Opprett leveringsstrøm.
2. Til kilde, plukke ut Direkte PUT.
3. Til Destinasjon, plukke ut Amazon S3.
4. Til Navn på leveringsstrøm, Tast inn ComprehendRealTimeBlog.
5. Under Transform kildeposter med AWS Lambda, plukke ut aktivert.
6. Til AWS Lambda-funksjon, skriv inn ARN for funksjonen du opprettet, eller bla til funksjonen AmazonComprehendPII-Redact.
7. Til Buffer størrelse, sett verdien til 1 MB.
8. Til Bufferintervall, la det være i 60 sekunder.
9. Under Destinasjonsinnstillinger, velg S3-bøtten du opprettet for de redigerte dataene.
10. Under Sikkerhetskopieringsinnstillinger, velg S3-bøtten du opprettet for råpostene.
11. Under Tillatelse, enten opprette eller oppdatere en IAM-rolle, eller velg en eksisterende rolle med de riktige tillatelsene.
12. Velg Opprett leveringsstrøm.

Distribuer strømmedataløsningen med Kinesis Data Generator

Du kan bruke Kinesis Data Generator (KDG) til å ta inn prøvedata til Kinesis Data Firehose og teste løsningen. For å forenkle denne prosessen tilbyr vi en Lambda-funksjon og CloudFormation-mal for å lage en Amazon Cognito bruker og tilordne passende tillatelser for å bruke KDG.

1. På Amazon Kinesis Data Generator-side, velg Opprett en Cognito-bruker med CloudFormation.Du blir omdirigert til AWS CloudFormation-konsollen for å lage stabelen din.
2. Oppgi et brukernavn og passord for brukeren du logger på KDG med.
3. La de andre innstillingene stå på standardinnstillingene og lag stabelen din.
4. På Utganger fanen, velg KDG UI-koblingen.
5. Skriv inn brukernavn og passord for å logge på.

Send testposter og valider redaksjon i Amazon S3

For å teste løsningen, fullfør følgende trinn:

1. Logg på KDG-URLen du opprettet i forrige trinn.
2. Velg regionen der AWS CloudFormation-stakken ble distribuert.
3. Til Stream/leveringsstrøm, velg leveringsstrømmen du opprettet (hvis du brukte malen, har den formatet accountnumber-awscomprehend-blog).
4. La de andre innstillingene stå på standardinnstillingene.
5. For postmalen kan du lage dine egne tester, eller bruke følgende mal. Hvis du bruker eksempeldataene nedenfor for testing, bør du ha oppdaterte miljøvariabler i AmazonComprehendPII-Redact Lambda funksjon til Tweet1, Tweet2. Hvis den distribueres via CloudFormation, oppdater miljøvariabler til Tweet1, Tweet2 innenfor den opprettede Lambda-funksjonen. Eksempeltestdataene 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. Velg Send data, og la noen sekunder før poster sendes til strømmen din.
7. Etter noen sekunder, stopp KDG-generatoren og sjekk S3-bøttene dine for de leverte filene.

Følgende er et eksempel på rådataene i den rå S3-bøtten:

{"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 redigerte dataene i den redigerte S3-bøtten:

{"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 sensitive informasjonen er fjernet fra de redigerte meldingene, noe som gir tillit til at du kan dele disse dataene med sluttsystemer.

Opprydding

Når du er ferdig med å eksperimentere med denne løsningen, kan du rydde opp i ressursene dine ved å bruke AWS CloudFormation-konsollen for å slette alle ressursene som er distribuert i dette eksemplet. Hvis du fulgte de manuelle trinnene, må du manuelt slette de to bøttene, den AmazonComprehendPII-Redact funksjon, ComprehendRealTimeBlog stream, logggruppen for ComprehendRealTimeBlog stream og eventuelle IAM-roller som ble opprettet.

konklusjonen

Dette innlegget viste deg hvordan du integrerer PII-redaksjon i strømmearkitekturen din i nær sanntid og reduserer databehandlingstiden ved å utføre redaksjon under flyturen. I dette scenariet gir du de redigerte dataene til sluttbrukerne dine, og en datainnsjø-administrator sikrer råbøtten for senere bruk. Du kan også bygge ytterligere behandling med Amazon Comprehend for å identifisere tone eller følelse, identifisere enheter i dataene og klassifisere hver melding.

Vi ga individuelle trinn for hver tjeneste som en del av dette innlegget, og inkluderte også en CloudFormation-mal som lar deg levere de nødvendige ressursene i kontoen din. Denne malen skal kun brukes for proof of concept eller testscenarier. Se utviklerveiledningene for Amazon Comprehend, Lambdaog Kinesis Data brannslange for eventuelle tjenestegrenser.

For å komme i gang med PII-identifikasjon og redaksjon, se Personlig identifiserbar informasjon (PII). Med eksempelarkitekturen i dette innlegget kan du integrere hvilken som helst av Amazon Comprehend API-ene med nesten sanntidsdata ved å bruke Kinesis Data Firehose-datatransformasjon. For å lære mer om hva du kan bygge med dine nærsanntidsdata med Kinesis Data Firehose, se Amazon Kinesis Data Firehose utviklerveiledning. Denne løsningen er tilgjengelig i alle AWS-regioner der Amazon Comprehend og Kinesis Data Firehose er tilgjengelig.

Om forfatterne

Joe Morotti er en løsningsarkitekt hos Amazon Web Services (AWS), og hjelper Enterprise-kunder over hele Midtvesten i USA. Han har hatt et bredt spekter av tekniske roller og liker å vise kundens kunst av det mulige. På fritiden liker han å tilbringe kvalitetstid med familien på å utforske nye steder og overanalysere idrettslagets prestasjoner

Sriharsh Adari er Senior Solutions Architect hos Amazon Web Services (AWS), hvor han hjelper kunder med å jobbe bakover fra forretningsresultater for å utvikle innovative løsninger på AWS. Gjennom årene har han hjulpet flere kunder med transformasjoner av dataplattformer på tvers av industrivertikaler. Hans kjernekompetanse inkluderer teknologistrategi, dataanalyse og datavitenskap. På fritiden liker han å spille tennis, se på TV-serier og spille Tabla.