Utilisation des API de détection de données sensibles avec des actions détaillées

Utilisation d'une détection détaillée des données sensibles

Note

Les actions détaillées ne sont disponibles que dans les versions AWS Glue 3.0 et 4.0. Cela inclut l'expérience AWS Glue Studio. Les modifications persistantes du journal d'audit ne sont pas non plus disponibles dans la version 2.0.

Tous les tâches visuelles des versions AWS Glue Studio 3.0 et 4.0 comporteront un script créé qui utilise automatiquement des API d'actions détaillées.

La transformation Détecter les données sensibles permet de détecter, masquer ou supprimer des entités que vous définissez ou sont prédéfinies par AWS Glue. Les actions détaillées vous permettent en outre d'appliquer une action spécifique par entité. Les avantages supplémentaires incluent :

Performances améliorées, car les actions sont appliquées dès que des données sont détectées.
La possibilité d'inclure ou exclure des colonnes spécifiques.
La possibilité d'utiliser un masquage partiel. Cela vous permet de masquer partiellement les entités de données sensibles détectées, plutôt que de masquer la chaîne entière. Les deux paramètres simples avec décalages et regex sont pris en charge.

Vous trouverez ci-dessous des extraits de code des API de détection de données sensibles et des actions détaillées utilisées dans les exemples de tâches référencés dans la section suivante.

API de détection : les actions détaillées utilisent le nouveau paramètre detectionParameters :


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

Utilisation des API de détection de données sensibles avec des actions détaillées

Les API de détection de données sensibles utilisant la détection analysent les données fournies, déterminent si les lignes ou les colonnes sont des types d'entités de données sensibles et exécutent les actions spécifiées par l'utilisateur pour chaque type d'entité.

Utilisation de l'API de détection avec des actions détaillées

