Filtros de suscripción a nivel de grupo de registros

Crear un flujo de de destino utilizando el siguiente comando:

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

Espere hasta que el flujo de esté Activo (esto podría tardar un minuto o dos). Puede utilizar el siguiente comando describe-stream de Kinesis Data Streams para comprobar la. StreamDescription StreamStatuspropiedad. Además, anote el valor StreamDescription.streamArn, ya que lo necesitará en un paso posterior:

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

A continuación, se muestra un ejemplo de la salida:

{
    "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 el rol de IAM que otorgará a CloudWatch Logs el permiso para colocar datos en tu transmisión. En primer lugar, tendrá que crear una política de confianza en un archivo (por ejemplo, ~/TrustPolicyForCWL-Kinesis.json). Utilice un editor de texto para crear esta política. No utilice la consola de IAM para crearla.

Esta política incluye una clave de contexto de condición global de aws:SourceArn para ayudar a prevenir el confuso problema de seguridad adjunto. Para obtener más información, consulte Prevención del suplente confuso.

{
  "Statement": {
    "Effect": "Allow",
    "Principal": { "Service": "logs.amazonaws.com" },
    "Action": "sts:AssumeRole",
    "Condition": { 
        "StringLike": { "aws:SourceArn": "arn:aws:logs:region:123456789012:*" } 
     }
   }
}

Ejecute el comando create-role para crear el rol de IAM y especifique el archivo de política de confianza. Anote el valor de Role.Arn devuelto, ya que también lo necesitará más tarde:

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

A continuación se muestra un ejemplo de la salida.

{
    "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 política de permisos para definir qué acciones puede realizar CloudWatch Logs en tu cuenta. En primer lugar, creará una política de permisos en un archivo (por ejemplo, ~/PermissionsForCWL-Kinesis.json). Utilice un editor de texto para crear esta política. No utilice la consola de IAM para crearla.

{
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "kinesis:PutRecord",
      "Resource": "arn:aws:kinesis:region:123456789012:stream/RootAccess"
    }
  ]
}

Asocie la política de permisos al rol mediante el siguiente put-role-policycomando:

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

Una vez que la transmisión esté en estado activo y hayas creado el rol de IAM, puedes crear el filtro de suscripción a CloudWatch Logs. El filtro de suscripción inicia de inmediato el flujo de datos de registro en tiempo real desde el grupo de registros elegido a su flujo de :

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"

Tras configurar el filtro de suscripción, CloudWatch Logs reenvía a la transmisión todos los eventos de registro entrantes que coincidan con el patrón de filtrado. Puede verificar que esto está ocurriendo si toma un iterador de particiones de Kinesis Data Streams y utiliza el comando get-records de Kinesis Data Streams para obtener algunos registros de 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"

Tenga en cuenta que es posible que tenga que realizar esta llamada varias veces antes de que Kinesis Data Streams comience a devolver los datos.

Cabe esperar ver una respuesta en una gama de registros. El atributo Datos de un registro de Kinesis Data Streams tiene codificación de base64 y está comprimido con el formato gzip. Puede examinar los datos sin procesar desde la línea de comando utilizando los siguientes comandos de Unix:

echo -n "<Content of Data>" | base64 -d | zcat

Los datos descodificados y descomprimidos en base64 se formatean como JSON con la siguiente estructura:

{
    "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\"}"
        }
    ]
}

Los elementos clave en la estructura de datos anterior son los siguientes:

Crea la AWS Lambda función.

Asegúrese de haber configurado el rol de ejecución de Lambda. Para obtener más información, consulte Paso 2.2: Crear un rol de IAM (rol de ejecución) en la AWS Lambda Guía del desarrollador.

Abra un editor de texto y cree un archivo denominado helloWorld.js con el siguiente contenido:

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();
        }
    });
};

Comprima el archivo helloWorld.js en un zip y guárdelo con el nombre helloWorld.zip.

Utilice el siguiente comando, donde el rol es el rol de ejecución de Lambda que configuró en el primer paso:

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

CloudWatch Concede a Logs el permiso para ejecutar tu función. Utilice el siguiente comando, sustituyendo la cuenta del marcador por su propia cuenta y el grupo de registros del marcador por el grupo de registros que procesar:

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"

Cree un filtro de suscripción utilizando el siguiente comando, sustituyendo la cuenta del marcador por su propia cuenta y el grupo de registros del marcador por el grupo de registros que procesar:

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

(Opcional) Probar mediante un evento de registro de ejemplo. En el símbolo del sistema, ejecute el siguiente comando, que pone un mensaje de registro sencillo en el flujo suscrito.

Para consultar la salida de su función de Lambda, diríjase a la función de Lambda donde verá la salida en /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\"}]"

Cabe esperar ver una respuesta en una matriz de Lambda. El atributo Data (Datos) del registro de Lambda tiene codificación de base64 y está comprimido con el formato gzip. La carga útil real que recibe Lambda está en el siguiente formato { "awslogs": {"data": "BASE64ENCODED_GZIP_COMPRESSED_DATA"} }. Puede examinar los datos sin procesar desde la línea de comandos mediante los siguientes comandos de Unix:

echo -n "<BASE64ENCODED_GZIP_COMPRESSED_DATA>" | base64 -d | zcat

