Utilizzo del rilevamento di dati sensibili all'esterno di AWS Glue Studio - AWS Glue
Rilevamento del rilevamento di dati sensibili utilizzando i tipi di AWS Managed PIIRilevamento del rilevamento di dati sensibili mediante tipi PII AWS CustomEntityType Parametri di rilevamento per l'utilizzo di detect()Parametri di rilevamento per classifyColumns()

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Utilizzo del rilevamento di dati sensibili all'esterno di AWS Glue Studio

AWS Glue Studio consente di rilevare dati sensibili, tuttavia è possibile utilizzare la funzionalità Sensitive Data Detection anche al di fuori di AWS Glue Studio.

Per un elenco completo dei tipi di dati sensibili gestiti, consulta la pagina Managed Sensitive Data Types.

Rilevamento del rilevamento di dati sensibili utilizzando i tipi di AWS Managed PII

AWS Glue fornisce due API in un AWS Glue job ETL. Questi sono detect() e 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")

È possibile utilizzare l'detect()API per identificare i tipi di informazioni personali AWS gestite e i tipi di entità personalizzati. Una nuova colonna viene creata automaticamente con il risultato del rilevamento. L'API classifyColumns() restituisce una mappa in cui le chiavi sono i nomi delle colonne e i valori sono un elenco di tipi di entità rilevati. SampleFraction indica la frazione dei dati da campionare durante la scansione di ricerca delle entità PII, mentre ThresholdFraction indica la frazione dei dati che devono essere soddisfatti per identificare una colonna come dati PII.

Rilevamento a livello di riga

Nell'esempio, il processo sta eseguendo le seguenti azioni utilizzando le API detect() e classifyColumns():

  • legge i dati da un Amazon S3 bucket e li trasforma in un DynamicFrame

  • rilevamento di istanze di “e-mail” e “carta di credito” in dynamicFrame

  • restituzione di un dynamicFrame con valori originali più una colonna che include il risultato del rilevamento per ogni riga

  • scrivere il DynamicFrame restituito in un altro percorso Amazon S3 


  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()
    }
  }

Rilevamento a livello di riga con operazioni granulari

Nell'esempio, il processo sta eseguendo le seguenti azioni utilizzando le API detect():

  • leggere i dati da un bucket di Amazon S3 e trasformarli in un dynamicFrame

  • rilevamento dei tipi di dati sensibili per “USA_PTIN”, “ BANK_ACCOUNT”, “USA_SSN”, “USA_PASSPORT_NUMBER” e “PHONE_NUMBER” nel dynamicFrame

  • restituzione di un dynamicFrame con valori mascherati modificati più una colonna che include il risultato del rilevamento per ogni riga

  • scrittura del dynamicFrame restituito in un altro percorso di Amazon S3

A differenza dell'API detect() di cui sopra, questa utilizza operazioni granulari per rilevare i tipi di entità. Per ulteriori informazioni, consulta Parametri di rilevamento per l'utilizzo di 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()
  }
}

Rilevamento a livello di colonna

Nell'esempio, il processo sta eseguendo le seguenti azioni utilizzando le API classifyColumns():

  • leggere i dati da un bucket di Amazon S3 e trasformarli in un dynamicFrame

  • rilevamento di istanze di “e-mail” e “carta di credito” in dynamicFrame

  • imposta i parametri per campionare il 100% della colonna, contrassegna un'entità come rilevata se si trova nel 10% delle celle e ha una sensibilità "LOW"

  • restituisce una mappa in cui le chiavi sono i nomi delle colonne e i valori sono l'elenco dei tipi di entità rilevati

  • scrittura del dynamicFrame restituito in un altro percorso di Amazon S3 

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()
  }
}

Rilevamento del rilevamento di dati sensibili mediante tipi PII AWS CustomEntityType

È possibile definire entità personalizzate tramite AWS Studio. Tuttavia, per utilizzare questa funzionalità fuori da AWS Studio, è necessario prima definire i tipi di entità personalizzati e quindi aggiungere i tipi di entità personalizzati definiti all'elenco dientityTypesToDetect.

Se hai tipi di dati sensibili specifici nei tuoi dati (come “ID dipendente”), puoi creare entità personalizzate chiamando l'API CreateCustomEntityType(). L'esempio seguente definisce il tipo di entità personalizzato 'EMPLOYEE_ID' per l'API CreateCustomEntityType() con i parametri della richiesta: 


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

Quindi, modifica il lavoro per utilizzare il nuovo tipo di dati sensibili personalizzato aggiungendo il tipo di entità personalizzato (EMPLOYEE_ID) all'API EntityDetector(): 


  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()
    }
  }
Nota

Se un tipo di dati sensibili personalizzato è definito con lo stesso nome di un tipo di entità gestita esistente, il tipo di dati sensibili personalizzato avrà la precedenza e sovrascriverà la logica del tipo di entità gestita.

Parametri di rilevamento per l'utilizzo di detect()

Questo metodo viene utilizzato per rilevare le entità in a DynamicFrame. Ne restituisce una nuova DataFrame con valori originali e una colonna aggiuntiva con outputColumnName metadati di rilevamento PII. Il mascheramento personalizzato può essere eseguito dopo che questo DynamicFrame è stato restituito all'interno dello AWS Glue script, oppure è possibile utilizzare l'API detect () con azioni granulari. 

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

