Esempio 1: filtri di sottoscrizione con Kinesis Data Streams Esempio 2: filtri di abbonamento con AWS Lambda Esempio 3: filtri di abbonamento con Amazon Data Firehose

Filtri di abbonamento a livello di account

Importante

Esiste il rischio di creare un ciclo ricorsivo infinito con i filtri di abbonamento, che può portare a un forte aumento della fatturazione di importazione se non viene risolto il problema. Per mitigare questo rischio, si consiglia di utilizzare criteri di selezione nei filtri di abbonamento a livello di account per escludere i gruppi di log che acquisiscono i dati di registro dalle risorse che fanno parte del flusso di lavoro di distribuzione dell'abbonamento. Per ulteriori informazioni su questo problema e per determinare quali gruppi di log escludere, vedere. Registra la prevenzione della ricorsione

È possibile impostare una politica di sottoscrizione a livello di account che includa un sottoinsieme di gruppi di log nell'account. La politica di sottoscrizione dell'account può funzionare con Kinesis Data Streams, Lambda o Firehose. I log inviati a un servizio di ricezione tramite una politica di abbonamento a livello di account sono codificati in base64 e compressi con il formato gzip.

Nota

Per visualizzare un elenco di tutte le politiche di filtro degli abbonamenti presenti nel tuo account, utilizza il describe-account-policies comando con il valore per il parametro. SUBSCRIPTION_FILTER_POLICY --policy-type Per ulteriori informazioni, vedere describe-account-policies¶.

Esempi

Esempio 1: filtri di sottoscrizione con Kinesis Data Streams
Esempio 2: filtri di abbonamento con AWS Lambda
Esempio 3: filtri di abbonamento con Amazon Data Firehose

Esempio 1: filtri di sottoscrizione con Kinesis Data Streams

Prima di creare un flusso di dati Kinesis Data Streams da utilizzare con una politica di abbonamento a livello di account, calcola il volume di dati di registro che verranno generati. Assicurati di creare un flusso che includa partizioni sufficienti per gestire questo volume. Se uno stream non ha abbastanza shard, viene limitato. Per ulteriori informazioni sui limiti del volume dello stream, consulta Quote e limiti nella documentazione di Kinesis Data Streams.

avvertimento

Poiché gli eventi di registro di più gruppi di log vengono inoltrati alla destinazione, esiste il rischio di limitazione. Vengono fatti nuovi tentativi per i risultati limitati per un massimo di 24 ore. Dopo 24 ore, i risultati non riusciti saranno eliminati.

Per ridurre il rischio di limitazione, procedi nel seguente modo:

Monitora il tuo flusso Kinesis Data Streams CloudWatch con le metriche. Questo ti aiuta a identificare le limitazioni e ad adattare la configurazione di conseguenza. Ad esempio, la DeliveryThrottling metrica tiene traccia del numero di eventi di registro per i quali CloudWatch Logs è stato limitato durante l'inoltro dei dati alla destinazione dell'abbonamento. Per ulteriori informazioni, consulta Monitoraggio con CloudWatch metriche.
Usa la modalità di capacità on demand per il tuo flusso in Kinesis Data Streams. La modalità on demand si adatta istantaneamente ai carichi di lavoro siano essi aumentati o diminuiti. Per ulteriori informazioni, consulta la modalità On-demand.
Limita il modello di filtro dell'abbonamento CloudWatch Logs in modo che corrisponda alla capacità del tuo stream in Kinesis Data Streams. Se invii una quantità eccessiva di dati al flusso, potrebbe essere necessario ridurre le dimensioni del filtro o modificarne i criteri.

L'esempio seguente utilizza una politica di sottoscrizione a livello di account per inoltrare tutti gli eventi di registro a uno stream in Kinesis Data Streams. Lo schema di filtro abbina tutti gli eventi di registro al testo Test e li inoltra allo stream in Kinesis Data Streams.

Per creare una politica di sottoscrizione a livello di account per Kinesis Data Streams

Crea un flusso di destinazione utilizzando il comando seguente:


$ C:\>  aws kinesis create-stream —stream-name "TestStream" —shard-count 1

