Détection de données sensibles Détection à l'aide de types d'informations personnelles AWS gérés Détection de données sensibles Détection à l'aide de AWS CustomEntityType types d'informations personnelles 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 de données sensibles Détection à l'aide de types d'informations personnelles AWS gérés

AWS Glue fournit deux API dans une tâche AWS Glue ETL. 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 l'detect()API pour identifier les types d' AWS informations personnelles gérées et les types d'entités personnalisés. Une nouvelle colonne est automatiquement créée avec le résultat de la détection. L'API classifyColumns() renvoie 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. SampleFraction indique la fraction des données à échantillonner lors de la recherche d'entités PII, tandis que ThresholdFraction indique la fraction des données qui doit être satisfaite pour qu'une colonne soit identifiée comme données PII.

Détection au niveau des lignes

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

lire les données d'un Amazon S3 bucket et les transformer en DynamicFrame
détection des instances « Email » et « Credit Card » dans le DynamicFrame
renvoi d'un DynamicFrame avec les valeurs d'origine plus une colonne qui englobe le résultat de la détection pour chaque ligne
écrire le DynamicFrame renvoyé 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.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 des API detect() :

lecture des données à partir d'un compartiment Amazon S3 et transformation de ces données en DynamicFrame
détection des types de données sensibles pour « USA_PTIN », « BANK_ACCOUNT », « USA_SSN », « USA_PASSPORT_NUMBER » et « PHONE_NUMBER » dans le DynamicFrame
renvoi d'un DynamicFrame avec les valeurs modifiées masquées plus une colonne qui englobe le résultat de la détection pour chaque ligne
écriture du DynamicFrame renvoyé dans un autre chemin Amazon S3

Contrairement à l'API detect() ci-dessus, celle-ci utilise des actions détaillées que les types d'entités détectent. Pour plus d’informations, consultez 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 des API classifyColumns() :

lecture des données à partir d'un compartiment Amazon S3 et transformation de ces données en DynamicFrame
détection des instances « Email » et « Credit Card » dans le 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 a une sensibilité « FAIBLE »
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
écriture du DynamicFrame renvoyé 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 de données sensibles Détection à l'aide de AWS CustomEntityType types d'informations personnelles

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 l'ID d'employé), vous pouvez créer des entités personnalisées en appelant l'API CreateCustomEntityType(). L'exemple suivant définit le type d'entité personnalisé « EMPLOYEE_ID » pour l'API CreateCustomEntityType() 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) à l'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()
    }
  }

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. Il renvoie une nouvelle colonne DataFrame contenant les valeurs d'origine et une colonne supplémentaire outputColumnName contenant des métadonnées de détection des informations personnelles. Un masquage personnalisé peut être effectué une fois celui-ci DynamicFrame renvoyé dans le AWS Glue script, ou l'API detect () avec des actions détaillées peut être utilisée à 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 : « FAIBLE » ou « ÉLEVÉ », par défaut : « FAIBLE ») spécifie la sensibilité du processus de détection. Les options valides sont « FAIBLE » ou « ÉLEVÉ ». Si ce n'est pas le cas, la sensibilité par défaut est réglée sur « FAIBLE ».

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 : le 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 : action exécutée sur l'entité détectée (par exemple, « DÉTECTER », « RÉDIGER », « 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 contenant des outputColumnName métadonnées de détection des informations personnelles.


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) : options JSON 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 : « FAIBLE » ou « ÉLEVÉ », par défaut : « FAIBLE ») : spécifie la sensibilité du processus de détection. Les options valides sont « FAIBLE » ou « ÉLEVÉ ». Si ce n'est pas le cas, la sensibilité par défaut est réglée sur « FAIBLE ».

Paramètres detectionParameters

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

action — (type :String, options : « DÉTECTER », « RÉDIGER », « PARTIAL_REDACT », « SHA256_HASH ») spécifie l'action à effectuer sur l'entité. Obligatoire. Notez que les actions qui effectuent un masquage (toutes sauf « DÉTECTER ») 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 source 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 « DÉTECTER » et « SHA256_HASH », aucune option n'est autorisée.
- Pour « RÉDIGER » :
  - redactText — (type :String, par défaut : « ***** ») texte destiné à 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é avec matchPattern, mais peut être utilisé avec numRightCharsToExclude.
  - numRightCharsToExclude— (type :String, integer) Nombre de bons caractères à exclure. Ne peut pas être combiné avec matchPattern, mais peut être utilisé avec numRightCharsToExclude.

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 script AWS Glue.


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 %) la fraction des données à échantillonner lors de la recherche d'entités PII.
thresholdFraction — (type :Double, par défaut : 10 %) :la fraction des données qui doit être satisfaite pour qu'une colonne soit identifiée comme données PII.
detectionSensitivity — (type : String, options : « FAIBLE » ou « ÉLEVÉ », par défaut : « FAIBLE ») spécifie la sensibilité du processus de détection. Les options valides sont « FAIBLE » ou « ÉLEVÉ ». Si ce n'est pas le cas, la sensibilité par défaut est réglée sur « FAIBLE ».

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