# Usar detecção de dados confidenciais fora do AWS Glue Studio O AWS Glue Studio permite que você detecte dados confidenciais, mas também é possível usar a funcionalidade de detecção de dados confidenciais fora do AWS Glue Studio. Para obter uma lista completa dos tipos de dados confidenciais gerenciados, consulte [Managed data types](https://docs.aws.amazon.com/glue/latest/dg/sensitive-data-managed-data-types.html). ## Detectar dados confidenciais usando os tipos de PII gerenciados pela AWS O AWS Glue fornece duas APIs em um trabalho de ETL do AWS Glue. Essas APIs são `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") ``` Você pode usar a API `detect()` para identificar os tipos de PII gerenciados pela AWS e os tipos de entidades personalizadas. Uma nova coluna é criada automaticamente com o resultado da detecção. A API `classifyColumns()` retorna um mapa em que as chaves são nomes de colunas e os valores são uma lista dos tipos de entidades detectados. `SampleFraction` indica a fração dos dados que deve ser amostrada ao escanear entidades de PII, enquanto `ThresholdFraction` indica a fração de dados que deve ser atendida para que uma coluna seja identificada como dados de PII. ### Detecção em nível de linha No exemplo, o trabalho está realizando as seguintes ações usando as APIs `classifyColumns()` e `detect()`: + ler os dados de um bucket do Amazon S3 e transformá-los em um dynamicFrame + detectar instâncias de "e-mail" e "cartão de crédito" no dynamicFrame + retornar um dynamicFrame com os valores originais mais uma coluna que inclui o resultado da detecção para cada linha + gravar o dynamicFrame retornado em outro caminho do 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() } } ``` ### Detecção em nível de linha com ações refinadas No exemplo, o trabalho está realizando as seguintes ações usando as APIs `detect()`: + lendo dados de um bucket do Amazon S3 e transformando-os em um dynamicFrame; + detectando tipos de dados confidenciais para “USA\$1PTIN”, “BANK\$1ACCOUNT”, “USA\$1SSN”, “USA\$1PASSPORT\$1NUMBER” e “PHONE\$1NUMBER” no DynamicFrame; + retornando um dynamicFrame com os valores mascarados modificados mais uma coluna que inclui o resultado da detecção para cada linha; + gravando o dynamicFrame retornado em outro caminho do Amazon S3 Em contraste com a API `detect()` acima, isso usa ações refinadas para detectar tipos de entidades. Para obter mais informações, consulte [Parâmetros de detecção para uso de `detect()`](#sensitive-data-detect-parameters-fine-grained-actions). ``` 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() } } ``` ### Detecção em nível de coluna No exemplo, o trabalho está realizando as seguintes ações usando as APIs `classifyColumns()`: + lendo dados de um bucket do Amazon S3 e transformando-os em um dynamicFrame; + detectando instâncias de "Email" e "Credit Card" no dynamicFrame; + definindo parâmetros para amostrar 100% da coluna e marcar uma entidade como detectada se ela estiver em 10% das células e apresentar sensibilidade "BAIXA"; + retornando um mapa em que as chaves são os nomes das colunas e os valores são uma lista dos tipos de entidades detectados + gravando o dynamicFrame retornado em outro caminho do 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() } } ``` ## Detectar dados confidenciais usando tipos de PII CustomEntityType da AWS Você pode definir as entidades personalizadas por meio do AWS Studio. Mas, para usar esse recurso fora do AWS Studio, você precisará primeiro definir os tipos de entidades personalizadas e, em seguida, adicionar os tipos de entidades personalizadas que foram definidos à lista de `entityTypesToDetect`. Se você tiver tipos de dados confidenciais específicos em seus dados (como “ID do funcionário”), poderá criar entidades personalizadas chamando a API `CreateCustomEntityType()`. O exemplo a seguir define o tipo de entidade personalizada 'EMPLOYEE\$1ID' para a API `CreateCustomEntityType()` com os parâmetros de solicitação: ``` { "name": "EMPLOYEE_ID", "regexString": "\d{4}-\d{3}", "contextWords": ["employee"] } ``` Em seguida, modifique o trabalho para usar o novo tipo de dados confidenciais personalizados adicionando o tipo de entidade personalizada (EMPLOYEE\$1ID) à 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 um tipo de dados confidenciais personalizados for definido com o mesmo nome de um tipo de entidade gerenciada existente, o tipo de dados confidenciais personalizados terá precedência e substituirá a lógica do tipo de entidade gerenciada. ## Parâmetros de detecção para uso de `detect()` Esse método é usado para detectar entidades em um DynamicFrame. Ele retorna um novo DataFrame com valores originais e uma coluna adicional outputColumnName que contém metadados de detecção de PII. O mascaramento personalizado poderá ser feito depois que esse DynamicFrame for retornado no script AWS Glue ou a API detect() com ações refinadas pode ser usada em seu lugar. ``` detect(frame: DynamicFrame, entityTypesToDetect: Seq[String], outputColumnName: String = "DetectedEntities", detectionSensitivity: String = "LOW"): DynamicFrame ``` Parâmetros: + **frame** (tipo:`DynamicFrame`): o DynamicFrame de entrada contendo os dados a serem processados. + **entityTypesToDetect** (tipo: `[Seq[String]`): a lista de tipos de entidades a serem detectadas. Esses podem ser tipos de entidade gerenciados ou tipos de entidade personalizados. + **outputColumnName** (tipo:`String`, padrão: "DetectedEntities"): o nome da coluna em que as entidades detectadas serão armazenadas. Se não for fornecido, o nome da coluna padrão será "DetectedEntities". + **detectionSensitivity** (tipo:`String`, opções: "BAIXA" ou "ALTA", padrão: "BAIXA"): especifica a sensibilidade do processo de detecção. As opções válidas são "BAIXA" ou "ALTA". Se essa propriedade não for definida, a sensibilidade padrão será definida como "BAIXA". Configurações do `outputColumnName`: O nome da coluna em que as entidades detectadas serão armazenadas. Se não for fornecido, o nome da coluna padrão será "DetectedEntities". Para cada linha na coluna de saída, a coluna suplementar inclui um mapa do nome da coluna para os metadados da entidade detectada com os seguintes pares de chave-valor: + **entityType**: o tipo da entidade detectada. + **start**: a posição inicial da entidade detectada nos dados originais. + **end**: a posição final da entidade detectada nos dados originais. + **actionUsed**: a ação executada na entidade detectada (por exemplo, “DETECT”, “REDACT”, “PARTIAL\$1REDACT”, “SHA256\$1HASH”). Exemplo: ``` { "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 } ] } } ``` **Parâmetros de detecção para `detect()` com ações refinadas** Esse método é usado para detectar entidades em um DynamicFrame usando os parâmetros especificados. Ele retorna um novo DataFrame com os valores originais substituídos por dados confidenciais mascarados e uma coluna `outputColumnName` adicional com metadados de detecção de PII. ``` detect(frame: DynamicFrame, detectionParameters: JsonOptions, outputColumnName: String = "DetectedEntities", detectionSensitivity: String = "LOW"): DynamicFrame ``` Parâmetros: + **frame** (tipo:`DynamicFrame`): o DynamicFrame de entrada contendo os dados a serem processados. + **detectionParameters** (tipo:`JsonOptions`): opções JSON que especificam parâmetros para o processo de detecção. + **outputColumnName** (tipo:`String`, padrão: "DetectedEntities"): o nome da coluna em que as entidades detectadas serão armazenadas. Se não for fornecido, o nome da coluna padrão será "DetectedEntities". + **detectionSensitivity** (tipo:`String`, opções: "BAIXA" ou "ALTA", padrão: "BAIXA"): especifica a sensibilidade do processo de detecção. As opções válidas são "BAIXA" ou "ALTA". Se essa propriedade não for definida, a sensibilidade padrão será definida como "BAIXA". `detectionParameters`configurações Se nenhuma configuração for incluída, os valores padrão serão usados. + **action** (tipo:`String`, opções: "DETECT", "REDACT", "PARTIAL\$1REDACT", "SHA256\$1HASH"): especifica a ação a ser executada na entidade. Obrigatório. Observe que as ações que executam o mascaramento (todas com exceção de "DETECT") só podem realizar uma ação por coluna. Essa é uma medida preventiva para mascarar entidades coalescidas. + **sourceColumns** (tipo: `List[String]`, padrão: ["\$1"]): lista de nomes de colunas de origem para realizar a detecção da entidade. Por padrão, será ["\$1"] se não estiver presente. Aumentará `IllegalArgumentException` se um nome de coluna inválido for usado. + **sourceColumnsToExclude** (tipo: `List[String]`): lista de nomes de colunas de origem para realizar a detecção para a entidade. Use `sourceColumns` ou `sourceColumnsToExclude`. Aumentará `IllegalArgumentException` se um nome de coluna inválido for usado. + **actionOptions**: opções adicionais com base na ação especificada: + Para "DETECT" e "SHA256\$1HASH", nenhuma opção é permitida. + Para "REDACT": + **redactText** (tipo:`String`, padrão: "\$1\$1\$1\$1\$1"): texto para substituir a entidade detectada. + Para "PARTIAL\$1REDACT": + **redactChar** (tipo:`String`, padrão: "\$1"): caractere para substituir cada caractere detectado na entidade. + **matchPattern** (tipo:`String`): padrão Regex para redação parcial. Não pode ser combinado com numLeftCharsToExclude ou `numRightCharsToExclude`. + **numLeftCharsToExclude** (tipo:`String, integer`): número de caracteres à esquerda a serem excluídos. Não pode ser combinado com matchPattern, mas pode ser usado com `numRightCharsToExclude`. + **numRightCharsToExclude** (tipo:`String, integer`): número de caracteres à direita a serem excluídos. Não pode ser combinado com matchPattern, mas pode ser usado com `numRightCharsToExclude`. Configurações de `outputColumnName` [Consulte as configurações de outputColumnName](#sensitive-data-detect-parameters-fine-grained-actions) ## Parâmetros de detecção para `classifyColumns()` Esse método é usado para detectar entidades em um DynamicFrame. Ele retorna um mapa em que as chaves são os nomes das colunas e os valores são uma lista dos tipos de entidades detectados. O mascaramento personalizado poderá ser feito depois que isso for retornado no script AWS Glue. ``` classifyColumns(frame: DynamicFrame, entityTypesToDetect: Seq[String], sampleFraction: Double = 0.1, thresholdFraction: Double = 0.1, detectionSensitivity: String = "LOW") ``` Parâmetros: + **frame** (tipo:`DynamicFrame`): o DynamicFrame de entrada contendo os dados a serem processados. + **entityTypesToDetect** (tipo: `Seq[String]`): a lista de tipos de entidades a serem detectadas. Esses podem ser tipos de entidade gerenciados ou tipos de entidade personalizados. + **sampleFraction** (tipo:`Double`, padrão: 10%): a fração dos dados que será amostrada na verificação de entidades de PII. + **thresholdFraction** (tipo:`Double`, padrão: 10%): a fração dos dados que deverá ser atendida para que uma coluna seja identificada como dados de PII. + **detectionSensitivity** (tipo:`String`, opções: "BAIXA" ou "ALTA", padrão: "BAIXA"): especifica a sensibilidade do processo de detecção. As opções válidas são "BAIXA" ou "ALTA". Se essa propriedade não for definida, a sensibilidade padrão será definida como "BAIXA".