Attendi qualche minuto che lo stream diventi attivo. Puoi verificare se lo stream è attivo utilizzando il comando describe-stream per controllare il. StreamDescription StreamStatusproprietà.


aws kinesis describe-stream --stream-name "TestStream"

Di seguito è riportato un output di esempio:


{
    "StreamDescription": {
        "StreamStatus": "ACTIVE",
        "StreamName": "TestStream",
        "StreamARN": "arn:aws:kinesis:region:123456789012:stream/TestStream",
        "Shards": [
            {
                "ShardId": "shardId-000000000000",
                "HashKeyRange": {
                    "EndingHashKey": "EXAMPLE8463463374607431768211455",
                    "StartingHashKey": "0"
                },
                "SequenceNumberRange": {
                    "StartingSequenceNumber":
                    "EXAMPLE688818456679503831981458784591352702181572610"
                }
            }
        ]
    }
}

Crea il ruolo IAM che concederà a CloudWatch Logs l'autorizzazione a inserire dati nel tuo stream. In primo luogo, sarà necessario creare una policy di attendibilità in un file (ad esempio, ~/TrustPolicyForCWL-Kinesis.json). Utilizza un editor di testo per creare questa policy.

Questa policy include una chiave di contesto della condizione globale aws:SourceArn per prevenire il problema di sicurezza noto come "confused deputy". Per ulteriori informazioni, consulta Prevenzione del "confused deputy".
```
{
  "Statement": {
    "Effect": "Allow",
    "Principal": { "Service": "logs.amazonaws.com" },
    "Action": "sts:AssumeRole",
    "Condition": { 
        "StringLike": { "aws:SourceArn": "arn:aws:logs:region:123456789012:*" } 
     }
   }
}
```

Utilizza il comando create-role per creare un ruolo IAM, specificando il file della policy di attendibilità. Annota il valore Role.Arn restituito, poiché ne avrai bisogno anche in una fase successiva:


aws iam create-role --role-name CWLtoKinesisRole --assume-role-policy-document file://~/TrustPolicyForCWL-Kinesis.json

Di seguito è riportato un esempio di output.


{
    "Role": {
        "AssumeRolePolicyDocument": {
            "Statement": {
                "Action": "sts:AssumeRole",
                "Effect": "Allow",
                "Principal": {
                    "Service": "logs.amazonaws.com"
                },
                "Condition": { 
                    "StringLike": { 
                        "aws:SourceArn": { "arn:aws:logs:region:123456789012:*" }
                    } 
                }
            }
        },
        "RoleId": "EXAMPLE450GAB4HC5F431",
        "CreateDate": "2023-05-29T13:46:29.431Z",
        "RoleName": "CWLtoKinesisRole",
        "Path": "/",
        "Arn": "arn:aws:iam::123456789012:role/CWLtoKinesisRole"
    }
}

Crea una politica di autorizzazioni per definire quali azioni CloudWatch Logs può eseguire sul tuo account. In primo luogo, creerai una policy delle autorizzazioni in un file (ad esempio, ~/PermissionsForCWL-Kinesis.json). Utilizza un editor di testo per creare questa policy. Non utilizzare la console IAM per crearla.
```
{
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "kinesis:PutRecord",
      "Resource": "arn:aws:kinesis:region:123456789012:stream/TestStream"
    }
  ]
}
```

Associa la politica delle autorizzazioni al ruolo utilizzando il seguente put-role-policycomando:


aws iam put-role-policy  --role-name CWLtoKinesisRole  --policy-name Permissions-Policy-For-CWL  --policy-document file://~/PermissionsForCWL-Kinesis.json

Dopo che lo stream è nello stato Attivo e hai creato il ruolo IAM, puoi creare la politica di filtro di sottoscrizione CloudWatch Logs. La policy avvia immediatamente il flusso di dati di registro in tempo reale verso il tuo stream. In questo esempio, tutti gli eventi di registro che contengono la stringa ERROR vengono trasmessi in streaming, ad eccezione di quelli nei gruppi di log denominati LogGroupToExclude1 andLogGroupToExclude2.


