Filtri di sottoscrizione a livello di gruppo di log

Crea un flusso di destinazione utilizzando il comando seguente:

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

Attendi finché il flusso non diventa attivo. Questa operazione può richiedere uno o due minuti. Puoi utilizzare il seguente comando https://docs.aws.amazon.com/cli/latest/reference/kinesis/describe-stream.html describe-stream di Amazon Kinesis Data Streams per verificare la proprietà. StreamDescription.StreamStatus Inoltre, annota il StreamDescription.StreamARN valore, poiché ti servirà in una fase successiva:

aws kinesis describe-stream --stream-name "RootAccess"

Di seguito è riportato un output di esempio:

{
    "StreamDescription": {
        "StreamStatus": "ACTIVE",
        "StreamName": "RootAccess",
        "StreamARN": "arn:aws:kinesis:us-east-1:123456789012:stream/RootAccess",
        "Shards": [
            {
                "ShardId": "shardId-000000000000",
                "HashKeyRange": {
                    "EndingHashKey": "340282366920938463463374607431768211455",
                    "StartingHashKey": "0"
                },
                "SequenceNumberRange": {
                    "StartingSequenceNumber":
                    "49551135218688818456679503831981458784591352702181572610"
                }
            }
        ]
    }
}

Crea il ruolo IAM che concederà a CloudWatch Logs il permesso di 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. Non utilizzare la console IAM per crearla.

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": { 
        "ArnLike": { "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 Role.Arn valore restituito, poiché ti servirà anche per un passaggio successivo:

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": "AAOIIAH450GAB4HC5F431",
        "CreateDate": "2015-05-29T13:46:29.431Z",
        "RoleName": "CWLtoKinesisRole",
        "Path": "/",
        "Arn": "arn:aws:iam::123456789012:role/CWLtoKinesisRole"
    }
}

Crea una politica di autorizzazioni per definire le azioni che 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/RootAccess"
    }
  ]
}

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

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

Dopo che lo stream è in stato attivo e hai creato il ruolo IAM, puoi creare il filtro di sottoscrizione CloudWatch Logs. Il filtro sottoscrizioni avvia immediatamente il flusso di dati di log in tempo reale dal gruppo di log selezionato nel flusso :

aws logs put-subscription-filter \
    --log-group-name "CloudTrail/logs" \
    --filter-name "RootAccess" \
    --filter-pattern "{$.userIdentity.type = Root}" \
    --destination-arn "arn:aws:kinesis:region:123456789012:stream/RootAccess" \
    --role-arn "arn:aws:iam::123456789012:role/CWLtoKinesisRole"

Dopo aver impostato il filtro delle sottoscrizioni, CloudWatch Logs inoltra al tuo stream tutti gli eventi di log in entrata che corrispondono al pattern di filtro. Puoi verificare che ciò avvenga utilizzando un iteratore shard di Amazon Kinesis Data Streams e utilizzando il comando Amazon Kinesis Data Streams get-records per recuperare alcuni record di Amazon Kinesis Data Streams:

aws kinesis get-shard-iterator --stream-name RootAccess --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"

Tieni presente che potresti dover effettuare questa chiamata alcune volte prima che Amazon Kinesis Data Streams inizi a restituire i dati.

In genere si visualizzerà una risposta con una matrice di record. L'attributo Data in un record Amazon Kinesis Data Streams è codificato in base64 e compresso con il 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:

{
    "owner": "111111111111",
    "logGroup": "CloudTrail/logs",
    "logStream": "111111111111_CloudTrail/logs_us-east-1",
    "subscriptionFilters": [
        "Destination"
    ],
    "messageType": "DATA_MESSAGE",
    "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\"}"
        }
    ]
}

Gli elementi chiave nella struttura di dati precedente sono i seguenti:

Crea la AWS Lambda funzione.

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 hello World.js e salvalo con il nomehelloWorld.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 nodejs12.x

Grant CloudWatch Logs consente di eseguire la tua funzione. Utilizza il comando seguente, sostituendo l'account di segnaposto con il tuo account e il gruppo di log di segnaposto con il gruppo di log da elaborare:

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

Crea un filtro di sottoscrizione utilizzando il comando seguente, sostituendo l'account di segnaposto con il tuo account e il gruppo di log di segnaposto con il gruppo di log da elaborare:

aws logs put-subscription-filter \
    --log-group-name myLogGroup \
    --filter-name demo \
    --filter-pattern "" \
    --destination-arn arn:aws:lambda:region:123456789123:function:helloworld

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 vedere l'output della tua funzione Lambda, vai alla funzione Lambda dove vedrai l'output in/aws/lambda/helloworld:

aws logs put-log-events --log-group-name myLogGroup --log-stream-name stream1 --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:

{
    "owner": "123456789012",
    "logGroup": "CloudTrail",
    "logStream": "123456789012_CloudTrail_us-east-1",
    "subscriptionFilters": [
        "Destination"
    ],
    "messageType": "DATA_MESSAGE",
    "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\"}"
        }
    ]
}

Gli elementi chiave nella struttura di dati precedente sono i seguenti:

Crea un bucket Amazon Simple Storage Service (Amazon S3). Ti consigliamo di utilizzare un bucket creato appositamente per CloudWatch Logs. 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 amzn-s3-demo-bucket2 --create-bucket-configuration LocationConstraint=region