Utilisez l'API de détection et spécifiez le outputColumnName et detectionParameters.



    object GlueApp {
      def main(sysArgs: Array[String]) {
      
        val spark: SparkContext = new SparkContext()
        val glueContext: GlueContext = new GlueContext(spark)
        
        // @params: [JOB_NAME]
        val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
        Job.init(args("JOB_NAME"), glueContext, args.asJava)
        
        // Script generated for node S3 bucket. Creates DataFrame from data stored in S3.
        val S3bucket_node1 = glueContext.getSourceWithFormat(formatOptions=JsonOptions("""{"quoteChar": "\"", "withHeader": true, "separator": ",", "optimizePerformance": false}"""), connectionType="s3", format="csv", options=JsonOptions("""{"paths": ["s3://189657479688-ddevansh-pii-test-bucket/tiny_pii.csv"], "recurse": true}"""), transformationContext="S3bucket_node1").getDynamicFrame()
     
        // Script generated for node Detect Sensitive Data. Will run detect API for the DataFrame
        // detectionParameter contains information on which EntityType are being detected
        // and what actions are being applied to them when detected. 
        val DetectSensitiveData_node2 = EntityDetector.detect(
            frame = S3bucket_node1, 
            detectionParameters = JsonOptions(
             """
                {
                    "PHONE_NUMBER": [
                        {
                            "action": "PARTIAL_REDACT",
                            "actionOptions": {
                                "numLeftCharsToExclude": "3",
                                "numRightCharsToExclude": "4",
                                "redactChar": "#"
                            },
                            "sourceColumnsToExclude": [ "Passport No", "DL NO#" ]
                        }
                    ],
                    "USA_PASSPORT_NUMBER": [
                        {
                            "action": "SHA256_HASH",
                            "sourceColumns": [ "Passport No" ]
                        }
                    ],
                    "USA_DRIVING_LICENSE": [
                        {
                            "action": "REDACT",
                            "actionOptions": {
                                "redactText": "USA_DL"
                            },
                            "sourceColumns": [ "DL NO#" ]
                        }
                    ]
                    
                }
            """
            ),
            outputColumnName = "DetectedEntities"
        )
     
        // Script generated for node S3 bucket. Store Results of detect to S3 location
        val S3bucket_node3 = glueContext.getSinkWithFormat(connectionType="s3", options=JsonOptions("""{"path": "s3://189657479688-ddevansh-pii-test-bucket/test-output/", "partitionKeys": []}"""), transformationContext="S3bucket_node3", format="json").writeDynamicFrame(DetectSensitiveData_node2)
     
        Job.commit()
      }

Le script ci-dessus créera un cadre de données à partir d'un emplacement dans Amazon S3, puis exécutera l'API detect. Étant donné que l'API detect exige que le champ detectionParameters (une carte du nom de l'entité avec une liste de tous les paramètres d'action à utiliser pour cette entité) soit représenté par l'objet JsonOptions d'AWS Glue, cela nous permettra également d'étendre les fonctionnalités de l'API.

Pour chaque action spécifiée par entité, etrez une liste de tous les noms de colonnes auxquels appliquer la combinaison entité/action. Cela vous permet de personnaliser les entités à détecter pour chaque colonne de votre jeu de données et d'ignorer les entités dont vous savez qu'elles ne figurent pas dans une colonne spécifique. Cela permet également à vos tâches d'être plus performantes en n'effectuant pas d'appels de détection inutiles à ces entités et en vous permettant d'effectuer des actions uniques pour chaque combinaison de colonnes et d'entités.

En examinant de plus près les detectionParameters, il existe trois types d'entités dans l'exemple de tâche. Il s'agit des Phone Number, USA_PASSPORT_NUMBER, et USA_DRIVING_LICENSE. Pour chacun de ces types d'entités, AWS Glue exécutera différentes actions, à savoir PARTIAL_REDACT, SHA256_HASH, REDACT et DETECT. Chacun des types d'entités a également des sourceColumns auxquelles s’appliquer et/ou des sourceColumnsToExclude si elles sont détectées.

Note

Une seule action de modification sur place (PARTIAL_REDACT, SHA256_HASH ou REDACT) peut être utilisée par colonne, mais l'action DETECT peut être utilisée avec n'importe laquelle de ces actions.

La disposition du champ detectionParameters est la suivante :



    ENTITY_NAME -> List[Actions]
    {
    	"ENTITY_NAME": [{
    		Action, // required
    		ColumnSpecs,
    		ActionOptionsMap
        }],
        "ENTITY_NAME2": [{
    		...
        }]
    }

Les types d'actions et actionOptions sont répertoriés ci-dessous :


DETECT
{
    # Required
    "action": "DETECT",
    # Optional, depending on action chosen
    "actionOptions": {
        // There are no actionOptions for DETECT 
    },
    # 1 of below required, both can also used
    "sourceColumns": [
        "COL_1", "COL_2", ..., "COL_N"
    ],
    "sourceColumnsToExclude": [
        "COL_5"
    ]
}

SHA256_HASH
{
    # Required
    "action": "SHA256_HASH",
    # Required or optional, depending on action chosen
    "actionOptions": {
        // There are no actionOptions for SHA256_HASH
    },
    
    # 1 of below required, both can also used
    "sourceColumns": [
        "COL_1", "COL_2", ..., "COL_N"
    ],
    "sourceColumnsToExclude": [
        "COL_5"
    ]
}

REDACT
{
    # Required
    "action": "REDACT",
    # Required or optional, depending on action chosen
    "actionOptions": {
        // The text that is being replaced
        "redactText": "USA_DL"
    },
    
    # 1 of below required, both can also used
    "sourceColumns": [
        "COL_1", "COL_2", ..., "COL_N"
    ],
    "sourceColumnsToExclude": [
        "COL_5"
    ]
}

PARTIAL_REDACT
{
    # Required
    "action": "PARTIAL_REDACT",
    # Required or optional, depending on action chosen
    "actionOptions": {
        // number of characters to not redact from the left side 
        "numLeftCharsToExclude": "3",
        // number of characters to not redact from the right side
        "numRightCharsToExclude": "4",
        // the partial redact will be made with this redacted character  
        "redactChar": "#",
        // regex pattern for partial redaction
        "matchPattern": "[0-9]"
    },
    
    # 1 of below required, both can also used
    "sourceColumns": [
        "COL_1", "COL_2", ..., "COL_N"
    ],
    "sourceColumnsToExclude": [
        "COL_5"
    ]
}

Une fois le script exécuté, les résultats sont envoyés à l'emplacement Amazon S3 indiqué. Vous pouvez afficher vos données dans Amazon S3, mais les types d'entités sélectionnés sont sensibilisés en fonction de l'action sélectionnée. Dans ce cas, nous aurions une ligne qui ressemblerait à ceci :


{
    "Name": "Colby Schuster",
    "Address": "39041 Antonietta Vista, South Rodgerside, Nebraska 24151",
    "Car Owned": "Fiat",
    "Email": "Kitty46@gmail.com",
    "Company": "O'Reilly Group",
    "Job Title": "Dynamic Functionality Facilitator",
    "ITIN": "991-22-2906",
    "Username": "Cassandre.Kub43",
    "SSN": "914-22-2906",
    "DOB": "2020-08-27",
    "Phone Number": "1-2#######1718",
    "Bank Account No": "69741187",
    "Credit Card Number": "6441-6289-6867-2162-2711",
    "Passport No": "94f311e93a623c72ccb6fc46cf5f5b0265ccb42c517498a0f27fd4c43b47111e",
    "DL NO#": "USA_DL"
}

Dans le script ci-dessus, le Phone Number a été partiellement expurgé avec #. Le Passport No a été transformé en un hachage SHA256. Le DL NO# a été détecté comme un numéro de permis de conduire américain et a été expurgé en « USA_DL », comme indiqué dans les detectionParameters.

Note

L'API classifyColumns n'est pas disponible pour une utilisation avec des actions détaillées en raison de la nature de l'API. Cette API effectue un échantillonnage de colonnes (ajustable par l'utilisateur mais possède des valeurs par défaut) pour effectuer la détection plus rapidement. Pour cette raison, les actions détaillées nécessitent une itération sur chaque valeur.