aws logs put-account-policy \
    --policy-name "ExamplePolicy" \
    --policy-type "SUBSCRIPTION_FILTER_POLICY" \
    --policy-document '{"RoleArn":"arn:aws:iam::123456789012:role/CWLtoKinesisRole", "DestinationArn":"arn:aws:kinesis:region:123456789012:stream/TestStream", "FilterPattern": "Test", "Distribution": "Random"}' \
    --selection-criteria 'LogGroupName NOT IN ["LogGroupToExclude1", "LogGroupToExclude2"]' \
    --scope "ALL"

Dopo aver impostato il filtro di abbonamento, CloudWatch Logs inoltra tutti gli eventi di registro in entrata che corrispondono al modello di filtro e ai criteri di selezione allo stream.

Il selection-criteria campo è facoltativo, ma è importante per escludere i gruppi di log che possono causare una ricorsione infinita dei log da un filtro di sottoscrizione. Per ulteriori informazioni su questo problema e per determinare quali gruppi di log escludere, vedere. Registra la prevenzione della ricorsione Attualmente, NOT IN è l'unico operatore supportato perselection-criteria.

È possibile verificare il flusso di eventi di registro utilizzando un iteratore di shard Kinesis Data Streams e utilizzando il get-records comando Kinesis Data Streams per recuperare alcuni record Kinesis Data Streams:
```
aws kinesis get-shard-iterator --stream-name TestStream --shard-id shardId-000000000000 --shard-iterator-type TRIM_HORIZON
```
```
{
    "ShardIterator":
    "AAAAAAAAAAFGU/kLvNggvndHq2UIFOw5PZc6F01s3e3afsSscRM70JSbjIefg2ub07nk1y6CDxYR1UoGHJNP4m4NFUetzfL+wev+e2P4djJg4L9wmXKvQYoE+rMUiFq+p4Cn3IgvqOb5dRA0yybNdRcdzvnC35KQANoHzzahKdRGb9v4scv+3vaq+f+OIK8zM5My8ID+g6rMo7UKWeI4+IWiK2OSh0uP"
}
```
```
aws kinesis get-records --limit 10 --shard-iterator "AAAAAAAAAAFGU/kLvNggvndHq2UIFOw5PZc6F01s3e3afsSscRM70JSbjIefg2ub07nk1y6CDxYR1UoGHJNP4m4NFUetzfL+wev+e2P4djJg4L9wmXKvQYoE+rMUiFq+p4Cn3IgvqOb5dRA0yybNdRcdzvnC35KQANoHzzahKdRGb9v4scv+3vaq+f+OIK8zM5My8ID+g6rMo7UKWeI4+IWiK2OSh0uP"
```
Potrebbe essere necessario utilizzare questo comando alcune volte prima che Kinesis Data Streams inizi a restituire dati.

In genere si visualizzerà una risposta con una matrice di record. L'attributo Dati in un record Kinesis Data Streams usa la codifica base64 e la compressione nel formato gzip. Puoi esaminare i dati non elaborati dalla riga di comando utilizzando i seguenti comandi Unix:
```
echo -n "<Content of Data>" | base64 -d | zcat
```
I dati con codifica base64 e decompressi sono in formato JSON con la seguente struttura:
```
{ 
    "messageType": "DATA_MESSAGE",
    "owner": "123456789012",
    "logGroup": "Example1",
    "logStream": "logStream1",
    "subscriptionFilters": [ 
        "ExamplePolicy" 
    ],
    "logEvents": [ 
        { 
            "id": "31953106606966983378809025079804211143289615424298221568",
            "timestamp": 1432826855000,
            "message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}"
        },
        { 
            "id": "31953106606966983378809025079804211143289615424298221569",
            "timestamp": 1432826855000,
            "message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}" 
        }, 
        { 
            "id": "31953106606966983378809025079804211143289615424298221570",
            "timestamp": 1432826855000,
            "message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}" 
        } 
    ],
    "policyLevel": "ACCOUNT_LEVEL_POLICY"
}
```
Gli elementi chiave della struttura dei dati sono i seguenti:

messageType

