Abbiamo riorganizzato la struttura di navigazione della documentazione per allinearla direttamente ai tuoi flussi di lavoro operativi. Per ulteriori informazioni, consulta le note di rilascio e il video dimostrativo.

Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Raccogliere i log di Tailscale

Supportato in:

Google SecOps SIEM

Questo documento spiega come importare i log di Tailscale in Google Security Operations utilizzando la funzionalità di streaming dei log Amazon S3 nativa di Tailscale. Tailscale produce dati operativi sotto forma di log di controllo della configurazione e log di flusso di rete. Questa integrazione utilizza la funzionalità di streaming S3 integrata di Tailscale per inviare automaticamente questi log a Google SecOps per l'analisi e il monitoraggio.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

Istanza Google SecOps
Accesso privilegiato alla Console di amministrazione di Tailscale (ruolo Proprietario, Amministratore, Amministratore di rete o Amministratore IT)
Accesso privilegiato ad AWS (S3, IAM)

Raccogliere i prerequisiti di Tailscale (informazioni sulla tailnet)

Accedi alla console di amministrazione di Tailscale.
Prendi nota del nome della tailnet (ad esempio, example.com o il nome della tua organizzazione).
Assicurati di avere il piano richiesto:
- Streaming dei log di controllo della configurazione: disponibile per i piani Personal, Personal Plus ed Enterprise.
- Streaming dei log di flusso di rete: disponibile solo con il piano Enterprise.

Configura il bucket AWS S3 e IAM per Google SecOps

Crea un bucket Amazon S3 seguendo questa guida utente: Creazione di un bucket
Salva il nome e la regione del bucket per riferimento futuro (ad esempio, tailscale-logs).
Crea un utente seguendo questa guida: Creazione di un utente IAM.
Seleziona l'utente creato.
Seleziona la scheda Credenziali di sicurezza.
Fai clic su Crea chiave di accesso nella sezione Chiavi di accesso.
Seleziona Servizio di terze parti come Caso d'uso.
Fai clic su Avanti.
(Facoltativo) Aggiungi un tag di descrizione.
Fai clic su Crea chiave di accesso.
Fai clic su Scarica file CSV per salvare la chiave di accesso e la chiave di accesso segreta per un utilizzo successivo.
Fai clic su Fine.
Seleziona la scheda Autorizzazioni.
Fai clic su Aggiungi autorizzazioni nella sezione Criteri per le autorizzazioni.
Seleziona Aggiungi autorizzazioni.
Seleziona Collega direttamente le norme.
Cerca e seleziona il criterio AmazonS3FullAccess.
Fai clic su Avanti.
Fai clic su Aggiungi autorizzazioni.

Configura il ruolo e il criterio IAM per i caricamenti S3

Nella console AWS, vai a IAM > Policy > Crea policy > Scheda JSON.

Inserisci la seguente policy:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowTailscalePutObjects",
      "Effect": "Allow",
      "Action": [
        "s3:PutObject",
        "s3:PutObjectAcl"
      ],
      "Resource": "arn:aws:s3:::tailscale-logs/*"
    }
  ]
}

Sostituisci tailscale-logs se hai inserito un nome bucket diverso.

Fai clic su Avanti > Crea policy.
Vai a IAM > Ruoli > Crea ruolo > Policy di attendibilità personalizzata.

Inserisci la seguente policy di attendibilità:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::982722776073:role/tailscale-log-streaming"
      },
      "Action": "sts:AssumeRole",
      "Condition": {
        "StringEquals": {
          "sts:ExternalId": "YOUR_TAILNET_NAME"
        }
      }
    }
  ]
}

Sostituisci YOUR_TAILNET_NAME con il nome effettivo della tua tailnet.

Fai clic su Avanti.
Collega la norma creata al passaggio 1.
Assegna al ruolo il nome TailscaleS3StreamingRole e fai clic su Crea ruolo.
Copia l'ARN del ruolo da utilizzare nella configurazione di Tailscale.

Configura lo streaming nativo dei log S3 di Tailscale

Configurare lo streaming dei log di controllo della configurazione

Nella Console di amministrazione Tailscale, vai a Log > Log di configurazione.
Fai clic su Avvia streaming.
Seleziona Amazon S3 come destinazione.
Fornisci i seguenti dettagli di configurazione:
- ID account AWS: il tuo ID account AWS.
- Nome bucket S3: tailscale-logs.
- ARN del ruolo: l'ARN del ruolo IAM che hai creato.
- Prefisso chiave S3: tailscale/configuration/ (facoltativo).
Fai clic su Avvia streaming.
Verifica che lo stato sia Attivo.

Configura lo streaming dei log di flusso di rete (solo piano Enterprise)

Se non sono già attivati, vai a Impostazioni > Log di flusso di rete e attiva i log di flusso di rete per la tua tailnet.
Vai a Log > Log di flusso di rete.
Fai clic su Avvia streaming.
Seleziona Amazon S3 come destinazione.
Fornisci i seguenti dettagli di configurazione:
- ID account AWS: il tuo ID account AWS
- Nome bucket S3: tailscale-logs
- ARN del ruolo: l'ARN del ruolo IAM che hai creato
- Prefisso chiave S3: tailscale/network/ (facoltativo)
Fai clic su Avvia streaming.
Verifica che lo stato sia Attivo.

