Erkennung sensibler Daten mithilfe von AWS verwalteter PII-Typen Erkennung sensibler Daten mithilfe von AWS CustomEntityType PII-Typen Erkennungsparameter für die Verwendung von detect()Erkennungsparameter für classifyColumns()

Erkennung sensibler Daten außerhalb von AWS Glue Studio verwenden

AWS Glue Studio ermöglicht es Ihnen, sensible Daten zu erkennen. Sie können die Funktion zur Erkennung sensibler Daten jedoch auch außerhalb von AWS Glue Studio verwenden.

Eine vollständige Liste der verwalteten vertraulichen Datentypen finden Sie unter Verwaltete Datentypen.

Erkennung sensibler Daten mithilfe von AWS verwalteter PII-Typen

AWS Glue stellt zwei APIs in einem AWS Glue ETL-Auftrag bereit. Diese sind detect() und classifyColumns():



  detect(frame: DynamicFrame, 
      entityTypesToDetect: Seq[String], 
      outputColumnName: String = "DetectedEntities",
      detectionSensitivity: String = "LOW"): DynamicFrame

 detect(frame: DynamicFrame, 
      detectionParameters: JsonOptions,
      outputColumnName: String = "DetectedEntities",
      detectionSensitivity: String = "LOW"): DynamicFrame
      
  classifyColumns(frame: DynamicFrame, 
      entityTypesToDetect: Seq[String], 
      sampleFraction: Double = 0.1, 
      thresholdFraction: Double = 0.1,
      detectionSensitivity: String = "LOW")

Sie können die detect() API verwenden, um AWS verwaltete PII-Typen und benutzerdefinierte Entitätstypen zu identifizieren. Es wird automatisch eine neue Spalte mit dem Erkennungsergebnis erstellt. Die classifyColumns() API gibt eine Map zurück, in der Schlüssel Spaltennamen und Werte eine Liste der erkannten Entitätstypen sind. SampleFraction gibt den Bruchteil der Daten an, der beim Scannen nach PII-Entitäten geprobt werden muss und ThresholdFraction gibt den Bruchteil der Daten an, der erfüllt sein muss, damit eine Spalte als PII-Daten identifiziert werden kann.

Erkennung auf Zeilenebene

Im Beispiel führt der Job die folgenden Aktionen mithilfe der APIs detect() und classifyColumns() aus:

liest Daten aus einem Amazon S3-Bucket und wandelt sie in einen DynamicFrame um
erkennt Instances von „E-Mail“ und „Kreditkarte“ im DynamicFrame
gibt einen DynamicFrame mit Originalwerten plus einer Spalte zurück, die das Erkennungsergebnis für jede Zeile umfasst
schreibt den zurückgegebenen DynamicFrame in einen anderen Amazon S3-Pfad



  import com.amazonaws.services.glue.GlueContext
  import com.amazonaws.services.glue.MappingSpec
  import com.amazonaws.services.glue.errors.CallSite
  import com.amazonaws.services.glue.util.GlueArgParser
  import com.amazonaws.services.glue.util.Job
  import com.amazonaws.services.glue.util.JsonOptions
  import org.apache.spark.SparkContext
  import scala.collection.JavaConverters._
  import com.amazonaws.services.glue.ml.EntityDetector
  
  object GlueApp {
    def main(sysArgs: Array[String]) {
      val spark: SparkContext = new SparkContext()
      val glueContext: GlueContext = new GlueContext(spark)
      val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
      Job.init(args("JOB_NAME"), glueContext, args.asJava)
      val frame= glueContext.getSourceWithFormat(formatOptions=JsonOptions("""{"quoteChar": "\"", "withHeader": true, "separator": ","}"""), connectionType="s3", format="csv", options=JsonOptions("""{"paths": ["s3://pathToSource"], "recurse": true}"""), transformationContext="AmazonS3_node1650160158526").getDynamicFrame()
  
      val frameWithDetectedPII = EntityDetector.detect(frame, Seq("EMAIL", "CREDIT_CARD"))
  
      glueContext.getSinkWithFormat(connectionType="s3", options=JsonOptions("""{"path": "s3://pathToOutput/", "partitionKeys": []}"""), transformationContext="someCtx", format="json").writeDynamicFrame(frameWithDetectedPII)
  
      Job.commit()
    }
  }

Erkennung auf Zeilenebene mit fein abgestuften Aktionen