I messaggi di dati utilizzeranno il tipo "DATA_MESSAGE". A volte CloudWatch i log possono emettere record Kinesis Data Streams di tipo «CONTROL_MESSAGE», principalmente per verificare se la destinazione è raggiungibile.

owner

L' AWS ID dell'account dei dati di registro di origine.

logGroup

Nome del gruppo di log dei dati di log originari.

logStream

Nome del flusso di log dei dati di log originari.

subscriptionFilters

Elenco dei nomi di filtro sottoscrizione che corrispondono con i dati di log originari.

logEvents

I dati di log effettivi, rappresentati come una varietà di record di eventi di log. La proprietà "id" è un identificatore univoco per ogni log eventi.

Livello di politica

Il livello al quale è stata applicata la politica. «ACCOUNT_LEVEL_POLICY» è il criterio di filtro degli abbonamenti a livello policyLevel di account.

Esempio 2: filtri di abbonamento con AWS Lambda

In questo esempio, creerai una politica di filtro degli abbonamenti a livello di account CloudWatch Logs che invia i dati di registro alla tua funzione. AWS Lambda

avvertimento

Prima di creare la funzione Lambda, calcola il volume dei dati di log che verrà generato. Assicurati di creare una funzione che possa gestire questo volume. Se la funzione non è in grado di gestire il volume, il flusso di log verrà limitato. Poiché gli eventi di registro di tutti i gruppi di log o di un sottoinsieme dei gruppi di log dell'account vengono inoltrati alla destinazione, esiste il rischio di limitazione. Per ulteriori informazioni sui limiti di Lambda, consulta Limiti di AWS Lambda.

Per creare una politica di filtro degli abbonamenti a livello di account per Lambda

Crea la funzione. AWS Lambda

Assicurati di aver configurato il ruolo di esecuzione di Lambda. Per ulteriori informazioni, consulta Fase 2.2: creazione di un ruolo IAM (ruolo di esecuzione) nella Guida per gli sviluppatori AWS Lambda .

Apri un editor di testo e crea un file denominato helloWorld.js con il seguente contenuto:


var zlib = require('zlib');
exports.handler = function(input, context) {
    var payload = Buffer.from(input.awslogs.data, 'base64');
    zlib.gunzip(payload, function(e, result) {
        if (e) { 
            context.fail(e);
        } else {
            result = JSON.parse(result.toString());
            console.log("Event Data:", JSON.stringify(result, null, 2));
            context.succeed();
        }
    });
};

Comprimi il file helloWorld.js e salvalo con il nome helloWorld.zip.

Utilizza il comando seguente, in cui il ruolo è il ruolo di esecuzione Lambda configurato nella prima fase:


aws lambda create-function \
    --function-name helloworld \
    --zip-file fileb://file-path/helloWorld.zip \
    --role lambda-execution-role-arn \
    --handler helloWorld.handler \
    --runtime nodejs18.x

Concedi a CloudWatch Logs il permesso di eseguire la tua funzione. Usa il seguente comando, sostituendo l'account segnaposto con il tuo account.


aws lambda add-permission \
    --function-name "helloworld" \
    --statement-id "helloworld" \
    --principal "logs.amazonaws.com" \
    --action "lambda:InvokeFunction" \
    --source-arn "arn:aws:logs:region:123456789012:log-group:*" \
    --source-account "123456789012"

Crea una politica di filtro degli abbonamenti a livello di account utilizzando il seguente comando, sostituendo l'account segnaposto con il tuo account. In questo esempio, tutti gli eventi di registro che contengono la stringa ERROR vengono trasmessi in streaming, ad eccezione di quelli nei gruppi di log denominati and. LogGroupToExclude1 LogGroupToExclude2
```
aws logs put-account-policy \
    --policy-name "ExamplePolicyLambda" \
    --policy-type "SUBSCRIPTION_FILTER_POLICY" \
    --policy-document '{"DestinationArn":"arn:aws:lambda:region:123456789012:function:helloWorld", "FilterPattern": "Test", "Distribution": "Random"}' \
    --selection-criteria 'LogGroupName NOT IN ["LogGroupToExclude1", "LogGroupToExclude2"]' \
    --scope "ALL"
```
Dopo aver impostato il filtro di abbonamento, CloudWatch Logs inoltra tutti gli eventi di registro in entrata che corrispondono al modello di filtro e ai criteri di selezione allo stream.