Journal d'audit permanent

Une nouvelle fonctionnalité introduite avec des actions détaillées (mais également disponible lors de l'utilisation des API normales) est la présence d'un journal d'audit permanent. Actuellement, l'exécution de l'API de détection ajoute un paramètre de colonne supplémentaire (par défaut DetectedEntities mais personnalisable via le outputColumnName) avec les métadonnées de détection des informations personnelles identifiables. Cela possède désormais une clé de métadonnées « actionUsed », qui est l'une des valeurs DETECT, PARTIAL_REDACT, SHA256_HASH, REDACT.


"DetectedEntities": {
    "Credit Card Number": [
        {
            "entityType": "CREDIT_CARD",
            "actionUsed": "DETECT",
            "start": 0,
            "end": 19
        }
    ],
    "Phone Number": [
        {
            "entityType": "PHONE_NUMBER",
            "actionUsed": "REDACT",
            "start": 0,
            "end": 14
        }
    ]
}

Même les clients utilisant des API sans actions détaillées, telles que detect(entityTypesToDetect, outputColumnName), verront ce journal d'audit permanent apparaître dans la trame de données qui en résulte.

Les clients utilisant des API avec d'actions détaillées verront toutes les actions, qu'elles soient expurgées ou non. Exemple :


+---------------------+----------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Credit Card Number  |  Phone Number  |                                                                                            DetectedEntities                                                                                             |
+---------------------+----------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| 622126741306XXXX    | +12#####7890   | {"Credit Card Number":[{"entityType":"CREDIT_CARD","actionUsed":"PARTIAL_REDACT","start":0,"end":16}],"Phone Number":[{"entityType":"PHONE_NUMBER","actionUsed":"PARTIAL_REDACT","start":0,"end":12}]}} |
| 6221 2674 1306 XXXX | +12#######7890 | {"Credit Card Number":[{"entityType":"CREDIT_CARD","actionUsed":"PARTIAL_REDACT","start":0,"end":19}],"Phone Number":[{"entityType":"PHONE_NUMBER","actionUsed":"PARTIAL_REDACT","start":0,"end":14}]}} |
| 6221-2674-1306-XXXX | 22#######7890  | {"Credit Card Number":[{"entityType":"CREDIT_CARD","actionUsed":"PARTIAL_REDACT","start":0,"end":19}],"Phone Number":[{"entityType":"PHONE_NUMBER","actionUsed":"PARTIAL_REDACT","start":0,"end":14}]}} |
+---------------------+----------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

Si vous ne souhaitez pas voir la colonne DetectedEntities, vous pouvez simplement supprimer la colonne supplémentaire dans un script personnalisé.

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

Types de données sensibles gérés

API Visual Job AWS Glue