Exemplo 1: filtros de assinatura com o Kinesis Data Streams Exemplo 2: filtros de assinatura com AWS Lambda Exemplo 3: filtros de assinatura com o Amazon Kinesis Data Firehose.

Usando filtros CloudWatch de assinatura do Logs

Você pode usar um filtro de assinatura com o Kinesis Data Streams, o Lambda ou o Kinesis Data Firehose. Os logs enviados a um serviço de recebimento por meio de um filtro de assinatura são codificados em base64 e compactados no formato gzip.

É possível pesquisar seus dados de log usando a Sintaxe de padrões de filtros.

Exemplos

Exemplo 1: filtros de assinatura com o Kinesis Data Streams
Exemplo 2: filtros de assinatura com AWS Lambda
Exemplo 3: filtros de assinatura com o Amazon Kinesis Data Firehose.

Exemplo 1: filtros de assinatura com o Kinesis Data Streams

O exemplo a seguir associa um filtro de assinatura a um grupo de registros contendo AWS CloudTrail eventos. O filtro de assinatura entrega todas as atividades registradas feitas pelas AWS credenciais “Root” a um stream no Kinesis Data Streams chamado "”. RootAccess Para obter mais informações sobre como enviar AWS CloudTrail eventos para CloudWatch registros, consulte Enviar CloudTrail eventos para CloudWatch registros no Guia doAWS CloudTrail usuário.

nota

Antes de criar o fluxo do , calcule o volume de dados de log que será gerado. Certifique-se de criar um fluxo do com estilhaços suficientes para suportar esse volume. Se o fluxo não tiver um número suficiente de estilhaços, o fluxo de logs será limitado. Para obter mais informações sobre os limites de volume de fluxo, consulte Cotas e limites.

São feitas novas tentativas de entregáveis com controle de utilização por até 24 horas. Após 24 horas, os entregáveis com falha são descartados.

Para reduzir o risco de controle de utilização, você pode seguir as seguintes etapas:

Monitore seu stream usando CloudWatch métricas. Isso ajuda você a identificar qualquer controle de utilização e ajustar sua configuração adequadamente. Por exemplo, a DeliveryThrottling métrica pode ser usada para rastrear o número de eventos de registro para os quais o CloudWatch Logs foi limitado ao encaminhar dados para o destino da assinatura. Para obter mais informações sobre o monitoramento, consulte Monitorar com métricas do CloudWatch.
Use o modo de capacidade sob demanda para o fluxo no Kinesis Data Streams. O modo sob demanda acomoda instantaneamente o crescimento e a redução das workloads. Para obter mais informações sobre o modo de capacidade sob demanda, consulte Modo sob demanda.
Restrinja seu padrão de filtro de CloudWatch assinatura para corresponder à capacidade do seu stream no Kinesis Data Streams. Se você estiver enviando muitos dados para o fluxo, talvez seja necessário reduzir o tamanho do filtro ou ajustar os critérios dele.

Para criar um filtro de assinatura para o Kinesis Data Streams

Crie um stream do de destino usando o seguinte comando:


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

Aguarde até que o stream do se torne ativo (isso pode levar um ou dois minutos). Você pode usar o seguinte comando describe-stream do Kinesis Data Streams para verificar o. StreamDescription StreamStatuspropriedade. Além disso, observe o valor StreamDescription.streamArn, pois você precisará dele em uma etapa posterior:


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

A seguir está um exemplo de saída:


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

Crie a função do IAM que concederá permissão aos CloudWatch Logs para colocar dados em seu stream. Primeiro, você precisará criar uma política de confiança em um arquivo (por exemplo, ~/TrustPolicyForCWL-Kinesis.json). Use um editor de texto para criar esta política. Não use o console do IAM para criá-la.