Il selection-criteria campo è facoltativo, ma è importante per escludere i gruppi di log che possono causare una ricorsione infinita dei log da un filtro di sottoscrizione. Per ulteriori informazioni su questo problema e per determinare quali gruppi di log escludere, vedere. Registra la prevenzione della ricorsione Attualmente, NOT IN è l'unico operatore supportato perselection-criteria.
Verifica tramite un log eventi di esempio (facoltativo). Al prompt dei comandi, esegui il comando seguente, il quale inserirà un semplice messaggio di log nel flusso sottoscritto.

Per visualizzare l'output della funzione Lambda, passa alla funzione Lambda, in cui potrai visualizzare l'output in /aws/lambda/helloworld:
```
aws logs put-log-events --log-group-name Example1 --log-stream-name logStream1 --log-events "[{\"timestamp\":CURRENT TIMESTAMP MILLIS , \"message\": \"Simple Lambda Test\"}]"
```
Dovresti visualizzare una risposta con una matrice di Lambda. L'attributo Data (Dati) nel log Lambda usa la codifica base64 e la compressione nel formato gzip. Il payload effettivo che Lambda riceve è nel formato seguente, { "awslogs": {"data": "BASE64ENCODED_GZIP_COMPRESSED_DATA"} }. Puoi esaminare i dati non elaborati dalla riga di comando utilizzando i seguenti comandi Unix:
```
echo -n "<BASE64ENCODED_GZIP_COMPRESSED_DATA>" | base64 -d | zcat
```
I dati con codifica base64 e decompressi sono in formato JSON con la seguente struttura:
```
{ 
    "messageType": "DATA_MESSAGE",
    "owner": "123456789012",
    "logGroup": "Example1",
    "logStream": "logStream1",
    "subscriptionFilters": [ 
        "ExamplePolicyLambda" 
    ],
    "logEvents": [ 
        { 
            "id": "31953106606966983378809025079804211143289615424298221568",
            "timestamp": 1432826855000,
            "message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}"
        },
        { 
            "id": "31953106606966983378809025079804211143289615424298221569",
            "timestamp": 1432826855000,
            "message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}" 
        }, 
        { 
            "id": "31953106606966983378809025079804211143289615424298221570",
            "timestamp": 1432826855000,
            "message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}" 
        } 
    ],
    "policyLevel": "ACCOUNT_LEVEL_POLICY"
}
```
Nota
Il filtro di sottoscrizione a livello di account non verrà applicato al gruppo di log della funzione Lambda di destinazione. Questo serve a prevenire una ricorsione infinita dei log che può portare a un aumento della fatturazione di importazione. Per ulteriori informazioni su questo problema, vedere. Registra la prevenzione della ricorsione

Gli elementi chiave della struttura dei dati sono i seguenti:

messageType

I messaggi di dati utilizzeranno il tipo "DATA_MESSAGE". A volte CloudWatch i log possono emettere record Kinesis Data Streams di tipo «CONTROL_MESSAGE», principalmente per verificare se la destinazione è raggiungibile.

owner

L' AWS ID dell'account dei dati di registro di origine.

logGroup

Nome del gruppo di log dei dati di log originari.

logStream

Nome del flusso di log dei dati di log originari.

subscriptionFilters

Elenco dei nomi di filtro sottoscrizione che corrispondono con i dati di log originari.

logEvents

I dati di log effettivi, rappresentati come una varietà di record di eventi di log. La proprietà "id" è un identificatore univoco per ogni log eventi.

Livello di politica

Il livello al quale è stata applicata la politica. «ACCOUNT_LEVEL_POLICY» è il criterio di filtro degli abbonamenti a livello policyLevel di account.

Esempio 3: filtri di abbonamento con Amazon Data Firehose

