Wir haben die Navigationsstruktur unserer Dokumentation neu organisiert, um sie direkt an Ihre betrieblichen Arbeitsabläufe anzupassen. Weitere Informationen finden Sie in den Versionshinweisen und im Video zur Anleitung.

Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

AWS-VPC-Flusslogs erfassen

Parserversion:17.0

Unterstützt in:

Google SecOps SIEM

In diesem Dokument wird beschrieben, wie Sie AWS VPC-Flusslogs mit drei verschiedenen Methoden in Google Security Operations aufnehmen: Amazon S3 (Textformat), Amazon CloudWatch Logs mit Kinesis Data Firehose und CSV-Format in Amazon S3. AWS VPC Flow Logs ist eine Funktion, mit der Sie Informationen über den IP-Traffic erfassen können, der in Ihrer VPC an Netzwerkschnittstellen ein- oder ausgeht. Mit dieser Integration können Sie diese Logs zur Analyse und zum Monitoring an Google SecOps senden.

Unterstützte AWS VPC-Flusslogformate

Google SecOps unterstützt die Aufnahme von AWS VPC Flow Logs in zwei primären Textformaten:

JSON-Format: Beim Logtyp AWS_VPC_FLOW werden Logs im JSON-Format geparst. In diesem Format enthält jeder Logeintrag sowohl einen Schlüssel als auch den entsprechenden Wert, sodass die Daten selbsterklärend sind.
CSV-Format: Google SecOps bietet auch einen Parser für AWS VPC Flow Logs im CSV-Format. In diesem Format werden Feldschlüssel nur einmal in der Kopfzeile aufgeführt. Die nachfolgenden Zeilen enthalten nur durch Kommas getrennte Werte.

Da das CSV-Format keine Feldschlüssel in den einzelnen Logeinträgen enthält, ist für den AWS_VPC_FLOW_CSV-Parser eine strenge, vordefinierte Reihenfolge der Werte erforderlich. Ihre CSV-Dateien müssen die folgende Feldreihenfolge für das korrekte Parsen einhalten:

   Version,Account_id,Interface_id,Srcaddr,Dstaddr,Srcport,Dstport,Protocol,Packets,Bytes,Start,End,Action,Log_status,Vpc_id,Subnet_id,Instance_id,Tcp_flags,Type,Pkt_srcaddr,Pkt_dstaddr,Region,Az_id,Sublocation_type,Sublocation_id,Pkt_src_aws_service,Pkt_dst_aws_service,Flow_direction,Traffic_path,Ecs_cluster_arn,Ecs_cluster_name,Ecs_container_instance_arn,Ecs_container_instance_id,Ecs_container_id,Ecs_second_container_id,Ecs_service_name,Ecs_task_definition_arn,Ecs_task_arn,Ecs_task_id

Hier ein Beispiel für eine CSV-Protokollzeile:

   7,369096419186,eni-0520bb5efed19d33a,10.119.32.34,10.119.223.3,51256,16020,6,14,3881,1723542839,1723542871,ACCEPT,OK,vpc-0769a6844ce873a6a,subnet-0cf9b2cb32f49f258,i-088d6080f45f5744f,0,IPv4,10.119.32.34,10.119.223.3,ap-northeast-1,apne1-az4,-,-,-,-,ingress,,-,-,-,-,-,-,-,-,-,-

Für Felder, für die kein Wert verfügbar ist, sollte ein leerer Wert (z. B. ,,) übergeben werden, um die richtige Position in der CSV-Zeile beizubehalten.

Hinweis

Prüfen Sie, ob folgende Voraussetzungen erfüllt sind:

Google SecOps-Instanz.
Privilegierter Zugriff auf AWS.

Option 1: AWS VPC-Flusslogexport mit AWS S3 konfigurieren (Textformat)

Im folgenden Abschnitt wird beschrieben, wie Sie Amazon S3- und IAM-Berechtigungen (Identity and Access Management) konfigurieren, um den Export von VPC-Flusslogs für die Analyse durch Google SecOps zu ermöglichen.

AWS S3-Bucket und IAM für Google SecOps konfigurieren

