Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
AWS Glue In Studio können Sie sensible Daten erkennen. Sie können die Funktion zur Erkennung sensibler Daten jedoch auch außerhalb von AWS Glue Studio verwenden.
Eine vollständige Liste der verwalteten vertraulichen Datentypen finden Sie unter Verwaltete Datentypen.
Erkennung sensibler Daten mithilfe AWS verwalteter PII Typen
AWS Glue bietet zwei APIs in einem AWS Glue ETL Job. Diese sind detect()
und 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")
Sie können den verwenden detect()
API, um AWS verwaltete PII Typen und benutzerdefinierte Entitätstypen zu identifizieren. Es wird automatisch eine neue Spalte mit dem Erkennungsergebnis erstellt. Das classifyColumns()
API gibt eine Map zurück, in der Schlüssel Spaltennamen und Werte eine Liste der erkannten Entitätstypen sind. SampleFraction
gibt den Bruchteil der Daten an, der beim Scannen nach PII Entitäten entnommen werden muss, während der Bruchteil der Daten ThresholdFraction
angegeben wird, der erfüllt sein muss, damit eine Spalte als PII Daten identifiziert werden kann.
Erkennung auf Zeilenebene
In dem Beispiel führt der Job die folgenden Aktionen mit dem detect()
und aus classifyColumns()
APIs:
-
liest Daten aus einem Amazon S3 Bucket und wandelt sie in einen dynamicFrame
-
Erkennung von Fällen von „E-Mail“ und „Kreditkarte“ in dynamicFrame
-
Rückgabe von a dynamicFrame mit Originalwerten plus einer Spalte, die das Erkennungsergebnis für jede Zeile umfasst
-
das Zurückgegebene dynamicFrame in einen anderen Amazon S3 Pfad schreiben
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()
}
}
Erkennung auf Zeilenebene mit fein abgestuften Aktionen
In dem Beispiel führt der Job die folgenden Aktionen mit dem aus detect()
APIs:
-
Daten aus einem Amazon S3 S3-Bucket lesen und daraus einen dynamicFrame
-
Erkennung sensibler Datentypen für „USA_PTIN“, „BANK_ACCOUNT“, „USA_SSN“, „USAPASSPORT_ _NUMBER“ und „PHONE_NUMBER“ in der dynamicFrame
-
Rückgabe von a dynamicFrame mit modifizierten maskierten Werten plus einer Spalte, die das Erkennungsergebnis für jede Zeile umfasst
-
das Zurückgegebene dynamicFrame in einen anderen Amazon S3-Pfad schreiben
Im Gegensatz zu den obigen detect()
API Angaben werden hier feinkörnige Aktionen für die Erkennung von Entitätstypen verwendet. Weitere Informationen finden Sie unter Erkennungsparameter für die Verwendung von 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()
}
}
Erkennung auf Spaltenebene
Im Beispiel führt der Job die folgenden Aktionen mithilfe von aus: classifyColumns()
APIs
-
Daten aus einem Amazon S3 S3-Bucket lesen und daraus einen dynamicFrame
-
Erkennung von Instanzen von „E-Mail“ und „Kreditkarte“ in dynamicFrame
-
Stellen Sie die Parameter so ein, dass 100% der Spalte abgetastet werden, markieren Sie eine Entität als erkannt, wenn sie sich in 10% der Zellen befindet, und weisen Sie die Empfindlichkeit „LOW“ auf
-
Gibt eine Zuordnung zurück, in der Spaltennamen die Schlüssel sind und die Liste der erkannten Entitätstypen die Werte bildet.
-
das Zurückgegebene dynamicFrame in einen anderen Amazon S3-Pfad schreiben
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()
}
}
Erkennung sensibler Daten mithilfe AWS CustomEntityType PII von Typen
Sie können benutzerdefinierte Entitäten über AWS Studio definieren. Um diese Funktion jedoch von AWS Studio aus verwenden zu können, müssen Sie zuerst die benutzerdefinierten Entitätstypen definieren und dann die definierten benutzerdefinierten Entitätstypen zur Liste von hinzufügenentityTypesToDetect
.
Wenn Ihre Daten bestimmte sensible Datentypen enthalten (z. B. „Mitarbeiter-ID“), können Sie benutzerdefinierte Entitäten erstellen, indem Sie die aufrufen. CreateCustomEntityType()
API Im folgenden Beispiel wird der benutzerdefinierte Entitätstyp 'EMPLOYEE_ID' CreateCustomEntityType()
API mit den Anforderungsparametern für definiert:
{
"name": "EMPLOYEE_ID",
"regexString": "\d{4}-\d{3}",
"contextWords": ["employee"]
}
Ändern Sie dann den Job so, dass er den neuen benutzerdefinierten sensiblen Datentyp verwendet, indem Sie den benutzerdefinierten Entitätstyp (EMPLOYEE_ID) zu dem hinzufügen: 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()
}
}
Anmerkung
Wenn ein benutzerdefinierter sensibler Datentyp mit demselben Namen wie ein vorhandener verwalteter Entitätstyp definiert ist, hat der benutzerdefinierte sensible Datentyp Vorrang und überschreibt die Logik des verwalteten Entitätstyps.
Erkennungsparameter für die Verwendung von detect()
Diese Methode wird für die Erkennung von Entitäten in a DynamicFrame verwendet. Es gibt eine neue Spalte DataFrame mit Originalwerten und einer zusätzlichen Spalte mit outputColumnName PII Erkennungsmetadaten zurück. Eine benutzerdefinierte Maskierung kann durchgeführt werden, nachdem DynamicFrame dies innerhalb der zurückgegeben wurde AWS Glue Stattdessen können das Skript oder detect () mit feinkörnigen Aktionen verwendet API werden.
detect(frame: DynamicFrame,
entityTypesToDetect: Seq[String],
outputColumnName: String = "DetectedEntities",
detectionSensitivity: String = "LOW"): DynamicFrame
Parameter:
-
frame — (Typ:
DynamicFrame
) Die Eingabe, die die zu verarbeitenden Daten DynamicFrame enthält. -
entityTypesToDetect — (Typ:
[Seq[String]
) Liste der zu erkennenden Entitätstypen. Dabei kann es sich entweder um verwaltete Entitätstypen oder um benutzerdefinierte Entitätstypen handeln. -
outputColumnName— (Typ:
String
, Standard: "DetectedEntities„) Der Name der Spalte, in der erkannte Entitäten gespeichert werden. Falls nicht angegeben, ist der Standardspaltenname "DetectedEntities“. -
detectionSensitivity— (Typ:
String
, Optionen: "LOW" oder "HIGH„, Standard:" LOW „) Gibt die Empfindlichkeit des Erkennungsprozesses an. Gültige Optionen sind "LOW" oder "HIGH“. Falls nicht angegeben, ist die Standardempfindlichkeit auf "LOW" gesetzt.
outputColumnName
-Einstellungen:
Der Name der Spalte, in der erkannte Entitäten gespeichert werden sollen. Falls nicht angegeben, lautet der Standardspaltenname "DetectedEntities“. Für jede Zeile in der Ausgabespalte enthält die zusätzliche Spalte eine Zuordnung des Spaltennamens zu den Metadaten der erkannten Entität mit den folgenden Schlüssel-Wert-Paaren:
-
entityType— Der erkannte Entitätstyp.
-
start – Die Startposition der erkannten Entität in den Originaldaten.
-
end – Die Endposition der erkannten Entität in den Originaldaten.
-
actionUsed— Die Aktion, die an der erkannten Entität ausgeführt wurde (z. B. "REDACT,“ ",“ "PARTIAL_REDACT,“ "SHA256_ HASH „). DETECT
Beispiel:
{
"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
}
]
}
}
Erkennungsparameter für detect()
mit detaillierten Aktionen
Diese Methode wird verwendet, um Entitäten in einer DynamicFrame unter Verwendung bestimmter Parameter zu erkennen. Sie gibt eine neue Spalte zurück, DataFrame bei der die Originalwerte durch maskierte vertrauliche Daten ersetzt wurdenoutputColumnName
, und eine zusätzliche Spalte mit PII Erkennungsmetadaten.
detect(frame: DynamicFrame,
detectionParameters: JsonOptions,
outputColumnName: String = "DetectedEntities",
detectionSensitivity: String = "LOW"): DynamicFrame
Parameter:
-
frame — (Typ:
DynamicFrame
): Die Eingabe, die die zu verarbeitenden Daten DynamicFrame enthält. -
detectionParameters— (Typ:
JsonOptions
): JSON Optionen, die Parameter für den Erkennungsprozess angeben. -
outputColumnName— (type:
String
, default: "DetectedEntities„): Der Name der Spalte, in der erkannte Entitäten gespeichert werden. Falls nicht angegeben, ist der Standardspaltenname "DetectedEntities“. -
detectionSensitivity— (type:
String
, options: "LOW" oder "HIGH„, Standard:" LOW „): Gibt die Empfindlichkeit des Erkennungsprozesses an. Gültige Optionen sind "LOW" oder "HIGH“. Falls nicht angegeben, ist die Standardempfindlichkeit auf "LOW" gesetzt.
detectionParameters
-Einstellungen
Wenn keine Einstellungen enthalten sind, werden Standardwerte verwendet.
-
action — (type:
String
, options: "DETECT„," REDACT „," PARTIAL _ REDACT „," SHA256 _ HASH „) Gibt die Aktion an, die für die Entität ausgeführt werden soll. Erforderlich Beachten Sie, dass Aktionen, die eine Maskierung durchführen (alle außer "DETECT„), nur eine Aktion pro Spalte ausführen können. Dies ist eine vorbeugende Maßnahme zur Maskierung zusammengeführter Entitäten. -
sourceColumns— (Typ:
List[String]
, Standard: [„*“]) Liste der Quellspaltennamen, für die die Entität erkannt werden soll. Wenn hier nichts angegeben ist, lautet die Standardeinstellung [„*“].IllegalArgumentException
wird ausgelöst, wenn ein ungültiger Spaltenname verwendet wird. -
sourceColumnsToAusschließen — (Typ:
List[String]
) Liste der Quellspaltennamen, für die eine Erkennung für die Entität durchgeführt werden soll. Verwenden Sie entwedersourceColumns
odersourceColumnsToExclude
.IllegalArgumentException
wird ausgelöst, wenn ein ungültiger Spaltenname verwendet wird. -
actionOptions— Zusätzliche Optionen, die auf der angegebenen Aktion basieren:
-
Für "DETECT" und "SHA256_ HASH „sind keine Optionen zulässig.
-
Für "REDACT„:
-
redactText— (Typ:
String
, Standard: „*****“) Text, der die erkannte Entität ersetzen soll.
-
-
Für "PARTIAL_ REDACT „:
-
redactChar— (Typ:
String
, Standard: „*“) Zeichen, das jedes erkannte Zeichen in der Entität ersetzen soll. -
matchPattern— (Typ:
String
) Regex-Muster für teilweises Schwärzen. Kann nicht mit oder kombiniert werden. numLeftChars ToExcludenumRightCharsToExclude
-
numLeftCharsToExclude— (Typ:
String, integer
) Anzahl der verbleibenden Zeichen, die ausgeschlossen werden sollen. Kann nicht mit kombiniert werdenmatchPattern, kann aber mit verwendet werdennumRightCharsToExclude
. -
numRightCharsToExclude— (Typ:
String, integer
) Anzahl der richtigen Zeichen, die ausgeschlossen werden sollen. Kann nicht mit kombiniert werdenmatchPattern, kann aber mit verwendet werdennumRightCharsToExclude
.
-
-
outputColumnName
-Einstellungen
Siehe outputColumnName Einstellungen
Erkennungsparameter für classifyColumns()
Diese Methode wird zum Erkennen von Entitäten in a verwendet DynamicFrame. Gibt eine Zuordnung zurück, in der Spaltennamen die Schlüssel sind und die Liste der erkannten Entitätstypen die Werte bildet. Eine benutzerdefinierte Maskierung kann durchgeführt werden, nachdem dies innerhalb von zurückgegeben wurde AWS Glue skript.
classifyColumns(frame: DynamicFrame,
entityTypesToDetect: Seq[String],
sampleFraction: Double = 0.1,
thresholdFraction: Double = 0.1,
detectionSensitivity: String = "LOW")
Parameter:
-
frame — (Typ:
DynamicFrame
) Die Eingabe, die die zu verarbeitenden Daten DynamicFrame enthält. -
entityTypesToDetect — (Typ:
Seq[String]
) Liste der zu erkennenden Entitätstypen. Dabei kann es sich entweder um verwaltete Entitätstypen oder um benutzerdefinierte Entitätstypen handeln. -
sampleFraction— (Typ:
Double
, Standard: 10%) Der Teil der Daten, der beim Scannen nach PII Entitäten abgetastet werden muss. -
thresholdFraction— (Typ:
Double
, Standard: 10%): Der Teil der Daten, der erfüllt sein muss, damit eine Spalte als PII Daten identifiziert werden kann. -
detectionSensitivity— (Typ:
String
, Optionen: "LOW" oder "HIGH„, Standard:" LOW „) Gibt die Empfindlichkeit des Erkennungsprozesses an. Gültige Optionen sind "LOW" oder "HIGH“. Falls nicht angegeben, ist die Standardempfindlichkeit auf "LOW" gesetzt.