Détection des données sensibles Détection à l'aide PII de types AWS gérés Détection des données sensibles Détection à l'aide AWS CustomEntityType PII de types Paramètres de détection pour l'utilisation de detect()Paramètres de détection pour classifyColumns()

Utilisation de la détection des données sensibles en dehors de AWS Glue Studio

AWS Glue Studio vous permet de détecter les données sensibles, mais vous pouvez également utiliser la fonctionnalité de détection des données sensibles en dehors de AWS Glue Studio.

Pour afficher la liste complète des types de données sensibles gérés, consultez Managed data types.

Détection des données sensibles Détection à l'aide PII de types AWS gérés

AWS Glue en fournit deux APIs dans un AWS Glue ETL job. detect() et 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")

Vous pouvez utiliser le detect() API pour identifier les PII types AWS gérés et les types d'entités personnalisés. Une nouvelle colonne est automatiquement créée avec le résultat de la détection. classifyColumns()APIRenvoie une carte où les clés sont les noms de colonnes et les valeurs sont la liste des types d'entités détectés. SampleFractionindique la fraction des données à échantillonner lors de la recherche d'PIIentités, tandis qu'ThresholdFractionindique la fraction de données qui doit être satisfaite pour qu'une colonne soit identifiée comme étant PII des données.

Détection au niveau des lignes

Dans l'exemple, la tâche exécute les actions suivantes à l'aide des touches detect() et classifyColumns() APIs :

lire les données d'un Amazon S3 bucket et les transformer en dynamicFrame
détection des cas de « courrier électronique » et de « carte de crédit » dans dynamicFrame
renvoyant a dynamicFrame avec les valeurs d'origine plus une colonne qui englobe le résultat de détection pour chaque ligne
écrire le retour dynamicFrame dans un autre Amazon S3 chemin



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

Détection au niveau des lignes avec actions détaillées

Dans l'exemple, la tâche exécute les actions suivantes à l'aide de detect() APIs :

lire les données d'un compartiment Amazon S3 et les transformer en dynamicFrame
détection des types de données sensibles pour « USA BANK _ PTIN ACCOUNT », « USA _ SSN », « _ », « USA PASSPORT _ _ NUMBER » et « PHONE _ NUMBER » dans dynamicFrame
renvoyant a dynamicFrame avec des valeurs masquées modifiées plus une colonne qui englobe le résultat de détection pour chaque ligne
écrire le retour dynamicFrame dans un autre chemin Amazon S3

Contrairement à ce qui précède detect()API, cela utilise des actions précises que les types d'entités doivent détecter. Pour de plus amples informations, veuillez consulter Paramètres de détection pour l'utilisation de 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()
  }
}

Détection au niveau des colonnes

Dans l'exemple, la tâche exécute les actions suivantes à l'aide de classifyColumns() APIs :

lire les données d'un compartiment Amazon S3 et les transformer en dynamicFrame
détection des cas de « courrier électronique » et de « carte de crédit » dans dynamicFrame
définir les paramètres pour échantillonner 100 % de la colonne, marquer une entité comme détectée si elle se trouve dans 10 % des cellules et avoir une sensibilité « LOW »
renvoie une carte où les clés sont les noms de colonnes et les valeurs sont une liste des types d'entités détectés
écrire le retour dynamicFrame dans un autre chemin 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()
  }
}

Détection des données sensibles Détection à l'aide AWS CustomEntityType PII de types

Vous pouvez définir des entités personnalisées via AWS Studio. Toutefois, pour utiliser cette fonctionnalité en dehors de AWS Studio, vous devez d'abord définir les types d'entités personnalisés, puis ajouter les types d'entités personnalisés définis à la liste desentityTypesToDetect.