Di seguito è riportato un output di esempio:

{
    "Location": "/amzn-s3-demo-bucket2"
}

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à. Annota il Role.Arn valore restituito, poiché ti servirà in una fase successiva:

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": "AAOIIAH450GAB4HC5F431",
        "CreateDate": "2015-05-29T13:46:29.431Z",
        "RoleName": "FirehosetoS3Role",
        "Path": "/",
        "Arn": "arn:aws:iam::123456789012:role/FirehosetoS3Role"
    }
}

Crea una politica di autorizzazioni per definire quali azioni può eseguire Firehose 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:::amzn-s3-demo-bucket2", 
          "arn:aws:s3:::amzn-s3-demo-bucket2/*" ]
    }
  ]
}

Associa la policy di autorizzazioni al ruolo utilizzando il comando put-role-policy seguente:

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

Crea un flusso di consegna Firehose di destinazione come segue, sostituendo i valori segnaposto per ROLearn e BucketARN con il ruolo e il bucket ARN 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:::amzn-s3-demo-bucket2"}'
                    

Tieni presente che Firehose utilizza automaticamente un prefisso in formato orario UTC per gli oggetti Amazon S3 consegnati. YYYY/MM/DD/HH 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 finché il flusso non si attiva (questa operazione potrebbe richiedere alcuni minuti). Puoi usare il comando Firehose describe-delivery-stream per controllare la proprietà. DeliveryStreamDescription.DeliveryStreamStatus Inoltre, annota il DeliveryStreamDescription.DeliveryStreamARN valore, poiché ti servirà 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:::amzn-s3-demo-bucket2",
                    "BufferingHints": {
                        "IntervalInSeconds": 300,
                        "SizeInMBs": 5
                    }
                }
            }
        ]
    }
}

Crea il ruolo IAM che CloudWatch concede a Logs il permesso di inserire 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": { 
         "ArnLike": { 
             "aws:SourceArn": "arn:aws:logs:region:123456789012:*"
         } 
     }
  }
}

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

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 le azioni che CloudWatch Logs può 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 policy di autorizzazioni al ruolo utilizzando il seguente 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 il filtro di sottoscrizione CloudWatch Logs. Il filtro di abbonamento 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-subscription-filter \
    --log-group-name "CloudTrail" \
    --filter-name "Destination" \
    --filter-pattern "{$.userIdentity.type = Root}" \
    --destination-arn "arn:aws:firehose:region:123456789012:deliverystream/my-delivery-stream" \
    --role-arn "arn:aws:iam::123456789012:role/CWLtoKinesisFirehoseRole"

Dopo aver impostato il filtro di abbonamento, CloudWatch Logs inoltrerà tutti gli eventi di log in entrata che corrispondono al modello di filtro al flusso di consegna di Amazon Data Firehose. I tuoi dati inizieranno a comparire in Amazon S3 in base all'intervallo di tempo del buffer impostato nel flusso di consegna di Amazon Data Firehose. Quando è trascorso tempo sufficiente, puoi verificare i dati controllando il Bucket Amazon S3.

aws s3api list-objects --bucket 'amzn-s3-demo-bucket2' --prefix 'firehose/'
{
    "Contents": [
        {
            "LastModified": "2015-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/2015/10/29/00/my-delivery-stream-2015-10-29-00-35-40-7cc92023-7e66-49bc-9fd4-fc9819cc8ed3",
            "Owner": {
                "DisplayName": "cloudwatch-logs",
                "ID": "1ec9cf700ef6be062b19584e0b7d84ecc19237f87b6"
            },
            "Size": 5752
        }
    ]
}

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

{
    "AcceptRanges": "bytes",
    "ContentType": "application/octet-stream",
    "LastModified": "Thu, 29 Oct 2015 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

Crea un dominio OpenSearch di servizio. Per ulteriori informazioni, vedere Creazione di domini OpenSearch di servizio

Apri la CloudWatch console all'indirizzo. https://console.aws.amazon.com/cloudwatch/

Nel pannello di navigazione, selezionare Log groups (Gruppi di log).

Selezionare il nome del gruppo di registro.

Scegli Azioni, Filtri di abbonamento, Crea filtro OpenSearch di abbonamento Amazon Service.

Scegli se eseguire lo streaming in un cluster di questo account o di un altro account.

Se hai scelto un altro account, fornire il dominio ARN e l'endpoint.

Per il cluster Amazon OpenSearch Service, scegli il nome del cluster in cui verranno consegnati i dati del gruppo di log

Scegli un formato di registro.

Per lo schema di filtro degli abbonamenti, inserisci i termini o lo schema da trovare nel registro degli eventi. Questo ti assicura di inviare solo i dati che ti interessano al tuo cluster OpenSearch di servizi. Per ulteriori informazioni, consulta Sintassi del modello di filtro per i filtri di parametri.

(Opzionale) In Select log data to test (Seleziona i dati di registro per il test), seleziona un flusso di registro, quindi scegli Test pattern (Modello di test) per verificare che il filtro di ricerca restituisca i risultati previsti.

Quindi scegli Start streaming (Avvia streaming).