(Facoltativo) Crea chiavi e utenti IAM di sola lettura per Google SecOps

Nella console AWS, vai a IAM > Utenti > Aggiungi utenti.
Fai clic su Add users (Aggiungi utenti).
Fornisci i seguenti dettagli di configurazione:
- Utente: secops-reader
- Tipo di accesso: Chiave di accesso - Accesso programmatico
Fai clic su Crea utente.
Collega criterio per la lettura minima (personalizzata): Utenti > secops-reader > Autorizzazioni > Aggiungi autorizzazioni > Collega policy direttamente > Crea policy.

Nell'editor JSON, inserisci la seguente policy:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::tailscale-logs/*"
    },
    {
      "Effect": "Allow",
      "Action": ["s3:ListBucket"],
      "Resource": "arn:aws:s3:::tailscale-logs"
    }
  ]
}

Imposta il nome su secops-reader-policy.
Vai a Crea criterio > cerca/seleziona > Avanti > Aggiungi autorizzazioni.
Vai a Credenziali di sicurezza > Chiavi di accesso > Crea chiave di accesso.
Scarica il file CSV (questi valori vengono inseriti nel feed).

Configura un feed in Google SecOps per importare i log di Tailscale

Vai a Impostazioni SIEM > Feed.
Fai clic su + Aggiungi nuovo feed.
Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Tailscale logs).
Seleziona Amazon S3 V2 come Tipo di origine.
Seleziona Tailscale come Tipo di log.
Fai clic su Avanti.
Specifica i valori per i seguenti parametri di input:
- URI S3: s3://tailscale-logs/tailscale/
- Opzioni di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze.
- Età massima del file: includi i file modificati nell'ultimo numero di giorni. Il valore predefinito è 180 giorni.
- ID chiave di accesso: chiave di accesso utente con accesso al bucket S3.
- Chiave di accesso segreta: chiave segreta dell'utente con accesso al bucket S3.
- Spazio dei nomi dell'asset: lo spazio dei nomi dell'asset.
- Etichette di importazione: l'etichetta applicata agli eventi di questo feed.
Fai clic su Avanti.
Controlla la nuova configurazione del feed nella schermata Finalizza e poi fai clic su Invia.

Tabella di mappatura UDM

Campo log	mapping UDM	Logica
`exit_traf_src_port_label`	`additional.fields`	Unita
`exit_traf_txBytes_label`	`additional.fields`	Unita
`exit_traf_txPkts_label`	`additional.fields`	Unita
`nodeId_label`	`additional.fields`	Unita
`origin_label`	`additional.fields`	Unita
`phy_traf_rxBytes_label`	`additional.fields`	Unita
`phy_traf_rxPkts_label`	`additional.fields`	Unita
`phy_traf_txBytes_label`	`additional.fields`	Unita
`phy_traf_txPkts_label`	`additional.fields`	Unita
`target1_id_label`	`additional.fields`	Unita
`target1_type_label`	`additional.fields`	Unita
`vir_traf_rxBytes_label`	`additional.fields`	Unita
`vir_traf_rxPkts_label`	`additional.fields`	Unita
`vir_traf_txBytes_label`	`additional.fields`	Unita
`vir_traf_txPkts_label`	`additional.fields`	Unita
`action`	`extensions.auth.type`	Mappato: `LOGIN` → `AUTHTYPE_UNSPECIFIED`
`start`	`metadata.event_timestamp`	Analizzato come `ISO8601`
`event_type`	`metadata.event_type`	Mappato direttamente
`exit_traf.txPkts`	`network.received_bytes`	Mappato direttamente
`index`	`network.received_bytes`	Mappato: `0` → `uinteger`
`phy_traf.rxBytes`	`network.received_bytes`	Mappato direttamente
`phy_traf.rxPkts`	`network.received_bytes`	Mappato direttamente
`exit_traf.txBytes`	`network.sent_bytes`	Mappato direttamente
`index`	`network.sent_bytes`	Mappato: `0` → `uinteger`
`phy_traf.txBytes`	`network.sent_bytes`	Mappato direttamente
`phy_traf.txPkts`	`network.sent_bytes`	Mappato direttamente
`target1.name`	`principal.asset.hostname`	Mappato direttamente
`src_ip`	`principal.asset.ip`	Unita
`target1.name`	`principal.hostname`	Mappato direttamente
`src_ip`	`principal.ip`	Unita
`src_port`	`principal.port`	Mappato direttamente
`action`	`security_result.action_details`	Mappato direttamente
`action_details_label`	`security_result.detection_fields`	Unita
`eventGroupID_label`	`security_result.detection_fields`	Unita
`dst_ip`	`target.asset.ip`	Unita
`dst_ip`	`target.ip`	Unita
`dst_port`	`target.port`	Mappato direttamente
`actor_loginName`	`target.user.email_addresses`	Unita
`actor_display_name`	`target.user.user_display_name`	Mappato direttamente
`actor_id`	`target.user.userid`	Mappato direttamente
N/D	`extensions.auth.type`	Costante: `AUTHTYPE_UNSPECIFIED`
N/D	`metadata.event_type`	Costante: `GENERIC_EVENT`

Log delle modifiche

Visualizza il log delle modifiche per questo parser

Hai bisogno di ulteriore assistenza? Ricevi risposte dai membri della community e dai professionisti di Google SecOps.