Im Beispiel führt der Job die folgenden Aktionen mithilfe der detect()-APIs:

liest Daten aus einem Amazon-S3-Bucket und wandelt sie in einen DynamicFrame um
Erkennung sensibler Datentypen für „USA_PTIN“, „BANK_ACCOUNT“, „USA_SSN“, „USA_PASSPORT_NUMBER“ und „PHONE_NUMBER“ im DynamicFrame
gibt einen DynamicFrame mit bearbeiteten maskierten Werten plus einer Spalte zurück, die das Erkennungsergebnis für jede Zeile umfasst
schreibt den zurückgegebenen DynamicFrame in einen anderen Amazon-S3-Pfad

Im Gegensatz zur obigen API werden hier detaillierte Aktionen für die Erkennung von Entitätstypen verwendet. detect() Weitere Informationen finden Sie unter Erkennungsparameter für die Verwendung von detect().


import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.MappingSpec
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
import com.amazonaws.services.glue.ml.EntityDetector

object GlueApp {
  def main(sysArgs: Array[String]) {
    val spark: SparkContext = new SparkContext()
    val glueContext: GlueContext = new GlueContext(spark)
    val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
    Job.init(args("JOB_NAME"), glueContext, args.asJava)
    val frame = glueContext.getSourceWithFormat(formatOptions=JsonOptions("""{"quoteChar": "\"", "withHeader": true, "separator": ","}"""), connectionType="s3", format="csv", options=JsonOptions("""{"paths": ["s3://pathToSource"], "recurse": true}"""), transformationContext="AmazonS3_node_source").getDynamicFrame()

    val detectionParameters = JsonOptions(
      """
        {
          "USA_DRIVING_LICENSE": [{
            "action": "PARTIAL_REDACT",
            "sourceColumns": ["Driving License"],
            "actionOptions": {
              "matchPattern": "[0-9]",
              "redactChar": "*"
            }
          }],
          "BANK_ACCOUNT": [{
            "action": "DETECT",
            "sourceColumns": ["*"]
          }],
          "USA_SSN": [{
            "action": "SHA256_HASH",
            "sourceColumns": ["SSN"]
          }],
          "IP_ADDRESS": [{
            "action": "REDACT",
            "sourceColumns": ["IP Address"],
            "actionOptions": {"redactText": "*****"}
          }],
          "PHONE_NUMBER": [{
            "action": "PARTIAL_REDACT",
            "sourceColumns": ["Phone Number"],
            "actionOptions": {
              "numLeftCharsToExclude": 1,
              "numRightCharsToExclude": 0,
              "redactChar": "*"
            }
          }]
        }
      """
    )

    val frameWithDetectedPII = EntityDetector.detect(frame, detectionParameters, "DetectedEntities", "HIGH")

    glueContext.getSinkWithFormat(connectionType="s3", options=JsonOptions("""{"path": "s3://pathToOutput/", "partitionKeys": []}"""), transformationContext="AmazonS3_node_target", format="json").writeDynamicFrame(frameWithDetectedPII)

    Job.commit()
  }
}

Erkennung auf Spaltenebene

Im Beispiel führt der Job die folgenden Aktionen mithilfe der classifyColumns()-APIs:

liest Daten aus einem Amazon-S3-Bucket und wandelt sie in einen DynamicFrame um
erkennt Instances von „E-Mail“ und „Kreditkarte“ im DynamicFrame
Stellen Sie die Parameter so ein, dass 100 % der Spalte erfasst werden, markieren Sie eine Entität als erkannt, wenn sie sich in 10 % der Zellen befindet, und stellen Sie die Empfindlichkeit „LOW“ ein.
Gibt eine Zuordnung zurück, in der Spaltennamen die Schlüssel sind und die Liste der erkannten Entitätstypen die Werte bildet.
schreibt den zurückgegebenen DynamicFrame in einen anderen Amazon-S3-Pfad


import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.MappingSpec
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
import com.amazonaws.services.glue.DynamicFrame
import com.amazonaws.services.glue.ml.EntityDetector

