Filtros de suscripción a nivel de cuenta

Crear un flujo de destino mediante el siguiente comando:

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

Espere unos minutos hasta que la transmisión se active. Puede comprobar si la transmisión está activa mediante el comando describe-stream para comprobar la. StreamDescription StreamStatuspropiedad.

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

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

{
    "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 el rol de IAM que otorgará permiso a CloudWatch Logs para incluir 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.

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": "EXAMPLE450GAB4HC5F431",
        "CreateDate": "2023-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/TestStream"
    }
  ]
}

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 haya creado el rol de IAM, puede crear la política de filtrado de suscripciones de CloudWatch registros. La política inicia de inmediato el flujo de datos del registro en tiempo real hacia su flujo. En este ejemplo, se transmiten todos los eventos de registro que contienen la cadena ERROR, excepto los de los grupos de registro denominados LogGroupToExclude1 y LogGroupToExclude2.

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"

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 filtro y los criterios de selección.

El campo selection-criteria es opcional, pero es importante usarlo si quiere excluir de un filtro de suscripción los grupos de registro que pueden provocar una recursión infinita de registros. Para obtener más información sobre este problema y determinar qué grupos de registro excluir, consulte Prevención de recursión de registros. Actualmente, NOT IN es el único operador compatible para selection-criteria.

Puede verificar el flujo de eventos de registro mediante un iterador de particiones de Kinesis Data Streams y con el comando get-records de Kinesis Data Streams para obtener algunos registros de 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"

Es posible que tenga que usar el comando 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:

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

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

Crea la función. AWS Lambda

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 nodejs18.x

CloudWatch Concede a Logs el permiso para ejecutar tu función. Use el siguiente comando para reemplazar la cuenta de marcador de posición por la suya propia.

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"

Cree una política de filtrado de suscripciones a nivel de cuenta mediante el siguiente comando y sustituya la cuenta de marcador de posición por la suya. En este ejemplo, se transmiten todos los eventos de registro que contienen la cadena ERROR, excepto los de los grupos de registro denominados LogGroupToExclude1 y 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"

Tras configurar el filtro de suscripción, CloudWatch Logs reenvía a tu transmisión todos los eventos de registro entrantes que coincidan con el patrón del filtro y los criterios de selección.

El campo selection-criteria es opcional, pero es importante usarlo si quiere excluir de un filtro de suscripción los grupos de registro que pueden provocar una recursión infinita de registros. Para obtener más información sobre este problema y determinar qué grupos de registro excluir, consulte Prevención de recursión de registros. Actualmente, NOT IN es el único operador compatible para selection-criteria.

(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 ver el resultado de la función Lambda, navegue hasta la función Lambda, donde verá el resultado: 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\"}]"

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:

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

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

Cree un bucket de Amazon Simple Storage Service (Amazon S3). Le recomendamos que utilice 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 amzn-s3-demo-bucket2 --create-bucket-configuration LocationConstraint=region

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

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

Cree el rol de IAM que concede permiso a Amazon Data Firehose para incluir 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": "EXAMPLE50GAB4HC5F431",
        "CreateDate": "2023-05-29T13:46:29.431Z",
        "RoleName": "FirehosetoS3Role",
        "Path": "/",
        "Arn": "arn:aws:iam::123456789012:role/FirehosetoS3Role"
    }
}

Cree una política de permisos para definir las acciones que Firehose puede realizar en su 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:::amzn-s3-demo-bucket2", 
          "arn:aws:s3:::amzn-s3-demo-bucket2/*" ]
    }
  ]
}

Asocie 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 el rol y el bucket que creó: 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"}'
                    

NFirehose utiliza automáticamente un prefijo en formato de hora YYYY/MM/DD/HH UTC 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 unos minutos hasta que se active el flujo. Puede utilizar el describe-delivery-streamcomando Firehose para comprobar el. DeliveryStreamDescription DeliveryStreamStatuspropiedad. Además, tenga en cuenta el DeliveryStreamDescription. DeliveryStreamValor de 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:::amzn-s3-demo-bucket2",
                    "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 con el rol utilizando el comando put-role-policy:

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 la función de IAM, podrá crear la política de filtrado de suscripciones a nivel de cuenta de CloudWatch Logs. La política inicia de inmediato el flujo de datos de registro en tiempo real desde el grupo de registro elegido a su flujo de entrega de 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"

Tras configurar el filtro de suscripción, CloudWatch Logs reenvía los eventos de registro entrantes que coinciden con el patrón de filtrado a la transmisión de entrega de Amazon Data Firehose.

El campo selection-criteria es opcional, pero es importante usarlo si quiere excluir de un filtro de suscripción los grupos de registro que pueden provocar una recursión infinita de registros. Para obtener más información sobre este problema y determinar qué grupos de registro excluir, consulte Prevención de recursión de registros. Actualmente, NOT IN es el único operador compatible para selection-criteria.

Los datos comenzarán a aparecer en su instancia de Amazon S3 en función del intervalo de búfer de tiempo definido en el flujo 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 'amzn-s3-demo-bucket2' --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 'amzn-s3-demo-bucket2' --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": {}
}

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