Registra i filtri di abbonamento a livello di gruppo

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. È possibile utilizzare il seguente comando Kinesis Data Streams describe-stream per controllare il. StreamDescription StreamStatusproprietà. Inoltre, prendi nota del valore StreamDescription.StreamArn, poiché ti servirà in un passaggio successivo:

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 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. 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": { 
        "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": "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 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/RootAccess"
    }
  ]
}

Associa la politica 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 è nello 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 di abbonamento, CloudWatch Logs inoltra tutti gli eventi di registro in entrata che corrispondono al modello di filtro allo stream. Puoi verificare che questo stia effettivamente avvenendo acquisendo un'iteratore di partizione di Kinesis Data Streams e utilizzando il comando Kinesis get-records per recuperare alcuni log di 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"

Potresti dover effettuare questa chiamata più 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:

{
    "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 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 nodejs12.x

Concedi a CloudWatch Logs il permesso 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 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 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 valore Role.Arn restituito, poiché ne avrai bisogno anche 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 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:::amzn-s3-demo-bucket2", 
          "arn:aws:s3:::amzn-s3-demo-bucket2/*" ]
    }
  ]
}

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 il ruolo e il bucket che hai creato: ARNs

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 YYYY/MM/DD/HH UTC 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 finché il flusso non si attiva (questa operazione potrebbe richiedere alcuni minuti). È 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:::amzn-s3-demo-bucket2",
                    "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:*"
         } 
     }
  }
}

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 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 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 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 il filtro di sottoscrizione CloudWatch Logs. Il filtro di sottoscrizione 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 configurato il filtro di abbonamento, CloudWatch Logs inoltrerà tutti gli eventi di log in entrata che corrispondono allo schema di filtro al flusso di distribuzione di Amazon Data Firehose. 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 '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, consulta 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 Lambda IAM Execution Role, scegli il ruolo IAM che Lambda deve utilizzare per eseguire le chiamate al servizio. OpenSearch Il ruolo IAM che scegli deve soddisfare questi requisiti:

Scegli un formato di registro.

Per lo schema di filtro degli abbonamenti, inserisci i termini o lo schema da trovare nei tuoi eventi di registro. 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).