Esta política inclui uma chave de contexto de condição global aws:SourceArn para ajudar a evitar o problema de segurança ‘confused deputy’. Para ter mais informações, consulte Prevenção de ‘confused deputy’.
```
{
  "Statement": {
    "Effect": "Allow",
    "Principal": { "Service": "logs.amazonaws.com" },
    "Action": "sts:AssumeRole",
    "Condition": { 
        "StringLike": { "aws:SourceArn": "arn:aws:logs:region:123456789012:*" } 
     }
   }
}
```

Use o comando create-role para criar a função do IAM especificando o arquivo de política de confiança. Observe o valor de Role.Arn retornado, pois ele também será necessário em uma etapa posterior:


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

A seguir, veja um exemplo de saída.


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

Crie uma política de permissões para definir quais ações o CloudWatch Logs pode fazer na sua conta. Primeiro, você criará uma política de permissões em um arquivo (por exemplo, ~/PermissionsForCWL-Kinesis.json). Use um editor de texto para criar esta política. Não use o console do IAM para criá-la.
```
{
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "kinesis:PutRecord",
      "Resource": "arn:aws:kinesis:region:123456789012:stream/RootAccess"
    }
  ]
}
```

Associe a política de permissões à função usando o seguinte put-role-policycomando:


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

Depois que o stream estiver no estado Ativo e você tiver criado a função do IAM, você poderá criar o filtro de assinatura de CloudWatch registros. O filtro de assinatura inicia imediatamente o fluxo de dados de log em tempo real a partir do grupo de logs escolhido para o fluxo do :


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"

Depois de configurar o filtro de assinatura, o CloudWatch Logs encaminha todos os eventos de registro recebidos que correspondem ao padrão do filtro para o seu stream. Você pode verificar se isso está acontecendo capturando um iterador de fragmentos do Kinesis Data Streams e usando o comando get-records do Kinesis Data Streams para buscar alguns registros do 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"

Observe que pode ser necessário fazer esta chamada algumas vezes para que o Kinesis Data Streams comece a retornar dados.

É necessário esperar para ver uma resposta com um conjunto de registros. O atributo Dados em um registro do Kinesis Data Streams é codificado em base64 e compactado no formato gzip. Você pode examinar os dados brutos na linha de comando usando os seguintes comandos Unix:


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

Os dados base64 decodificados e descompactados têm o formato JSON com a seguinte estrutura:


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

Os principais elementos na estrutura de dados acima são os seguintes:

owner: O ID da AWS conta dos dados de registro de origem.
logGroup: O nome do grupo de logs dos dados de log de origem.
logStream: O nome do stream de log dos dados de log de origem.
subscriptionFilters: A lista de nomes de filtro de assinatura que corresponderam aos dados de log de origem.
messageType: As mensagens de dados usarão o tipo "DATA_MESSAGE". Às vezes, o CloudWatch Logs pode emitir registros do Kinesis Data Streams com o tipo “CONTROL_MESSAGE”, principalmente para verificar se o destino está acessível.
logEvents: Os dados de log reais, representados como um conjunto de registros de eventos de log. A propriedade "id" é um identificador exclusivo de cada evento de log.

Exemplo 2: filtros de assinatura com AWS Lambda

Neste exemplo, você criará um filtro de assinatura de CloudWatch registros que envia dados de registro para sua AWS Lambda função.

nota

Antes de criar a função Lambda, calcule o volume de dados de log que será gerado. Lembre-se de criar uma função que suporte esse volume. Se a função não tiver um volume suficiente, o fluxo de logs será limitado. Para obter mais informações sobre limites do Lambda, consulte Limites doAWS Lambda.

Para criar um filtro de assinatura para o Lambda

Crie a AWS Lambda função.

Certifique-se de ter configurado a função de execução do Lambda. Para obter mais informações, consulte Etapa 2.2: Criar uma função do IAM (função de execução) no Guia do desenvolvedor doAWS Lambda .

Abra um editor de texto e crie um arquivo chamado helloWorld.js com o seguinte conteúdo:


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