Si vos données contiennent des types de données sensibles spécifiques (tels que « ID d'employé »), vous pouvez créer des entités personnalisées en appelant le. CreateCustomEntityType() API L'exemple suivant définit le type d'entité personnalisé « EMPLOYEE _ID » CreateCustomEntityType() API avec les paramètres de demande :



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

Modifiez ensuite la tâche pour utiliser le nouveau type de données sensibles personnalisé en ajoutant le type d'entité personnalisé (EMPLOYEE_ID) au EntityDetector() API :



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

Note

Si un type de données sensibles personnalisé est défini avec le même nom qu'un type d'entité géré existant, le type de données sensibles personnalisé prévaut et remplace la logique du type d'entité géré.

Paramètres de détection pour l'utilisation de `detect()`

Cette méthode est utilisée pour détecter des entités dans un DynamicFrame. Elle renvoie une nouvelle colonne DataFrame avec les valeurs d'origine et une colonne supplémentaire outputColumnName contenant des métadonnées PII de détection. Un masquage personnalisé peut être effectué une fois DynamicFrame celui-ci renvoyé dans le AWS Glue un script, ou le detect () avec des actions précises API peuvent être utilisés à la place.


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

Paramètres :

frame — (type :DynamicFrame) L'entrée DynamicFrame contenant les données à traiter.
entityTypesToDétecter — (type :[Seq[String]) Liste des types d'entités à détecter. Il peut s'agir de types d'entités gérés ou de types d'entités personnalisés.
outputColumnName— (type :String, par défaut : "DetectedEntities«) Le nom de la colonne dans laquelle les entités détectées seront stockées. S'il n'est pas fourni, le nom de colonne par défaut est « DetectedEntities ».
detectionSensitivity— (type :String, options : "LOW" ou "HIGH«, par défaut :" LOW «) Spécifie la sensibilité du processus de détection. Les options valides sont « LOW » ou « HIGH ». Si ce n'est pas le cas, la sensibilité par défaut est définie sur « LOW ».

Paramètres outputColumnName :

Le nom de la colonne dans laquelle les entités détectées seront stockées. S'il n'est pas fourni, le nom de colonne par défaut est « DetectedEntities ». Pour chaque ligne de la colonne de sortie, la colonne supplémentaire inclut un mappage du nom de la colonne avec les métadonnées de l'entité détectée avec les paires clé-valeur suivantes :

entityType— Type d'entité détecté.
début : la position de départ de l'entité détectée dans les données d'origine.
fin : la position de fin de l'entité détectée dans les données d'origine.
actionUsed— L'action effectuée sur l'entité détectée (par exempleDETECT, «REDACT, » », » PARTIAL _REDACT, » SHA256 _ HASH «).

Exemple :


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

Paramètres de détection pour detect() avec des actions détaillées

Cette méthode est utilisée pour détecter des entités dans un à DynamicFrame l'aide de paramètres spécifiés. Il renvoie une nouvelle colonne DataFrame avec les valeurs d'origine remplacées par des données sensibles masquées et une colonne supplémentaire outputColumnName contenant des métadonnées PII de détection.


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

Paramètres :

frame — (type :DynamicFrame) : entrée DynamicFrame contenant les données à traiter.
detectionParameters— (type :JsonOptions) : JSON options spécifiant les paramètres du processus de détection.
outputColumnName— (type :String, par défaut : "DetectedEntities«) : nom de la colonne dans laquelle les entités détectées seront stockées. S'il n'est pas fourni, le nom de colonne par défaut est « DetectedEntities ».
detectionSensitivity— (type :String, options : "LOW" ou "HIGH«, par défaut :" LOW «) : Spécifie la sensibilité du processus de détection. Les options valides sont « LOW » ou « HIGH ». Si ce n'est pas le cas, la sensibilité par défaut est définie sur « LOW ».

Paramètres detectionParameters

Si aucun paramètre n'est inclus, les valeurs par défaut seront utilisées.

action — (type :String, options : "DETECT«," REDACT «," PARTIAL _ REDACT «," SHA256 _ HASH «) Spécifie l'action à effectuer sur l'entité. Obligatoire. Notez que les actions qui effectuent un masquage (toutes sauf DETECT « ») ne peuvent effectuer qu'une seule action par colonne. Il s'agit d'une mesure préventive pour masquer les entités fusionnées.
sourceColumns— (type :List[String], par défaut : [« * »]) Liste des noms de colonnes sources sur lesquels effectuer la détection pour l'entité. La valeur par défaut est [« * »] si elle n'est pas précisée. Lève une IllegalArgumentException si un nom de colonne non valide est utilisé.
sourceColumnsToExclure — (type :List[String]) Liste des noms des colonnes sources sur lesquelles effectuer la détection pour l'entité. Utilisez sourceColumns ou sourceColumnsToExclude. Lève une IllegalArgumentException si un nom de colonne non valide est utilisé.
actionOptions— Options supplémentaires basées sur l'action spécifiée :
- Pour « DETECT » et HASH « SHA256 _ », aucune option n'est autorisée.
- Pour REDACT « » :
  - redactText— (type :String, par défaut : « ***** ») Texte pour remplacer l'entité détectée.
- Pour « PARTIAL _ REDACT » :
  - redactChar— (type :String, par défaut : « * ») Caractère pour remplacer chaque caractère détecté dans l'entité.
  - matchPattern— (type :String) Modèle Regex pour la rédaction partielle. Ne peut pas être combiné avec numLeftChars ToExclude ounumRightCharsToExclude.
  - numLeftCharsToExclude— (type :String, integer) Nombre de caractères gauches à exclure. Ne peut pas être combiné avecmatchPattern, mais peut être utilisé avecnumRightCharsToExclude.
  - numRightCharsToExclude— (type :String, integer) Nombre de bons caractères à exclure. Ne peut pas être combiné avecmatchPattern, mais peut être utilisé avecnumRightCharsToExclude.

Paramètres outputColumnName

Voir les outputColumnName paramètres

Paramètres de détection pour `classifyColumns()`

Cette méthode est utilisée pour détecter des entités dans un DynamicFrame. Il renvoie une carte où les clés sont les noms de colonnes et les valeurs sont une liste des types d'entités détectés. Un masquage personnalisé peut être effectué une fois celui-ci renvoyé dans le AWS Glue script.


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

Paramètres :

frame — (type :DynamicFrame) L'entrée DynamicFrame contenant les données à traiter.
entityTypesToDétecter — (type :Seq[String]) Liste des types d'entités à détecter. Il peut s'agir de types d'entités gérés ou de types d'entités personnalisés.
sampleFraction— (type :Double, par défaut : 10 %) Fraction des données à échantillonner lors de la recherche d'PIIentités.
thresholdFraction— (type :Double, par défaut : 10 %) : fraction des données qui doit être remplie pour qu'une colonne soit identifiée comme une PII donnée.
detectionSensitivity— (type :String, options : "LOW" ou "HIGH«, par défaut :" LOW «) Spécifie la sensibilité du processus de détection. Les options valides sont « LOW » ou « HIGH ». Si ce n'est pas le cas, la sensibilité par défaut est définie sur « LOW ».

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Utilisation des marque-pages de tâche

Types de données sensibles gérés