Wählen Sie Ihre Cookie-Einstellungen aus

Wir verwenden essentielle Cookies und ähnliche Tools, die für die Bereitstellung unserer Website und Services erforderlich sind. Wir verwenden Performance-Cookies, um anonyme Statistiken zu sammeln, damit wir verstehen können, wie Kunden unsere Website nutzen, und Verbesserungen vornehmen können. Essentielle Cookies können nicht deaktiviert werden, aber Sie können auf „Anpassen“ oder „Ablehnen“ klicken, um Performance-Cookies abzulehnen.

Wenn Sie damit einverstanden sind, verwenden AWS und zugelassene Drittanbieter auch Cookies, um nützliche Features der Website bereitzustellen, Ihre Präferenzen zu speichern und relevante Inhalte, einschließlich relevanter Werbung, anzuzeigen. Um alle nicht notwendigen Cookies zu akzeptieren oder abzulehnen, klicken Sie auf „Akzeptieren“ oder „Ablehnen“. Um detailliertere Entscheidungen zu treffen, klicken Sie auf „Anpassen“.

Verwendung der Erkennung sensibler Daten außerhalb von AWS Glue Studio

Fokusmodus
Verwendung der Erkennung sensibler Daten außerhalb von AWS Glue Studio - AWS Glue

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.

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. SampleFractiongibt 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 entweder sourceColumns oder sourceColumnsToExclude. 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 ToExclude numRightCharsToExclude

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

DatenschutzNutzungsbedingungen für die WebsiteCookie-Einstellungen
© 2025, Amazon Web Services, Inc. oder Tochtergesellschaften. Alle Rechte vorbehalten.