Compacte o arquivo helloWorld.js e salve-o com o nome helloWorld.zip.

Use o comando a seguir, no qual a função é a função de execução do Lambda configurada na primeira etapa:


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

Conceda à CloudWatch Logs a permissão para executar sua função. Use o comando a seguir, substituindo o espaço reservado conta pela sua própria conta e o espaço reservado grupo de logs pelo grupo de logs a ser processado:


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"

Crie um filtro de assinatura usando o seguinte comando, substituindo o espaço reservado conta pela sua própria conta e o espaço reservado grupo de logs pelo grupo de logs a ser processado:


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

(Opcional) Teste usando um exemplo de evento de log. Em um prompt de comando, execute o seguinte comando, que colocará uma mensagem de log simples no stream assinado.

Para ver a saída de sua função Lambda, navegue para a função Lambda na qual você verá a saída em /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\"}]"
```
É necessário esperar para ver uma resposta com uma matriz do Lambda. O atributo Data (Dados) em um registro do Lambda é codificado em base64 e compactado com o formato gzip. A carga útil real recebida pelo Lambda está no seguinte formato { "awslogs": {"data": "BASE64ENCODED_GZIP_COMPRESSED_DATA"} }. Você pode examinar os dados brutos na linha de comando usando os seguintes comandos Unix:
```
echo -n "<BASE64ENCODED_GZIP_COMPRESSED_DATA>" | base64 -d | zcat
```
Os dados base64 decodificados e descompactados têm o formato JSON com a seguinte estrutura:
```
{
    "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\"}"
        }
    ]
}
```
Os principais elementos na estrutura de dados acima são os seguintes:

owner

O ID da AWS conta dos dados de registro de origem.

logGroup

O nome do grupo de logs dos dados de log de origem.

logStream

O nome do stream de log dos dados de log de origem.

subscriptionFilters

A lista de nomes de filtro de assinatura que corresponderam aos dados de log de origem.

messageType

As mensagens de dados usarão o tipo "DATA_MESSAGE". Às vezes, CloudWatch os Logs podem emitir registros Lambda com o tipo “CONTROL_MESSAGE”, principalmente para verificar se o destino está acessível.

logEvents

Os dados de log reais, representados como um conjunto de registros de eventos de log. A propriedade "id" é um identificador exclusivo de cada evento de log.

Exemplo 3: filtros de assinatura com o Amazon Kinesis Data Firehose.

Neste exemplo, você criará uma assinatura do CloudWatch Logs que enviará todos os eventos de log recebidos que correspondam aos seus filtros definidos para o seu stream de entrega do Amazon Kinesis Data Firehose. Os dados enviados do CloudWatch Logs para o Amazon Kinesis Data Firehose já estão compactados com a compactação gzip de nível 6, portanto, você não precisa usar a compactação no seu stream de distribuição do Kinesis Data Firehose.

nota

Antes de criar o fluxo do Kinesis Data Firehose, calcule o volume de dados de log que será gerado. Crie um fluxo do Kinesis Data Firehose que possa comportar esse volume. Se o fluxo não puder suportar o volume, o fluxo de logs será limitado. Para obter mais informações sobre os limites de volume de fluxo do Kinesis Data Firehose, consulte Limites de dados do Amazon Kinesis Data Firehose.

Para criar um filtro de assinatura para o Kinesis Data Firehose

Crie um bucket do Amazon Simple Storage Service (Amazon S3). Recomendamos que você use um bucket criado especificamente para o CloudWatch Logs. No entanto, se você desejar usar um bucket existente, vá para a etapa 2.

Execute o comando a seguir, substituindo o espaço reservado Region (Região) pela região que você deseja usar:
```
aws s3api create-bucket --bucket my-bucket --create-bucket-configuration LocationConstraint=region
```
A seguir está um exemplo de saída:
```
{
    "Location": "/my-bucket"
}
```
Crie o perfil do IAM que concede ao Amazon Kinesis Data Firehose permissão para colocar dados em seu bucket do Amazon S3.

Para obter mais informações, consulte Controlar o acesso com o Kinesis Data Firehose no Guia do desenvolvedor do Amazon Kinesis Data Firehose.

Primeiro, use um editor de texto para criar uma política de confiança em um arquivo ~/TrustPolicyForFirehose.json, da seguinte maneira:
```
{
  "Statement": {
    "Effect": "Allow",
    "Principal": { "Service": "firehose.amazonaws.com" },
    "Action": "sts:AssumeRole"
    } 
}
```

Use o comando create-role para criar a função do IAM especificando o arquivo de política de confiança. Observe o valor de Role.Arn retornado, pois você precisará dele em uma etapa 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"
    }
}

Crie uma política de permissões para definir quais ações o Kinesis Data Firehose pode fazer em sua conta. Primeiro, use um editor de texto para criar uma política de permissões em um arquivo ~/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/*" ]
    }
  ]
}

Associe a política de permissões à função usando o seguinte put-role-policy comando:


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

Crie um fluxo de entrega do Kinesis Data Firehose de destino substituindo os valores de espaço reservado de RoleARN e BucketARN pelos ARNs de função e bucket que você criou:
```
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"}'
                    