In questo esempio, creerai una politica di filtro di abbonamento CloudWatch Logs a livello di account che invia gli eventi di registro in entrata che corrispondono ai filtri definiti al flusso di distribuzione di Amazon Data Firehose. I dati inviati dai CloudWatch log ad Amazon Data Firehose sono già compressi con la compressione gzip di livello 6, quindi non è necessario utilizzare la compressione all'interno del flusso di distribuzione Firehose. È quindi possibile utilizzare la funzionalità di decompressione di Firehose per decomprimere automaticamente i registri. Per ulteriori informazioni, vedere Writing to Kinesis Data CloudWatch Firehose Using Logs.

avvertimento

Prima di creare lo stream Firehose, calcolate il volume di dati di registro che verranno generati. Assicurati di creare uno stream Firehose in grado di gestire questo volume. Se il flusso non è in grado di gestire il volume, il flusso di log verrà limitato. Per ulteriori informazioni sui limiti del volume dello stream Firehose, consulta Amazon Data Firehose Data Limits.

Per creare un filtro di abbonamento per Firehose

Crea un bucket Amazon Simple Storage Service (Amazon S3). Ti consigliamo di utilizzare un bucket creato appositamente per CloudWatch i log. Tuttavia, se intendi utilizzare un bucket esistente, puoi passare alla fase 2.

Esegui il comando seguente, sostituendo il segnaposto Regione con la Regione che desideri utilizzare:
```
aws s3api create-bucket --bucket my-bucket --create-bucket-configuration LocationConstraint=region
```
Di seguito è riportato un output di esempio:
```
{
    "Location": "/my-bucket"
}
```
Crea il ruolo IAM che concede ad Amazon Data Firehose l'autorizzazione a inserire dati nel tuo bucket Amazon S3.

Per ulteriori informazioni, consulta Controlling Access with Amazon Data Firehose nella Amazon Data Firehose Developer Guide.

In primo luogo, utilizza un editor di testo per creare una policy di attendibilità in un file ~/TrustPolicyForFirehose.json, come segue:
```
{
  "Statement": {
    "Effect": "Allow",
    "Principal": { "Service": "firehose.amazonaws.com" },
    "Action": "sts:AssumeRole"
    } 
}
```

Utilizza il comando create-role per creare un ruolo IAM, specificando il file della policy di attendibilità. Prendi nota del valore Role.Arn restituito, poiché ti servirà in un passaggio successivo:


aws iam create-role \
 --role-name FirehosetoS3Role \
 --assume-role-policy-document file://~/TrustPolicyForFirehose.json

{
    "Role": {
        "AssumeRolePolicyDocument": {
            "Statement": {
                "Action": "sts:AssumeRole",
                "Effect": "Allow",
                "Principal": {
                    "Service": "firehose.amazonaws.com"
                }
            }
        },
        "RoleId": "EXAMPLE50GAB4HC5F431",
        "CreateDate": "2023-05-29T13:46:29.431Z",
        "RoleName": "FirehosetoS3Role",
        "Path": "/",
        "Arn": "arn:aws:iam::123456789012:role/FirehosetoS3Role"
    }
}

Crea una politica di autorizzazioni per definire quali azioni Firehose può eseguire sul tuo account. In primo luogo, utilizza un editor di testo per creare una policy di autorizzazione in un file ~/PermissionsForFirehose.json:


{
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [ 
          "s3:AbortMultipartUpload", 
          "s3:GetBucketLocation", 
          "s3:GetObject", 
          "s3:ListBucket", 
          "s3:ListBucketMultipartUploads", 
          "s3:PutObject" ],
      "Resource": [ 
          "arn:aws:s3:::my-bucket", 
          "arn:aws:s3:::my-bucket/*" ]
    }
  ]
}

Associate la politica delle autorizzazioni al ruolo utilizzando il seguente comando: put-role-policy


aws iam put-role-policy --role-name FirehosetoS3Role --policy-name Permissions-Policy-For-Firehose --policy-document file://~/PermissionsForFirehose.json

