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-Flusslogs sind eine Funktion, mit der Sie Informationen zum IP-Traffic erfassen können, der an Netzwerkschnittstellen in Ihrer VPC ein- oder ausgeht. Mit dieser 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: Der Logtyp AWS_VPC_FLOW parst Logs im JSON-Format. 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 Feld-Schlü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 jedem Logeintrag enthält, basiert der AWS_VPC_FLOW_CSV-Parser auf einer strikten, vordefinierten Reihenfolge von Werten. Ihre CSV-Dateien müssen die folgende Feldreihenfolge einhalten, damit sie korrekt geparst werden können:

   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-Logzeile:

   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 innerhalb der CSV-Zeile beizubehalten.

Hinweis

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

Google SecOps-Instanz
Privilegierter Zugriff auf AWS.

Option 1: Export von AWS-VPC-Flusslogs mit AWS S3 konfigurieren (Textformat)

Im folgenden Abschnitt wird beschrieben, wie Sie Amazon S3- und Identity and Access Management-Berechtigungen 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 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äß diesem Nutzerhandbuch: IAM-Nutzer erstellen.
Wählen Sie den erstellten Nutzer aus.
Wählen Sie den Tab Sicherheitsanmeldedaten aus.
Klicken Sie im Bereich Access Keys (Zugriffsschlüssel) auf Create Access Key (Zugriffsschlüssel erstellen).
Wählen Sie Drittanbieterdienst als Anwendungsfall aus.
Klicken Sie auf Weiter.
Optional: Fügen Sie ein Beschreibungs-Tag hinzu.
Klicken Sie auf Zugriffsschlüssel erstellen.
Klicken Sie auf CSV-Datei herunterladen, um den Zugriffsschlüssel und den geheimen Zugriffsschlüssel zur späteren 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 > Flusslog 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: 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 des Logeintrags: Wählen Sie AWS-Standardformat aus.
- Log file format (Format der Protokolldatei): Wählen Sie Text (Plain) (Text (Nur-Text)) 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 Einstellungen > Datenverwaltung > Feeds auf. Wenn Sie eine reine SIEM-Plattform verwenden, rufen Sie die 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 als Quelltyp Amazon S3 V2 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 der Quelle: Wählen Sie die gewünschte Löschoption aus.
- Maximales Dateialter: Standardmäßig 180 Tage.
- Zugriffsschlüssel-ID: Der 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 des Datenexports, 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 > Flusslog 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.
- Logeintragsformat: 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 die Endpunkt-URL und den geheimen Schlüssel abzurufen

Rufen Sie die Einstellungen > Datenverwaltung > Feeds auf. Wenn Sie eine reine SIEM-Plattform verwenden, rufen Sie die 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.
Überprü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 anschließend API-Schlüssel aus.
Kopieren Sie den Schlüssel und speichern Sie ihn an einem sicheren Ort.
Beschränken Sie den Zugriff des API-Schlüssels auf die Google SecOps API.

IAM-Berechtigungen für CloudWatch Logs für Firehose konfigurieren

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

Fügen Sie die folgende JSON-Richtlinie ein und ersetzen Sie <region> und <account-id> durch Ihre AWS-Region und Ihre 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.
Gehen Sie zu 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-Konsole Kinesis > Data Firehose > Bereitstellungsstream erstellen 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 HTTPS-Endpunkt-URL des Feeds 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 Secret-Schlüssel ein, der im Google SecOps-Feed generiert wurde. Dieser wird zum X-Amz-Firehose-Access-Key-Header.
- Hinweise zur Zwischenspeicherung: Legen Sie Puffergröße = 1 MiB und Pufferintervall = 60 Sekunden fest.
- Komprimierung: Wählen Sie Deaktiviert aus.
- S3-Sicherung: Wählen Sie Deaktiviert aus.
- Behalten Sie die Standardeinstellungen für Wiederholen und Logging bei.
Klicken Sie auf Bereitstellungsstream erstellen.

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

Rufen Sie CloudWatch > Logs > Loggruppen auf.
Wählen Sie die Ziel-Loggruppe aus (z. B. /aws/vpc/flowlogs).
Öffnen Sie den Tab Abofilter und klicken Sie auf Erstellen.
Wählen Sie Create Amazon Kinesis Data Firehose subscription filter aus.
Geben Sie die folgenden Konfigurationsdetails an:
- Ziel: Wählen Sie den Lieferstream cwlogs-to-secops aus.
- Berechtigung erteilen: Wählen Sie die Rolle CWLtoFirehoseRole aus.
- Filtername: Geben Sie all-events ein.
- Filtermuster: Lassen Sie dieses 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 Zeilen in Ihrer CSV-Datei einer strengen, einheitlichen Spaltenreihenfolge folgen, die den Feldern entspricht, die Sie im benutzerdefinierten Format Ihres VPC-Flusslogs 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, Ihre Parser-Option erfordert eine.
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 Einstellungen > Datenverwaltung > Feeds auf. Wenn Sie eine reine SIEM-Plattform verwenden, rufen Sie die 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 als Quelltyp Amazon S3 V2 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: Der 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

Logbeispiel	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)` Zustand: `if [pkt_dstaddr_ip] != [dstaddr] will map to intermediary.ip"`
	`1.1.2.1`	`"additional.fields (pkt-dstaddr-ip)` Zustand: `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 enthält erhebliche Änderungen an der Zuordnung von Parser_Name-Logfeldern zu UDM-Feldern und an 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 Ereignistypzuordnung

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

Ereignistyp	Felder aus dem Log	Grund
FILE_UNCATEGORIZED	`Bytes`	It's newly handled in this PR mapped to an appropriate, specific event type
NETWORK_CONNECTION	`protocol`	It's newly handled in this PR mapped to an appropriate, specific event type
NETWORK_UNCATEGORIZED	`Class_name`	It's newly handled in this PR mapped to an appropriate, specific event type
NETWORK_UNCATEGORIZED	`flow_direction`	It's newly handled in this PR mapped to an appropriate, specific event type
STATUS_UPDATE	`[src_endpoint][ip]`	It's newly handled in this PR mapped to an appropriate, specific event type

Änderungsprotokoll

Änderungsprotokoll für diesen Parser ansehen

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