Erstellen Sie einen Amazon S3-Bucket. Folgen Sie dazu der Anleitung unter Bucket erstellen.
Speichern Sie den Namen und die Region des Buckets zur späteren Verwendung (z. B. aws-vpc-flowlogs).
Erstellen Sie einen Nutzer gemäß dieser Anleitung: IAM-Nutzer erstellen.
Wählen Sie den erstellten Nutzer aus.
Wählen Sie den Tab Sicherheitsanmeldedaten aus.
Klicken Sie im Abschnitt Zugriffsschlüssel auf Zugriffsschlüssel erstellen.
Wählen Sie Drittanbieterdienst als Anwendungsfall aus.
Klicken Sie auf Weiter.
Optional: Fügen Sie ein Beschreibungstag hinzu.
Klicken Sie auf Zugriffsschlüssel erstellen.
Klicken Sie auf CSV-Datei herunterladen, um den Access Key (Zugriffsschlüssel) und den Secret Access Key (geheimer Zugriffsschlüssel) für die zukünftige Verwendung zu speichern.
Klicken Sie auf Fertig.
Wählen Sie den Tab Berechtigungen aus.
Klicken Sie im Bereich Berechtigungsrichtlinien auf Berechtigungen hinzufügen.
Wählen Sie Berechtigungen hinzufügen aus.
Wählen Sie Richtlinien direkt anhängen aus.
Suchen Sie nach der Richtlinie AmazonS3FullAccess.
Wählen Sie die Richtlinie aus.
Klicken Sie auf Weiter.
Klicken Sie auf Berechtigungen hinzufügen.

VPC-Flusslogs erstellen (Ziel: Amazon S3, Textformat)

Öffnen Sie die AWS Console > VPC > Ihre VPCs/Subnetze/Netzwerkschnittstellen und wählen Sie den Bereich aus, den Sie protokollieren möchten.
Klicken Sie auf Aktionen > Flow-Log erstellen.
Geben Sie die folgenden Konfigurationsdetails an:
- Filter: Wählen Sie gemäß Ihrer Richtlinie Alle (oder Annehmen / Ablehnen) aus.
- Maximales Aggregationsintervall: Wählen Sie 1 Minute (empfohlen) oder 10 Minuten aus.
- Ziel: An einen Amazon S3-Bucket senden.
- S3-Bucket-ARN: Geben Sie den im vorherigen Abschnitt erstellten Bucket-Namen im folgenden Format ein: arn:aws:s3:::<your-bucket>.
- Format für Logeinträge: Wählen Sie AWS-Standardformat aus.
- Logdateiformat: Wählen Sie Text (Plain) aus.
- Optional: Deaktivieren Sie Hive-kompatible Präfixe und Stündliche Partitionen, sofern Sie sie nicht benötigen.
Klicken Sie auf Flow-Log erstellen.

Feed in Google SecOps konfigurieren, um AWS VPC-Flusslogs (S3-Text) aufzunehmen

Rufen Sie die SIEM-Einstellungen > Feeds auf.
Klicken Sie auf + Neuen Feed hinzufügen.
Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B. AWS VPC Flow Logs - S3 (Text).
Wählen Sie Amazon S3 V2 als Quelltyp aus.
Wählen Sie AWS VPC Flow als Logtyp aus.
Klicken Sie auf Weiter.
Geben Sie Werte für die folgenden Eingabeparameter an:
- S3-URI: Geben Sie die Adresse des S3-Buckets ein, z. B. s3://<your-bucket>/AWSLogs/<account-id>/vpcflowlogs/<region>/.
- Optionen zum Löschen der Quelle: Wählen Sie die gewünschte Option aus.
- Maximales Dateialter: Standardmäßig 180 Tage.
- Zugriffsschlüssel-ID: Nutzerzugriffsschlüssel mit Zugriff auf den S3-Bucket.
- Geheimer Zugriffsschlüssel: Der geheime Schlüssel des Nutzers mit Zugriff auf den S3-Bucket.
- Asset-Namespace: Der Asset-Namespace.
- Aufnahmelabels: Das Label, das auf die Ereignisse aus diesem Feed angewendet wird.
Klicken Sie auf Weiter.
Prüfen Sie die neue Feedkonfiguration auf dem Bildschirm Abschließen und klicken Sie dann auf Senden.