Crea un flusso di distribuzione Firehose di destinazione come segue, sostituendo i valori segnaposto per ROLearn e bucketARN con gli ARN role e bucket che hai creato:
```
aws firehose create-delivery-stream \
   --delivery-stream-name 'my-delivery-stream' \
   --s3-destination-configuration \
  '{"RoleARN": "arn:aws:iam::123456789012:role/FirehosetoS3Role", "BucketARN": "arn:aws:s3:::my-bucket"}'
                    
```
NFirehose utilizza automaticamente un prefisso nel formato orario UTC YYYY/MM/DD/HH per gli oggetti Amazon S3 consegnati. Puoi specificare un ulteriore prefisso da aggiungere davanti al prefisso del formato data e ora. Se il prefisso termina con una barra (/), viene visualizzato come cartella nel bucket Amazon S3.

Attendi qualche minuto che lo stream diventi attivo. È possibile utilizzare il describe-delivery-streamcomando Firehose per controllare il. DeliveryStreamDescription DeliveryStreamStatusproprietà. Inoltre, nota il DeliveryStreamDescription. DeliveryStreamValore ARN, in quanto sarà necessario in un passaggio successivo:


aws firehose describe-delivery-stream --delivery-stream-name "my-delivery-stream"
{
    "DeliveryStreamDescription": {
        "HasMoreDestinations": false,
        "VersionId": "1",
        "CreateTimestamp": 1446075815.822,
        "DeliveryStreamARN": "arn:aws:firehose:us-east-1:123456789012:deliverystream/my-delivery-stream",
        "DeliveryStreamStatus": "ACTIVE",
        "DeliveryStreamName": "my-delivery-stream",
        "Destinations": [
            {
                "DestinationId": "destinationId-000000000001",
                "S3DestinationDescription": {
                    "CompressionFormat": "UNCOMPRESSED",
                    "EncryptionConfiguration": {
                        "NoEncryptionConfig": "NoEncryption"
                    },
                    "RoleARN": "delivery-stream-role",
                    "BucketARN": "arn:aws:s3:::my-bucket",
                    "BufferingHints": {
                        "IntervalInSeconds": 300,
                        "SizeInMBs": 5
                    }
                }
            }
        ]
    }
}

Crea il ruolo IAM che concede a CloudWatch Logs l'autorizzazione a inserire i dati nel tuo flusso di distribuzione Firehose. In primo luogo, utilizza un editor di testo per creare una policy di attendibilità in un file ~/TrustPolicyForCWL.json:

Questa policy include una chiave di contesto della condizione globale aws:SourceArn per prevenire il problema di sicurezza noto come "confused deputy". Per ulteriori informazioni, consulta Prevenzione del "confused deputy".
```
{
  "Statement": {
    "Effect": "Allow",
    "Principal": { "Service": "logs.amazonaws.com" },
    "Action": "sts:AssumeRole",
    "Condition": { 
         "StringLike": { 
             "aws:SourceArn": "arn:aws:logs:region:123456789012:*"
         } 
     }
  }
}
```


aws iam create-role \
--role-name CWLtoKinesisFirehoseRole \
--assume-role-policy-document file://~/TrustPolicyForCWL.json

{
    "Role": {
        "AssumeRolePolicyDocument": {
            "Statement": {
                "Action": "sts:AssumeRole",
                "Effect": "Allow",
                "Principal": {
                    "Service": "logs.amazonaws.com"
                },
                "Condition": { 
                     "StringLike": { 
                         "aws:SourceArn": "arn:aws:logs:region:123456789012:*"
                     } 
                 }
            }
        },
        "RoleId": "AAOIIAH450GAB4HC5F431",
        "CreateDate": "2015-05-29T13:46:29.431Z",
        "RoleName": "CWLtoKinesisFirehoseRole",
        "Path": "/",
        "Arn": "arn:aws:iam::123456789012:role/CWLtoKinesisFirehoseRole"
    }
}

Crea una politica di autorizzazioni per definire quali azioni i CloudWatch log possono eseguire sul tuo account. In primo luogo, utilizza un editor di testo per creare un file di policy di autorizzazioni (ad esempio, ~/PermissionsForCWL.json):
```
{
    "Statement":[
      {
        "Effect":"Allow",
        "Action":["firehose:PutRecord"],
        "Resource":[
            "arn:aws:firehose:region:account-id:deliverystream/delivery-stream-name"]
      }
    ]
}
```