object GlueApp {
  def main(sysArgs: Array[String]) {
    val spark: SparkContext = new SparkContext()
    val glueContext: GlueContext = new GlueContext(spark)
    val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
    Job.init(args("JOB_NAME"), glueContext, args.asJava)
    val frame = glueContext.getSourceWithFormat(formatOptions=JsonOptions("""{"quoteChar": "\"", "withHeader": true, "separator": ",", "optimizePerformance": false}"""), connectionType="s3", format="csv", options=JsonOptions("""{"paths": ["s3://pathToSource"], "recurse": true}"""), transformationContext="frame").getDynamicFrame()
    
    import glueContext.sparkSession.implicits._

    val detectedDataFrame = EntityDetector.classifyColumns(
        frame, 
        entityTypesToDetect = Seq("CREDIT_CARD", "PHONE_NUMBER"), 
        sampleFraction = 1.0, 
        thresholdFraction = 0.1,
        detectionSensitivity = "LOW"
    )
    val detectedDF = (detectedDataFrame).toSeq.toDF("columnName", "entityTypes")
    val DetectSensitiveData_node = DynamicFrame(detectedDF, glueContext)

    glueContext.getSinkWithFormat(connectionType="s3", options=JsonOptions("""{"path": "s3://pathToOutput", "partitionKeys": []}"""), transformationContext="someCtx", format="json").writeDynamicFrame(DetectSensitiveData_node)

    Job.commit()
  }
}

Erkennung sensibler Daten mithilfe von AWS CustomEntityType PII-Typen

Sie können benutzerdefinierte Entitäten über AWS Studio definieren. Um dieses Feature jedoch außerhalb von AWS Studio verwenden zu können, müssen Sie zuerst die benutzerdefinierten Entitätstypen definieren und dann die definierten benutzerdefinierten Entitätstypen zur Liste von entityTypesToDetect hinzufügen.

Wenn Ihre Daten bestimmte sensible Datentypen enthalten (z. B. „Mitarbeiter-ID“), können Sie benutzerdefinierte Entitäten erstellen, indem Sie die API CreateCustomEntityType() aufrufen. Das folgende Beispiel definiert den benutzerdefinierten Entitätstyp 'EMPLOYEE_ID' für die API CreateCustomEntityType() mit den Anforderungsparametern:



  { 
      "name": "EMPLOYEE_ID",
      "regexString": "\d{4}-\d{3}",
      "contextWords": ["employee"]
  }

Ändern Sie dann den Auftrag, um den neuen benutzerdefinierten vertraulichen Datentyp zu verwenden, indem Sie der API EntityDetector() den benutzerdefinierten Entitätstyp (EMPLOYEE_ID) hinzufügen:



  import com.amazonaws.services.glue.GlueContext
  import com.amazonaws.services.glue.MappingSpec
  import com.amazonaws.services.glue.errors.CallSite
  import com.amazonaws.services.glue.util.GlueArgParser
  import com.amazonaws.services.glue.util.Job
  import com.amazonaws.services.glue.util.JsonOptions
  import org.apache.spark.SparkContext
  import scala.collection.JavaConverters._
  import com.amazonaws.services.glue.ml.EntityDetector
  
  object GlueApp {
    def main(sysArgs: Array[String]) {
      val spark: SparkContext = new SparkContext()
      val glueContext: GlueContext = new GlueContext(spark)
      val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
      Job.init(args("JOB_NAME"), glueContext, args.asJava)
      val frame= glueContext.getSourceWithFormat(formatOptions=JsonOptions("""{"quoteChar": "\"", "withHeader": true, "separator": ","}"""), connectionType="s3", format="csv", options=JsonOptions("""{"paths": ["s3://pathToSource"], "recurse": true}"""), transformationContext="AmazonS3_node1650160158526").getDynamicFrame()
  
      val frameWithDetectedPII = EntityDetector.detect(frame, Seq("EMAIL", "CREDIT_CARD", "EMPLOYEE_ID"))
  
      glueContext.getSinkWithFormat(connectionType="s3", options=JsonOptions("""{"path": "s3://pathToOutput/", "partitionKeys": []}"""), transformationContext="someCtx", format="json").writeDynamicFrame(frameWithDetectedPII)
  
      Job.commit()
    }
  }

Anmerkung

Wenn ein benutzerdefinierter sensibler Datentyp mit demselben Namen wie ein vorhandener verwalteter Entitätstyp definiert ist, hat der benutzerdefinierte sensible Datentyp Vorrang und überschreibt die Logik des verwalteten Entitätstyps.

Erkennungsparameter für die Verwendung von `detect()`

