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. Durch diese Integration können Sie diese Logs zur Analyse und Überwachung an Google SecOps senden.

Unterstützte AWS VPC-Flusslogformate

Google SecOps unterstützt die Aufnahme von AWS-VPC-Flusslogs 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-Flusslogs 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 Feld-Keys in den einzelnen Logeinträgen enthält, ist der AWS_VPC_FLOW_CSV-Parser auf eine strenge, vordefinierte Reihenfolge von Werten angewiesen. 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 zur Analyse durch Google SecOps zu ermöglichen.

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

Erstellen Sie einen Amazon S3-Bucket gemäß dem Nutzerhandbuch 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 Bereich 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 > Your VPCs/Subnets/Network interfaces (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 Flusslog 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 S3-Bucket-Adresse ein, z. B. s3://<your-bucket>/AWSLogs/<account-id>/vpcflowlogs/<region>/.
- Optionen zum Löschen von Quellen: Wählen Sie die gewünschte Option zum Löschen 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-Flusslogexport mit Amazon CloudWatch Logs und Kinesis Data Firehose konfigurieren

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

VPC-Flusslogs erstellen (Ziel: Amazon CloudWatch Logs)

Öffnen Sie die AWS-Konsole > VPC > Ihre VPCs/Subnetze/Netzwerkschnittstellen.
Klicken Sie auf Aktionen > Flow-Log erstellen.
Geben Sie die folgenden Konfigurationsdetails an:
- Filter: 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.
- Zielloggruppe: 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.
- Format des Logeintrags: Wählen Sie AWS-Standard (Version 2) oder Benutzerdefiniert (enthält zusätzliche Felder) aus.
Klicken Sie auf Flusslog erstellen.

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

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 Log type (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 Secret-Schlüssel generieren, um einen Secret-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 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 Direkte PUT-Anfrage 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-Schlüssel ein (dies wird der X-Amz-Firehose-Access-Key-Header).
- Puffer-Hinweise: Legen Sie Puffergröße = 1 MiB und Pufferintervall = 60 Sekunden fest.
- Komprimierung: Wählen Sie Deaktiviert aus.
- S3-Sicherung: Wählen Sie Deaktiviert aus.
- Lassen Sie die Einstellungen für retry (Wiederholung) und logging (Protokollierung) auf default (Standard).
Klicken Sie auf Bereitstellungsstream erstellen.

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

Rufen Sie CloudWatch > Logs > Log-Gruppen auf.
Wählen Sie die Ziel-Loggruppe aus (z. B. /aws/vpc/flowlogs).
Öffnen Sie den Tab Abo-Filter und klicken Sie auf Erstellen.
Wählen Sie Create Amazon Kinesis Data Firehose subscription filter (Amazon Kinesis Data Firehose-Abonnementfilter 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)

Achten Sie darauf, dass die CSV-Zeilen 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). Produktionsdateien dürfen keine Kopfzeile enthalten, es sei denn, dies ist für die 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 Logtyp aus.
Klicken Sie auf Weiter.
Geben Sie Werte für die folgenden Eingabeparameter an:
- S3-URI: Geben Sie die S3-Bucket-Adresse ein, z. B. s3://<your-bucket>/vpcflowlogs-csv/<region>/.
- Optionen zum Löschen der Quelle: Wählen Sie die gewünschte Löschoption 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 Release-Version 16.0 des AWS VPC Flow Logs-Parsers veröffentlicht. Diese Version enthält wichtige Änderungen bei der Zuordnung von Parser_Name-Logfeldern zu UDM-Feldern sowie Änderungen bei der Zuordnung von Ereignistypen.

Delta der Logfeldzuordnung

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 Zuordnung von Ereignistypen

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

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

Änderungsprotokoll

Änderungsprotokoll für diesen Parser ansehen

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