Associa la politica delle autorizzazioni al ruolo utilizzando il comando: put-role-policy


aws iam put-role-policy --role-name CWLtoKinesisFirehoseRole --policy-name Permissions-Policy-For-CWL --policy-document file://~/PermissionsForCWL.json

Dopo che il flusso di distribuzione di Amazon Data Firehose è attivo e hai creato il ruolo IAM, puoi creare la policy di filtro di sottoscrizione a livello di account CloudWatch Logs. La policy avvia immediatamente il flusso di dati di log in tempo reale dal gruppo di log scelto al flusso di distribuzione di Amazon Data Firehose:


aws logs put-account-policy \
    --policy-name "ExamplePolicyFirehose" \
    --policy-type "SUBSCRIPTION_FILTER_POLICY" \
    --policy-document '{"RoleArn":"arn:aws:iam::123456789012:role/CWLtoKinesisFirehoseRole", "DestinationArn":"arn:aws:firehose:us-east-1:123456789012:deliverystream/delivery-stream-name", "FilterPattern": "Test", "Distribution": "Random"}' \
    --selection-criteria 'LogGroupName NOT IN ["LogGroupToExclude1", "LogGroupToExclude2"]' \
    --scope "ALL"

Dopo aver configurato il filtro di abbonamento, CloudWatch Logs inoltra gli eventi di log in entrata che corrispondono al modello di filtro al flusso di distribuzione di Amazon Data Firehose.

Il selection-criteria campo è facoltativo, ma è importante per escludere i gruppi di log che possono causare una ricorsione infinita dei log da un filtro di sottoscrizione. Per ulteriori informazioni su questo problema e per determinare quali gruppi di log escludere, vedere. Registra la prevenzione della ricorsione Attualmente, NOT IN è l'unico operatore supportato perselection-criteria.

I tuoi dati inizieranno a comparire in Amazon S3 in base all'intervallo di tempo impostato nel flusso di distribuzione di Amazon Data Firehose. Quando è trascorso tempo sufficiente, puoi verificare i dati controllando il Bucket Amazon S3.


aws s3api list-objects --bucket 'my-bucket' --prefix 'firehose/'
{
    "Contents": [
        {
            "LastModified": "2023-10-29T00:01:25.000Z",
            "ETag": "\"a14589f8897f4089d3264d9e2d1f1610\"",
            "StorageClass": "STANDARD",
            "Key": "firehose/2015/10/29/00/my-delivery-stream-2015-10-29-00-01-21-a188030a-62d2-49e6-b7c2-b11f1a7ba250",
            "Owner": {
                "DisplayName": "cloudwatch-logs",
                "ID": "1ec9cf700ef6be062b19584e0b7d84ecc19237f87b5"
            },
            "Size": 593
        },
        {
            "LastModified": "2015-10-29T00:35:41.000Z",
            "ETag": "\"a7035b65872bb2161388ffb63dd1aec5\"",
            "StorageClass": "STANDARD",
            "Key": "firehose/2023/10/29/00/my-delivery-stream-2023-10-29-00-35-40-EXAMPLE-7e66-49bc-9fd4-fc9819cc8ed3",
            "Owner": {
                "DisplayName": "cloudwatch-logs",
                "ID": "EXAMPLE6be062b19584e0b7d84ecc19237f87b6"
            },
            "Size": 5752
        }
    ]
}


aws s3api get-object --bucket 'my-bucket' --key 'firehose/2023/10/29/00/my-delivery-stream-2023-10-29-00-01-21-a188030a-62d2-49e6-b7c2-b11f1a7ba250' testfile.gz

{
    "AcceptRanges": "bytes",
    "ContentType": "application/octet-stream",
    "LastModified": "Thu, 29 Oct 2023 00:07:06 GMT",
    "ContentLength": 593,
    "Metadata": {}
}

I dati nell'oggetto di Amazon S3 vengono compressi nel formato gzip. Puoi esaminare i dati non elaborati dalla riga di comando utilizzando i seguenti comandi Unix:


zcat testfile.gz

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Registra i filtri di abbonamento a livello di gruppo

Abbonamenti tra più account e più regioni