Diese Methode wird zum Erkennen von Entitäten in einem DynamicFrame verwendet. Sie gibt einen neuen DataFrame mit Originalwerten und einer zusätzlichen Spalte OutputColumnName zurück, die Metadaten zur PII-Erkennung enthält. Eine benutzerdefinierte Maskierung kann durchgeführt werden, nachdem dieser DynamicFrame im AWS Glue-Skript zurückgegeben wurde, oder es kann stattdessen die detect()-API mit detaillierten Aktionen verwendet werden.


detect(frame: DynamicFrame, 
       entityTypesToDetect: Seq[String], 
       outputColumnName: String = "DetectedEntities",
       detectionSensitivity: String = "LOW"): DynamicFrame

Parameter:

frame – (Typ:DynamicFrame) Der Eingabe-DynamicFrame, der die zu verarbeitenden Daten enthält.
entityTypesToDetect – (Typ:[Seq[String]) Liste der zu erkennenden Entitätstypen. Dabei kann es sich entweder um verwaltete Entitätstypen oder um benutzerdefinierte Entitätstypen handeln.
outputColumnName – (Typ:String, Standard: „DetectedEntities“) Der Name der Spalte, in der erkannte Entitäten gespeichert werden. Falls nicht angegeben, lautet der Standardspaltenname „DetectedEntities“.
detectionSensitivity – (Typ:String, Optionen: „LOW“ oder „HIGH“, Standard: „LOW“) Gibt die Empfindlichkeit des Erkennungsprozesses an. Gültige Optionen sind „LOW“ oder „HIGH“. Falls nicht angegeben, ist die Standardempfindlichkeit auf „LOW“ eingestellt.

outputColumnName-Einstellungen:

Der Name der Spalte, in der erkannte Entitäten gespeichert werden sollen. Falls nicht angegeben, lautet der Standardspaltenname „DetectedEntities“. Für jede Zeile in der Ausgabespalte enthält die zusätzliche Spalte eine Zuordnung des Spaltennamens zu den Metadaten der erkannten Entität mit den folgenden Schlüssel-Wert-Paaren:

entityType – Der erkannte Entitätstyp.
start – Die Startposition der erkannten Entität in den Originaldaten.
end – Die Endposition der erkannten Entität in den Originaldaten.
actionUsed – Die Aktion, die an der erkannten Entität ausgeführt wurde (z. B. „DETECT“, „REDACT“, „PARTIAL_REDACT“, „SHA256_HASH“).

Beispiel:


{
   "DetectedEntities":{
      "SSN Col":[
         {
            "entityType":"USA_SSN",
            "actionUsed":"DETECT",
            "start":4,
            "end":15
         }
      ],
      "Random Data col":[
         {
            "entityType":"BANK_ACCOUNT",
            "actionUsed":"PARTIAL_REDACT",
            "start":4,
            "end":13
         },
         {
            "entityType":"IP_ADDRESS",
            "actionUsed":"REDACT",
            "start":4,
            "end":13
         }
      ]
   }
}

Erkennungsparameter für detect() mit detaillierten Aktionen

Diese Methode wird zum Erkennen von Entitäten in einem DynamicFrame mit bestimmten Parametern verwendet. Sie gibt einen neuen DataFrame mit Originalwerten, die durch maskierte sensible Daten ersetzt werden, und einer zusätzlichen Spalte outputColumnName zurück, die Metadaten zur PII-Erkennung enthält.


detect(frame: DynamicFrame, 
       detectionParameters: JsonOptions,
       outputColumnName: String = "DetectedEntities",
       detectionSensitivity: String = "LOW"): DynamicFrame

Parameter:

frame – (Typ: DynamicFrame): Der Eingabe-DynamicFrame, der die zu verarbeitenden Daten enthält.
detectionParameters – (Typ: JsonOptions): JSON-Optionen, die Parameter für den Erkennungsprozess angeben.
outputColumnName – (Typ:String, Standard: „DetectedEntities“); Der Name der Spalte, in der erkannte Entitäten gespeichert werden. Falls nicht angegeben, lautet der Standardspaltenname „DetectedEntities“.
detectionSensitivity – (Typ:String, Optionen: „LOW“ oder „HIGH“, Standard: „LOW“): Gibt die Empfindlichkeit des Erkennungsprozesses an. Gültige Optionen sind „LOW“ oder „HIGH“. Falls nicht angegeben, ist die Standardempfindlichkeit auf „LOW“ eingestellt.

detectionParameters-Einstellungen

Wenn keine Einstellungen enthalten sind, werden Standardwerte verwendet.

action – (Typ:String, Optionen: „DETECT“, „REDACT“, „PARTIAL_REDACT“, „SHA256_HASH“) Gibt die Aktion an, die für die Entität ausgeführt werden soll. Erforderlich Beachten Sie, dass Aktionen, die eine Maskierung durchführen (alle außer „DETECT“), nur einmal pro Spalte ausgeführt werden. Dies ist eine vorbeugende Maßnahme zur Maskierung zusammengeführter Entitäten.
sourceColumns – (Typ:List[String], Standard: [„*“]) Liste der Quellspaltennamen, anhand derer die Entität erkannt werden soll. Wenn hier nichts angegeben ist, lautet die Standardeinstellung [„*“]. IllegalArgumentException wird ausgelöst, wenn ein ungültiger Spaltenname verwendet wird.
sourceColumnsToExclude – (Typ:List[String]) Liste der Quellspaltennamen, anhand derer die Entität erkannt werden soll. Verwenden Sie entweder sourceColumns oder sourceColumnsToExclude. IllegalArgumentException wird ausgelöst, wenn ein ungültiger Spaltenname verwendet wird.
actionOptions – Zusätzliche Optionen, die auf der angegebenen Aktion basieren:
- Für „DETECT“ und „SHA256_HASH“ sind keine Optionen zulässig.
- Für „REDACT“:
  - redactText – (Typ:String, Standard: „*****“) Text, der die erkannte Entität ersetzen soll.
- Für „PARTIAL_REDACT“:
  - redactChar – (Typ:String, Standard: „*“) Zeichen, das jedes erkannte Zeichen in der Entität ersetzen soll.
  - matchPattern – (Typ:String) Regex-Muster für teilweises Redigieren. Kann nicht mit numLeftCharsToExclude oder numRightCharsToExclude kombiniert werden.
  - numLeftCharsToExclude – (Typ: String, integer) Anzahl der links auszuschließenden Zeichen. Kann nicht mit matchPattern kombiniert werden, kann aber mit numRightCharsToExclude verwendet werden.
  - numRightCharsToExclude – (Typ: String, integer) Anzahl der rechts auszuschließenden Zeichen. Kann nicht mit matchPattern kombiniert werden, kann aber mit numRightCharsToExclude verwendet werden.

outputColumnName-Einstellungen

Siehe outputColumnName-Einstellungen

Erkennungsparameter für `classifyColumns()`

Diese Methode wird zum Erkennen von Entitäten in einem DynamicFrame verwendet. Gibt eine Zuordnung zurück, in der Spaltennamen die Schlüssel sind und die Liste der erkannten Entitätstypen die Werte bildet. Eine benutzerdefinierte Maskierung kann durchgeführt werden, nachdem dies im AWS Glue-Skript zurückgegeben wurde.


classifyColumns(frame: DynamicFrame, 
                entityTypesToDetect: Seq[String], 
                sampleFraction: Double = 0.1, 
                thresholdFraction: Double = 0.1,
                detectionSensitivity: String = "LOW")

Parameter:

frame – (Typ:DynamicFrame) Der Eingabe-DynamicFrame, der die zu verarbeitenden Daten enthält.
entityTypesToDetect – (Typ:Seq[String]) Liste der zu erkennenden Entitätstypen. Dabei kann es sich entweder um verwaltete Entitätstypen oder um benutzerdefinierte Entitätstypen handeln.
sampleFraction – (Typ:Double, Standard: 10 %) Der Bruchteil der Daten, die beim Scannen nach PII-Entitäten erfasst werden sollen.
thresholdFraction – (Typ:Double, Standard: 10 %): Der Bruchteil der Daten, bei dem die Bedingung erfüllt sein muss, damit eine Spalte als PII-Daten identifiziert werden kann.
detectionSensitivity – (Typ:String, Optionen: „LOW“ oder „HIGH“, Standard: „LOW“) Gibt die Empfindlichkeit des Erkennungsprozesses an. Gültige Optionen sind „LOW“ oder „HIGH“. Falls nicht angegeben, ist die Standardempfindlichkeit auf „LOW“ eingestellt.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Verwenden von Auftragslesezeichen

Verwaltete sensible Datentypen