Option 2: AWS VPC Flow Logs-Export mit Amazon CloudWatch Logs und Kinesis Data Firehose konfigurieren

Nachdem Sie die Flow-Logs für CloudWatch eingerichtet haben, bietet diese Option eine zusätzliche Ebene für den Datenexport, indem die Logdaten mit Kinesis Data Firehose an ein Ziel Ihrer Wahl gestreamt werden.

VPC-Flusslogs erstellen (Ziel: Amazon CloudWatch Logs)

Öffnen Sie die AWS Console> VPC > Ihre VPCs/Subnetze/Netzwerkschnittstellen.
Klicken Sie auf Aktionen > Flow-Log erstellen.
Geben Sie die folgenden Konfigurationsdetails an:
- Filtern: Wählen Sie gemäß Ihrer Richtlinie Alle (oder Akzeptieren/Ablehnen) aus.
- Maximales Aggregationsintervall: Wählen Sie 1 Minute (empfohlen) oder 10 Minuten aus.
- Ziel: Wählen Sie An CloudWatch Logs senden aus.
- Ziel-Loggruppe: Wählen Sie eine Loggruppe aus oder erstellen Sie eine (z. B. /aws/vpc/flowlogs).
- IAM-Rolle: Wählen Sie eine Rolle aus, die in CloudWatch Logs schreiben kann.
- Logeintragformat: Wählen Sie AWS-Standard (Version 2) oder Benutzerdefiniert (mit zusätzlichen Feldern) aus.
Klicken Sie auf Flow-Log erstellen.

Feed in Google SecOps erstellen, um Endpunkt-URL und Secret Key zu erhalten

Rufen Sie die SIEM-Einstellungen > Feeds auf.
Klicken Sie auf + Neuen Feed hinzufügen.
Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B. AWS VPC Flow Logs - CloudWatch via Firehose.
Wählen Sie Amazon Data Firehose als Quelltyp aus.
Wählen Sie AWS VPC Flow als Logtyp aus.
Klicken Sie auf Weiter.
Geben Sie Werte für die folgenden Eingabeparameter an:
- Trennzeichen für Aufteilung: Optional n.
- Asset-Namespace: Der Asset-Namespace, z. B. aws.vpc.flowlogs.cwl.
- Labels für Datenaufnahme: Das Label, das auf die Ereignisse aus diesem Feed angewendet werden soll (z. B. source=vpc_flow_firehose).
Klicken Sie auf Weiter.
Prüfen Sie die Feedkonfiguration und klicken Sie auf Senden.
Klicken Sie auf Geheimen Schlüssel generieren, um einen geheimen Schlüssel zur Authentifizierung dieses Feeds zu generieren.
Kopieren und speichern Sie den geheimen Schlüssel, da Sie ihn nicht noch einmal aufrufen können.
Wechseln Sie zum Tab Details.
Kopieren Sie die Feed-Endpunkt-URL aus dem Feld Endpoint Information (Endpunktinformationen).
Klicken Sie auf Fertig.

API-Schlüssel für den Amazon Data Firehose-Feed erstellen

Rufen Sie in der Google Cloud Console die Seite Anmeldedaten auf.
Klicken Sie auf Anmeldedaten erstellen und wählen Sie dann API-Schlüssel aus.
Kopieren Sie den Schlüssel und speichern Sie ihn an einem sicheren Ort.
Schränken Sie den Zugriff des API-Schlüssels auf die Google SecOps API ein.

IAM-Berechtigungen für CloudWatch Logs to Firehose konfigurieren

Rufen Sie in der AWS Console IAM > Richtlinien > Richtlinie erstellen > JSON auf.

Fügen Sie den folgenden Richtlinien-JSON ein und ersetzen Sie <region> und <account-id> durch Ihre AWS-Region und Konto-ID:

{
"Version": "2012-10-17",
"Statement": [
   {
      "Effect": "Allow",
      "Action": [
      "firehose:PutRecord",
      "firehose:PutRecordBatch"
      ],
      "Resource": "arn:aws:firehose:<region>:<account-id>:deliverystream/cwlogs-to-secops"
   }
]
}