Parametri:

  • frame — (type:DynamicFrame) L'input DynamicFrame contenente i dati da elaborare.

  • entityTypesToRileva — (tipo:[Seq[String]) Elenco dei tipi di entità da rilevare. Possono essere tipi di entità gestiti o personalizzati.

  • outputColumnName— (tipo:String, default: "DetectedEntities«) Il nome della colonna in cui verranno memorizzate le entità rilevate. Se non viene fornito, il nome di colonna predefinito è "DetectedEntities».

  • detectionSensivity — (tipo: String, opzioni: "BASSA" oppure "ELEVATA", impostazione predefinita: "BASSA") specifica la distinzione del processo di rilevamento. Le opzioni valide sono "BASSA" oppure "ELEVATA". Se non viene fornita, la distinzione predefinita è impostata su "LOW".

Impostazioni di outputColumnName:

Il nome della colonna in cui verranno memorizzate le entità rilevate. Se non viene fornito, il nome di colonna predefinito è "DetectedEntities». Per ogni riga della colonna di output, la colonna supplementare include una mappa del nome della colonna ai metadati dell'entità rilevata, con le seguenti coppie chiave-valore:

  • entityType: il tipo di entità rilevato.

  • start — la posizione iniziale dell'entità rilevata nei dati originali.

  • end — la posizione finale dell'entità rilevata nei dati originali.

  • actionUsed — l'azione eseguita sull'entità rilevata (ad esempio, "DETECT," "REDACT," "PARTIAL_REDACT," "SHA256_HASH").

Esempio: 

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

Parametri di rilevamento per detect() con operazioni granulari

Questo metodo viene utilizzato per rilevare le entità in un DynamicFrame utilizzando parametri specificati. Ne restituisce una nuova DataFrame con valori originali sostituiti con dati sensibili mascherati e una colonna aggiuntiva con metadati outputColumnName di rilevamento PII. 

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

Parametri:

  • frame — (type:DynamicFrame): L'input DynamicFrame contenente i dati da elaborare.

  • detectionParameters — (tipo: JsonOptions): opzioni JSON che specificano i parametri per il processo di rilevamento.

  • outputColumnName— (type:String, default: "DetectedEntities«): Il nome della colonna in cui verranno memorizzate le entità rilevate. Se non viene fornito, il nome di colonna predefinito è "DetectedEntities».

  • detectionSensivity — (tipo: String, opzioni: "BASSA" oppure "ELEVATA", impostazione predefinita: "BASSA"): specifica la distinzione del processo di rilevamento. Le opzioni valide sono "BASSA" oppure "ELEVATA". Se non viene fornita, la distinzione predefinita è impostata su "LOW".

Impostazioni di detectionParameters

Se non è inclusa alcuna impostazione, verranno utilizzati i valori predefiniti.

  • action — (tipo: String, opzioni: "DETECT", "REDACT", "PARTIAL_REDACT", "SHA256_HASH") specifica l'operazione da eseguire sull'entità. Obbligatorio. Le operazioni che eseguono il mascheramento (ad eccezione di "DETECT") possono eseguire solo un'operazione per colonna. Si tratta di una misura preventiva per mascherare le entità unite.

  • sourceColumns — (tipo: List[String], impostazione predefinita: ["*"]) elenco dei nomi delle colonne di origine su cui eseguire il rilevamento dell'entità. L'impostazione predefinita è ["*"], se non presente. Viene generato IllegalArgumentException se viene utilizzato un nome di colonna non valido.

  • sourceColumnsToEscludi — (tipo:List[String]) Elenco dei nomi delle colonne di origine su cui eseguire il rilevamento dell'entità. Usa sourceColumns o sourceColumnsToExclude. Viene generato IllegalArgumentException se viene utilizzato un nome di colonna non valido.

  • actionOptions — opzioni aggiuntive basate sull'operazione specificata:

    • Per "DETECT" e "SHA256_HASH", non sono consentite opzioni.

    • Per "REDACT":

      • redactText — (tipo: String, impostazione predefinita: "*****") testo per sostituire l'entità rilevata.

    • Per "PARTIAL_REDACT":

      • redactChar — (tipo: String, impostazione predefinita: "*") carattere per sostituire ogni carattere rilevato nell'entità.

      • matchPattern — (tipo: String) modello Regex per la redazione parziale. Non può essere combinato con numLeftChars ToExclude onumRightCharsToExclude.

      • numLeftCharsToExclude— (tipo:String, integer) Numero di caratteri a sinistra da escludere. Non può essere unito a matchPattern, ma può essere utilizzato con numRightCharsToExclude.

      • numRightCharsToExclude— (digitare:String, integer) Numero di caratteri a destra da escludere. Non può essere unito a matchPattern, ma può essere utilizzato con numRightCharsToExclude.

Impostazioni di outputColumnName

Vedi outputColumnName le impostazioni

Parametri di rilevamento per classifyColumns()

Questo metodo viene utilizzato per rilevare le entità in a DynamicFrame. Restituisce una mappa in cui le chiavi sono i nomi delle colonne e i valori sono l'elenco dei tipi di entità rilevati. Il mascheramento personalizzato può essere eseguito dopo che questo è stato restituito all'interno dello script AWS Glue. 

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

Parametri:

  • frame — (tipo:DynamicFrame) L'input DynamicFrame contenente i dati da elaborare.

  • entityTypesToRileva — (tipo:Seq[String]) Elenco dei tipi di entità da rilevare. Possono essere tipi di entità gestiti o personalizzati.

  • sampleFraction — (tipo: Double, impostazione predefinita: 10%) la frazione dei dati da campionare durante la scansione di entità PII.

  • thresholdFraction — (tipo: Double, impostazione predefinita: 10%): la frazione dei dati che devono essere soddisfatti per identificare una colonna come dati PII.

  • detectionSensivity — (tipo: String, opzioni: "BASSA" oppure "ELEVATA", impostazione predefinita: "BASSA") specifica la distinzione del processo di rilevamento. Le opzioni valide sono "BASSA" oppure "ELEVATA". Se non viene fornita, la distinzione predefinita è impostata su "LOW".