```
Observe que o Kinesis Data Firehose usa automaticamente um prefixo no formato de tempo AAAA/MM/DD/HH (UTC) para objetos entregues do Amazon S3. Você pode especificar um prefixo extra a ser incluído na frente do prefixo de formato de tempo. Se o prefixo terminar com uma barra (/), ele aparecerá como uma pasta no bucket do Amazon S3.

Aguarde até que o stream fique ativo (isso pode levar alguns minutos). Você pode usar o comando Kinesis describe-delivery-streamData Firehose para verificar o. DeliveryStreamDescription DeliveryStreamStatuspropriedade. Além disso, observe DeliveryStreamDescriptiono. DeliveryStreamValor do ARN, conforme necessário em uma etapa 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
                    }
                }
            }
        ]
    }
}

Crie a função do IAM que concede permissão aos CloudWatch Logs para colocar dados em seu stream de entrega do Kinesis Data Firehose. Primeiro, use um editor de texto para criar uma política de confiança em um arquivo ~/TrustPolicyForCWL.json:

Esta política inclui uma chave de contexto de condição global aws:SourceArn para ajudar a evitar o problema de segurança ‘confused deputy’. Para ter mais informações, consulte Prevenção de ‘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"
    }
}

Crie uma política de permissões para definir quais ações o CloudWatch Logs pode fazer na sua conta. Primeiro, use um editor de texto para criar um arquivo de política de permissões (por exemplo, ~/PermissionsForCWL.json):


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

Associe a política de permissões com a função usando o comando put-role-policy:


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

Depois que o stream de entrega do Amazon Kinesis Data Firehose estiver ativo e você tiver criado a função do IAM, você poderá CloudWatch criar o filtro de assinatura do Logs. O filtro de assinatura inicia imediatamente o fluxo de dados de log em tempo real do grupo de logs escolhido para o fluxo de entrega do Amazon Kinesis 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"
```

Depois de configurar o filtro de assinatura, o CloudWatch Logs encaminhará todos os eventos de log recebidos que correspondam ao padrão do filtro para o seu stream de entrega do Amazon Kinesis Data Firehose. Seus dados começarão a aparecer no Amazon S3 com base no intervalo de buffer de tempo definido em seu fluxo de entrega do Amazon Kinesis Data Firehose. Quando tiver passado tempo suficiente, você poderá conferir seus dados verificando o bucket do 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": {}
}

Os dados no objeto do Amazon S3 são compactados com o formato gzip. Você pode examinar os dados brutos na linha de comando usando o seguinte comando Unix:


zcat testfile.gz

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Filtros de assinatura

Compartilhamento de dados de log entre contas com assinaturas