Geben Sie der Richtlinie den Namen CWLtoFirehoseWrite und klicken Sie auf Richtlinie erstellen.
Klicken Sie auf IAM > Rollen > Rolle erstellen.

Wählen Sie Benutzerdefinierte Vertrauensrichtlinie aus und fügen Sie Folgendes ein:

{
"Version": "2012-10-17",
"Statement": [
   {
      "Effect": "Allow",
      "Principal": {
      "Service": "logs.<region>.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
   }
]
}

Hängen Sie die Richtlinie CWLtoFirehoseWrite an die Rolle an.
Geben Sie der Rolle den Namen CWLtoFirehoseRole und klicken Sie auf Rolle erstellen.

Amazon Kinesis Data Firehose für Google SecOps konfigurieren

Rufen Sie in der AWS Console Kinesis > Data Firehose > Create delivery stream auf.
Geben Sie die folgenden Konfigurationsdetails an:
- Quelle: Wählen Sie Direkter PUT oder andere Quellen aus.
- Ziel: Wählen Sie HTTP-Endpunkt aus.
- Name: cwlogs-to-secops
- HTTP-Endpunkt-URL: Geben Sie die Feed-HTTPS-Endpunkt-URL aus Google SecOps mit angehängtem API-Schlüssel ein: <ENDPOINT_URL>?key=<API_KEY>.
- HTTP-Methode: Wählen Sie POST aus.
Unter Zugriffsschlüssel:
- Geben Sie den in Google SecOps Feed generierten Secret key ein (dies wird zum X-Amz-Firehose-Access-Key-Header).
- Pufferungshinweise: Legen Sie Puffergröße = 1 MiB und Zwischenspeicherintervall = 60 Sekunden fest.
- Komprimierung: Wählen Sie Deaktiviert aus.
- S3-Sicherung: Wählen Sie Deaktiviert aus.
- Behalten Sie für die Einstellungen für Wiederholung und Logging die Standardeinstellungen bei.
Klicken Sie auf Lieferstream erstellen.

CloudWatch-Logs-Gruppe für den Firehose-Stream abonnieren

Rufen Sie CloudWatch > Logs > Loggruppen auf.
Wählen Sie die Zielloggruppe aus, z. B. /aws/vpc/flowlogs.
Öffnen Sie den Tab Abo-Filter und klicken Sie auf Erstellen.
Wählen Sie Amazon Kinesis Data Firehose-Abo-Filter erstellen aus.
Geben Sie die folgenden Konfigurationsdetails an:
- Ziel: Wählen Sie den Auslieferungsstream cwlogs-to-secops aus.
- Berechtigung erteilen: Wählen Sie die Rolle CWLtoFirehoseRole aus.
- Filtername: Geben Sie all-events ein.
- Filtermuster: Lassen Sie das Feld leer, um alle Ereignisse zu senden.
Klicken Sie auf Streaming starten.

Option 3: AWS VPC-Flusslogs im CSV-Format mit Amazon S3 konfigurieren

Protokolle in das CSV-Format umwandeln (optional)

Die CSV-Zeilen müssen einer strengen, einheitlichen Spaltenreihenfolge entsprechen, die mit den Feldern übereinstimmt, die Sie in Ihrem benutzerdefinierten Format für VPC-Flow-Logs ausgewählt haben (z. B. der kanonische v2-Feldsatz oder Ihr v5-/v7-Satz). Fügen Sie in Produktionsdateien keine Kopfzeile ein, es sei denn, dies ist für Ihre Parseroption erforderlich.
Schreiben Sie CSV-Dateien in ein stabiles Präfix, z. B. s3://<your-bucket>/vpcflowlogs-csv/<region>/year=<year>/month=<month>/day=<day>/.

Feed in Google SecOps konfigurieren, um AWS VPC-Flusslogs (CSV) aufzunehmen

Rufen Sie die SIEM-Einstellungen > Feeds auf.
Klicken Sie auf + Neuen Feed hinzufügen.
Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B. AWS VPC Flow Logs - S3 (CSV).
Wählen Sie Amazon S3 V2 als Quelltyp aus.
Wählen Sie AWS VPC Flow (CSV) als Log type (Logtyp) aus.
Klicken Sie auf Weiter.
Geben Sie Werte für die folgenden Eingabeparameter an:
- S3-URI: Geben Sie die Adresse des S3-Buckets ein, z. B. s3://<your-bucket>/vpcflowlogs-csv/<region>/.
- Optionen zum Löschen der Quelle: Wählen Sie die gewünschte Option aus.
- Maximales Dateialter: Standardmäßig 180 Tage.
- Zugriffsschlüssel-ID: Nutzerzugriffsschlüssel mit Zugriff auf den S3-Bucket.
- Geheimer Zugriffsschlüssel: Der geheime Schlüssel des Nutzers mit Zugriff auf den S3-Bucket.
- Asset-Namespace: Der Asset-Namespace.
- Aufnahmelabels: Das Label, das auf die Ereignisse aus diesem Feed angewendet wird.
Klicken Sie auf Weiter.
Prüfen Sie die neue Feedkonfiguration auf dem Bildschirm Abschließen und klicken Sie dann auf Senden.

UDM-Zuordnungstabelle

Beispiellog	Logfeld	UDM-Zuordnung
`"entries: { data: ""7,11111111111,eni-11aa1a1a1a1aa1a,1.1.1.1,2.2.2.2,51256,16020,6,14,3881,1723542839,1723542871,ACCEPT,OK,vpc-1aa1a1a1a1aa1aa,subnet-1aa1a1a1a1aa1a1,i-1aa1a1a1a1aa1a,0,IPv4,1.1.1.1,2.2.2.2,ap-northeast-1,masked_zone,-,-,-,-,ingress,,-,-,-,-,-,-,-,-,-,-"" collection_time: { seconds: 1741159282 nanos: 254633949 } }"`	`7`	`metadata.product_version`
	`11111111111`	`metadata.product_log_id`
	`eni-11aa1a1a1a1aa1a`	`principal.user.product_object_id`
	`1.1.1.1`	`principal.ip`
	`2.2.2.2`	`target.ip`
	`51256`	`principal.port`
	`16020`	`target.port`
	`6`	`network.ip_protocol`
	`14`	`network.sent_packets`
	`3881`	`network.received_bytes`
	`1723542839`	`metadata.event_timestamp about.resource.attribute.labels(start_time)`
	`1723542871`	`metadata.ingested_timestamp about.resource.attribute.labels(end_time)`
	`ACCEPT`	`security_result.action security_result.action_details`
	`OK`	`about.resource.attribute.labels (log-status)`
	`vpc-1aa1a1a1a1aa1a`	`principal.resource.attribute.labels (vpcID)`
	`subnet-a1a1a1a1a1`	`principal.asset_id`
	`i-1aa1a1a1a1aa1a`	`principal.resource_ancestors.product_object_id`
	`0`	`about.resource.attribute.labels (type)`
	`IPv4`	`additional.fields (pkt-srcaddr-ip)`
	`1.1.1.1`	`intermediary.ip`
	`2.2.2.2`	`additional.fields (tcp_flags)`
	`ap-northeast-1`	`not getting mapped`
	`masked_zone`	`not getting mapped`
	`-`	`about.resource.attribute.labels (sublocation_type)`
	`-`	`about.resource.attribute.labels (sublocation_id)`
	`-`	`about.resource.attribute.labels (pkt_src_aws_service)`
	`-`	`about.resource.attribute.labels (pkt_dst_aws_service)`
	`ingress`	`network.direction`
		`additional.fields (traffic_path)`
	`-`	`not getting mapped`
	`-`	`not getting mapped-`
`"entries: { data: ""7,11111111111,eni-11aa1a1a1a1aa1a,5.5.5.5,2.2.2.2,53102,16020,6,8,2112,1723542839,1723542871,ACCEPT,OK,vpc-1aa1a1a1a1aa1a,subnet-1aa1a1a1a1aa1a,i-1aa1a1a1a1aa1a,0,IPv4,5.5.5.5,2.2.2.2,ap-northeast-1,masked_zone,-,-,-,-,ingress,,-,-,-,-,-,-,-,-,-,-"" collection_time: { seconds: 1741159390 nanos: 374934225 } }"`	`7`	`metadata.product_version`
	`11111111111`	`metadata.product_log_id`
	`eni-11aa1a1a1a1aa1a`	`principal.user.product_object_id`
	`5.5.5.5`	`principal.ip`
	`2.2.2.2`	`target.ip`
	`53102`	`principal.port`
	`16020`	`target.port`
	`6`	`network.ip_protocol`
	`8`	`network.sent_packets`
	`2112`	`network.received_bytes`
	`1723542839`	`metadata.event_timestamp about.resource.attribute.labels(start_time)`
	`1723542871`	`metadata.ingested_timestamp about.resource.attribute.labels(end_time)`
	`ACCEPT`	`security_result.action security_result.action_details`
	`OK`	`about.resource.attribute.labels (log-status)`
	`vpc-1aa1a1a1a1aa1a`	`principal.resource.attribute.labels (vpcID)`
	`subnet-1aa1a1a1a1aa1a`	`principal.asset_id`
	`i-1aa1a1a1a1aa1a`	`principal.resource_ancestors.product_object_id`
	`0`	`about.resource.attribute.labels (type)`
	`IPv4`	`additional.fields (pkt-srcaddr-ip)`
	`5.5.5.5`	`intermediary.ip`
	`2.2.2.2`	`additional.fields (tcp_flags)`
	`ap-northeast-1`	`not getting mapped`
	`masked_zone`	`not getting mapped`
	`-`	`about.resource.attribute.labels (sublocation_type)`
	`-`	`about.resource.attribute.labels (sublocation_id)`
	`-`	`about.resource.attribute.labels (pkt_src_aws_service)`
	`-`	`about.resource.attribute.labels (pkt_dst_aws_service)`
	`ingress`	`network.direction`
		`additional.fields (traffic_path)`
	`-`	`not getting mapped`
	`-`	`not getting mapped1`
`"entries: { data: ""7,11111111111,eni-11aa1a1a1a1aa1a,1.1.2.2,1.1.2.1,36358,42659,6,1091,3.754327e+06,1747981553,1747981582,ACCEPT,OK,vpc-1aa1a1a1a1aa1a,subnet-1aa1a1a1a1aa1a,i-1aa1a1a1a1aa1a,0,IPv4,1.1.2.2,1.1.2.1,ap-northeast-1,apne1-az1,-,-,-,-,egress,1,-,-,-,-,-,-,-,-,-,-,604249"" collection_time: { seconds: 1748238552 nanos: 479960397 } }"`	`7`	`metadata.product_version`
	`11111111111`	`metadata.product_log_id`
	`eni-11aa1a1a1a1aa1a`	`about.resource.attribute.labels`
	`1.1.2.2`	`principal.ip`
	`1.1.2.1`	`target.ip`
	`36358`	`principal.port`
	`42659`	`target.port`
	`6`	`network.ip_protocol`
	`1091`	`network.sent_packets`
	`3.75E+06`	`network.sent_bytes`
	`1747981553`	`metadata.event_timestamp about.resource.attribute.labels(start_time)`
	`1747981582`	`metadata.ingested_timestamp about.resource.attribute.labels(end_time)`
	`ACCEPT`	`security_result.action security_result.action_details`
	`OK`	`about.resource.attribute.labels (log-status)`
	`vpc-1aa1a1a1a1aa1a`	`principal.resource.attribute.labels (vpcID)`
	`subnet-1aa1a1a1a1aa1a`	`principal.asset_id`
	`i-1aa1a1a1a1aa1a`	`principal.resource_ancestors.product_object_id`
	`0`	`additional.fields (tcp_flags)`
	`IPv4`	`about.resource.attribute.labels(type)`
	`1.1.2.2`	`"additional.fields (pkt-srcaddr-ip)` Bedingung: `if [pkt_dstaddr_ip] != [dstaddr] will map to intermediary.ip"`
	`1.1.2.1`	`"additional.fields (pkt-dstaddr-ip)` Bedingung: `if [pkt_srcaddr_ip] != [srcaddr] will map to intermediary.ip"`
	`ap-northeast-1`	`principal.location.country_or_region`
	`apne1-az1`	`principal.location.name`
	`-`	`about.resource.attribute.labels (sublocation_type)`
	`-`	`about.resource.attribute.labels (sublocation_id)`
	`-`	`about.resource.attribute.labels (pkt_src_aws_service)`
	`-`	`about.resource.attribute.labels (pkt_dst_aws_service)`
	`egress`	`network.direction`
	`1`	`additional.fields (traffic_path)`
	`-`	`not getting mapped`
	`604249`	`not getting mapped`
	`Connection_info.Tcp_flags`	`additional.fields`
	`connection_info.tcp_flags`	`additional.fields`
	`Dst_endpoint.Interface_uid`	`target.user.product_object_id`
	`Log_status`	`additional.fields`
	`Src_endpoint.Instance_uid`	`principal.user.product_object_id`
	`Tcp_flags`	`additional.fields`
	`tcp_flags`	`additional.fields`
	`tgw_dst_az_id`	`target.resource.attribute.cloud.availability_zone`
	`tgw_id`	`target.resource.product_object_id`
	`tgw_src_az_id`	`principal.location.name`
	`Traffic_Bytes`	`network.sent_bytes`
	`Traffic_Packets`	`network.sent_packets`

Release-Delta

Google SecOps hat Version 16.0 des AWS VPC Flow Logs-Parsers veröffentlicht. Diese Version enthält wichtige Änderungen an der Zuordnung von Parser_Name-Logfeldern zu UDM-Feldern sowie Änderungen an der Zuordnung von Ereignistypen.

Delta der Zuordnung von Logfeldern

Logfeld	Alte Zuordnung	Aktuelle Zuordnung
`bytes`	`network.sent_bytes`	`Removed`
`Connection_info.Tcp_flags`	`network.dhcp.flags`	`additional.fields`
`connection_info.tcp_flags`	`network.dhcp.flags`	`additional.fields`
`Dst_endpoint.Interface_uid`	`additional.fields`	`target.user.product_object_id`
`flow_direction`	`about.resource.attribute.labels`	`Removed`
`Log_status`	`about.resource.attribute.labels`	`additional.fields`
`Src_endpoint.Instance_uid`	`additional.fields`	`principal.user.product_object_id`
`Tcp_flags`	`network.dhcp.flags`	`additional.fields`
`tcp_flags`	`network.dhcp.flags`	`additional.fields`
`tgw_dst_az_id`	`target.resource.attribute.labels`	`target.resource.attribute.cloud.availability_zone`
`tgw_id`	`additional.fields`	`target.resource.product_object_id`
`tgw_src_az_id`	`principal.resource.attribute.labels`	`principal.location.name`
`Traffic_Bytes`	`additional.fields`	`network.sent_bytes`
`Traffic_Packets`	`additional.fields`	`network.sent_packets`

Delta der Ereignistypzuordnung

Mehrere Ereignisse, die allgemein klassifiziert wurden, werden jetzt mit aussagekräftigen Ereignistypen richtig klassifiziert.

Ereignistyp	Felder aus dem Log	Grund
FILE_UNCATEGORIZED	`Bytes`	Sie wird in diesem PR neu behandelt und einem entsprechenden, spezifischen Ereignistyp zugeordnet.
NETWORK_CONNECTION	`protocol`	Sie wird in diesem PR neu behandelt und einem entsprechenden, spezifischen Ereignistyp zugeordnet.
NETWORK_UNCATEGORIZED	`Class_name`	Sie wird in diesem PR neu behandelt und einem entsprechenden, spezifischen Ereignistyp zugeordnet.
NETWORK_UNCATEGORIZED	`flow_direction`	Sie wird in diesem PR neu behandelt und einem entsprechenden, spezifischen Ereignistyp zugeordnet.
STATUS_UPDATE	`[src_endpoint][ip]`	Sie wird in diesem PR neu behandelt und einem entsprechenden, spezifischen Ereignistyp zugeordnet.

Änderungsprotokoll

Änderungsprotokoll für diesen Parser ansehen

Benötigen Sie weitere Hilfe? Antworten von Community-Mitgliedern und Google SecOps-Experten erhalten