Los datos descodificados y descomprimidos en base64 se formatean como JSON con la siguiente estructura:

{
    "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\"}"
        }
    ]
}

Los elementos clave en la estructura de datos anterior son los siguientes:

Cree un bucket de Amazon Simple Storage Service (Amazon S3). Te recomendamos que utilices un depósito creado específicamente para CloudWatch los registros. Sin embargo, si desea utilizar un bucket existente, vaya al paso 2.

Ejecute el siguiente comando y sustituya la región del marcador por la región que desee utilizar:

aws s3api create-bucket --bucket my-bucket --create-bucket-configuration LocationConstraint=region

A continuación, se muestra un ejemplo de la salida:

{
    "Location": "/my-bucket"
}

Cree la función de IAM que conceda permiso a Amazon Data Firehose para colocar datos en su bucket de Amazon S3.

Para obtener más información, consulte Control del acceso con Amazon Data Firehose en la Guía para desarrolladores de Amazon Data Firehose.

En primer lugar, utilice un editor de texto para crear una política de confianza en un archivo ~/TrustPolicyForFirehose.json tal como se indica a continuación:

{
  "Statement": {
    "Effect": "Allow",
    "Principal": { "Service": "firehose.amazonaws.com" },
    "Action": "sts:AssumeRole"
    } 
}

Ejecute el comando create-role para crear el rol de IAM y especifique el archivo de política de confianza. Anote el valor de Role.Arn devuelto, ya que lo necesitará en un paso posterior:

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 política de permisos para definir qué acciones puede realizar Firehose en tu cuenta. En primer lugar, utilice un editor de texto para crear una política de permisos en un archivo ~/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/*" ]
    }
  ]
}

Asocia la política de permisos al rol mediante el siguiente put-role-policy comando:

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

Cree una transmisión de entrega de Firehose de destino de la siguiente manera y sustituya los valores de los marcadores de posición de RoLearn y BucketArn por los ARN de rol y bucket que creó:

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"}'
                    

Tenga en cuenta que Firehose utiliza automáticamente un prefijo en el formato de hora UTC AAAA/MM/DD/HH para los objetos de Amazon S3 entregados. Puede especificar un prefijo adicional que añadir delante del prefijo de formato de hora. Si el prefijo termina con una barra inclinada (/), aparece como una carpeta en el bucket de Amazon S3.

Espere hasta que el flujo se active (esto podría tardar unos minutos). Puede utilizar el describe-delivery-streamcomando Firehose para comprobar el. DeliveryStreamDescription DeliveryStreamStatuspropiedad. Además, tenga en cuenta el DeliveryStreamDescription. DeliveryStreamValor ARN, ya que lo necesitará en un paso posterior:

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 el rol de IAM que otorga permiso a CloudWatch Logs para colocar datos en tu transmisión de entrega de Firehose. En primer lugar, utilice un editor de texto para crear una política de confianza en un archivo ~/TrustPolicyForCWL.json:

Esta política incluye una clave de contexto de condición global de aws:SourceArn para ayudar a prevenir el confuso problema de seguridad adjunto. Para obtener más información, consulte Prevención del suplente confuso.

{
  "Statement": {
    "Effect": "Allow",
    "Principal": { "Service": "logs.amazonaws.com" },
    "Action": "sts:AssumeRole",
    "Condition": { 
         "StringLike": { 
             "aws:SourceArn": "arn:aws:logs:region:123456789012:*"
         } 
     }
  }
}

Ejecute el comando create-role para crear el rol de IAM y especifique el archivo de política de confianza. Anote el valor de Role.Arn devuelto, ya que lo necesitará en un paso posterior:

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 política de permisos para definir qué acciones puede realizar CloudWatch Logs en tu cuenta. En primer lugar, utilice un editor de texto para crear un archivo de política de permisos (por ejemplo, ~/PermissionsForCWL.json):

{
    "Statement":[
      {
        "Effect":"Allow",
        "Action":["firehose:PutRecord"],
        "Resource":[
            "arn:aws:firehose:region:account-id:deliverystream/delivery-stream-name"]
      }
    ]
}

Asocie la política de permisos al rol mediante el put-role-policy comando:

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

Una vez que la transmisión de entrega de Amazon Data Firehose esté en estado activo y haya creado el rol de IAM, podrá crear el filtro de suscripción a CloudWatch Logs. El filtro de suscripción inicia inmediatamente el flujo de datos de registro en tiempo real desde el grupo de registros elegido a la transmisión de entrega de 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"

Tras configurar el filtro de suscripción, CloudWatch Logs reenviará todos los eventos de registro entrantes que coincidan con el patrón de filtrado a la transmisión de entrega de Amazon Data Firehose. Sus datos comenzarán a aparecer en su Amazon S3 en función del intervalo de tiempo establecido en la transmisión de entrega de Amazon Data Firehose. Una vez que haya transcurrido el tiempo suficiente, puede verificar los datos comprobando su bucket de Amazon S3.

aws s3api list-objects --bucket 'my-bucket' --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 'my-bucket' --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": {}
}

Los datos en el objeto de Amazon S3 se comprimen con el formato gzip. Puede examinar los datos sin procesar desde la línea de comando utilizando el siguiente comando de Unix:

zcat testfile.gz