Detectar dados confidenciais usando os tipos de PII gerenciados pela AWS Detectar dados confidenciais usando tipos de PII CustomEntityType da AWS Parâmetros de detecção para uso de detect()Parâmetros de detecção para classifyColumns()

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.

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_PTIN”, “BANK_ACCOUNT”, “USA_SSN”, “USA_PASSPORT_NUMBER” e “PHONE_NUMBER” 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 ter mais informações, consulte Parâmetros de detecção para uso 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()
  }
}

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_ID' 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_ID) à 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_REDACT”, “SHA256_HASH”).

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".

configurações detectionParameters

Se nenhuma configuração for incluída, os valores padrão serão usados.

action (tipo:String, opções: "DETECT", "REDACT", "PARTIAL_REDACT", "SHA256_HASH"): 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: ["*"]): lista de nomes de colunas de origem para realizar a detecção da entidade. Por padrão, será ["*"] 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_HASH", nenhuma opção é permitida.
- Para "REDACT":
  - redactText (tipo:String, padrão: "*****"): texto para substituir a entidade detectada.
- Para "PARTIAL_REDACT":
  - redactChar (tipo:String, padrão: "*"): 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

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".

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Usar marcadores de trabalho

Tipos de dados confidenciais gerenciados