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 Data Firehose

Filtros de assinatura em nível de conta

Importante

Existe o risco de causar um loop recursivo infinito com filtros de assinatura que pode levar a um grande aumento na cobrança por ingestão se não for resolvido. Para reduzir esse risco, recomendamos que você use critérios de seleção nos filtros de assinatura em nível de conta para excluir grupos de registros que ingerem dados de registro de recursos que fazem parte do fluxo de trabalho de entrega de assinaturas. Para obter mais informações sobre esse problema e determinar quais grupos de registros excluir, consultePrevenção de recursão de registros.

Você pode definir uma política de assinatura em nível de conta que inclua um subconjunto de grupos de registros na conta. A política de assinatura da conta pode funcionar com Kinesis Data Streams, Lambda ou Firehose. Os registros enviados para um serviço de recebimento por meio de uma política de assinatura em nível de conta são codificados em base64 e compactados com o formato gzip.

nota

Para ver uma lista de todas as políticas de filtro de assinatura em sua conta, use o describe-account-policies comando com um valor de SUBSCRIPTION_FILTER_POLICY para o --policy-type parâmetro. Para obter mais informações, consulte describe-account-policies¶.

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 Data Firehose

Exemplo 1: filtros de assinatura com o Kinesis Data Streams

Antes de criar um stream de dados do Kinesis Data Streams para usar com uma política de assinatura em nível de conta, calcule o volume de dados de log que serão gerados. Certifique-se de criar um fluxo do com estilhaços suficientes para suportar esse volume. Se um stream não tiver fragmentos suficientes, ele será estrangulado. Para obter mais informações sobre limites de volume de stream, consulte Cotas e limites na documentação do Kinesis Data Streams.

Atenção

Como os eventos de log de vários grupos de log são encaminhados para o destino, existe o risco de limitação. 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 do Kinesis Data Streams CloudWatch com métricas. Isso ajuda você a identificar a limitação e ajustar sua configuração adequadamente. Por exemplo, a DeliveryThrottling métrica rastreia o número de eventos de registro para CloudWatch os quais o Logs foi limitado ao encaminhar dados para o destino da assinatura. Para ter mais informações, consulte Monitoramento com CloudWatch métricas.
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, consulte Modo sob demanda.
Restrinja seu padrão de filtro de assinatura do CloudWatch Logs 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.

O exemplo a seguir usa uma política de assinatura em nível de conta para encaminhar todos os eventos de log para um stream no Kinesis Data Streams. O padrão de filtro combina todos os eventos de registro com o texto Test e os encaminha para o stream no Kinesis Data Streams.

Para criar uma política de assinatura em nível de conta para o Kinesis Data Streams

Crie um stream do de destino usando o seguinte comando:


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

Aguarde alguns minutos até que o stream fique ativo. Você pode verificar se o fluxo está ativo usando o comando describe-stream para verificar o. StreamDescription StreamStatuspropriedade.


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

A seguir está um exemplo de saída:


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

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.

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": "EXAMPLE450GAB4HC5F431",
        "CreateDate": "2023-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á-lo.
```
{
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "kinesis:PutRecord",
      "Resource": "arn:aws:kinesis:region:123456789012:stream/TestStream"
    }
  ]
}
```

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 a política de filtro de assinatura de CloudWatch registros. A política inicia imediatamente o fluxo de dados de registro em tempo real para seu stream. Neste exemplo, todos os eventos de log que contêm a string ERROR são transmitidos, exceto aqueles nos grupos de log chamados LogGroupToExclude1 e. 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"

Depois de configurar o filtro de assinatura, o CloudWatch Logs encaminha todos os eventos de registro recebidos que correspondam ao padrão do filtro e aos critérios de seleção para o seu stream.

O selection-criteria campo é opcional, mas é importante para excluir grupos de registros que podem causar uma recursão infinita de registros de um filtro de assinatura. Para obter mais informações sobre esse problema e determinar quais grupos de registros excluir, consultePrevenção de recursão de registros. Atualmente, NOT IN é o único operador compatível com selection-criteria o.

Você pode verificar o fluxo de eventos de log usando um iterador de fragmentos do Kinesis Data Streams e usando o get-records comando Kinesis Data Streams para buscar alguns registros do 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"
```
Talvez você precise usar esse comando algumas vezes antes 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:
```
{ 
    "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"
}
```
Os principais elementos da estrutura de dados são os seguintes:

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.

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.

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.

Nível de política

O nível em que a política foi aplicada. “ACCOUNT_LEVEL_POLICY” serve policyLevel para uma política de filtro de assinatura em nível de conta.

Exemplo 2: filtros de assinatura com AWS Lambda

Neste exemplo, você criará uma política de filtro de assinatura no nível da conta do CloudWatch Logs que envia dados de registro para sua AWS Lambda função.

Atenção

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 conseguir lidar com o volume, o fluxo de log será acelerado. Como os eventos de registro de todos os grupos de registro ou de um subconjunto dos grupos de registro da conta são encaminhados para o destino, existe o risco de limitação. Para obter mais informações sobre limites do Lambda, consulte Limites do AWS Lambda.

Para criar uma política de filtro de assinatura em nível de conta 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 do AWS 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 nodejs18.x

Conceda à CloudWatch Logs a permissão para executar sua função. Use o comando a seguir, substituindo a conta de espaço reservado pela sua própria conta.


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"

Crie uma política de filtro de assinatura no nível da conta usando o comando a seguir, substituindo a conta de espaço reservado pela sua própria conta. Neste exemplo, todos os eventos de log que contêm a string ERROR são transmitidos, exceto aqueles nos grupos de log chamados LogGroupToExclude1 e. 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"
```
Depois de configurar o filtro de assinatura, o CloudWatch Logs encaminha todos os eventos de registro recebidos que correspondam ao padrão do filtro e aos critérios de seleção para o seu stream.

O selection-criteria campo é opcional, mas é importante para excluir grupos de registros que podem causar uma recursão infinita de registros de um filtro de assinatura. Para obter mais informações sobre esse problema e determinar quais grupos de registros excluir, consultePrevenção de recursão de registros. Atualmente, NOT IN é o único operador compatível com selection-criteria o.
(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 Example1 --log-stream-name logStream1 --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:
```
{ 
    "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"
}
```
nota
O filtro de assinatura no nível da conta não será aplicado ao grupo de registros da função Lambda de destino. Isso evita uma recursão infinita de registros que pode levar a um aumento no faturamento por ingestão. Para obter mais informações sobre esse problema, consultePrevenção de recursão de registros.

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

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.

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.

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.

Nível de política

O nível em que a política foi aplicada. “ACCOUNT_LEVEL_POLICY” serve policyLevel para uma política de filtro de assinatura em nível de conta.

Exemplo 3: filtros de assinatura com o Amazon Data Firehose

Neste exemplo, você criará uma política de filtro de assinatura em nível de conta do CloudWatch Logs que envia eventos de log recebidos que correspondam aos filtros definidos para o seu stream de entrega do Amazon Data Firehose. Os dados enviados do CloudWatch Logs para o Amazon 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 Firehose. Em seguida, você pode usar o recurso de descompressão no Firehose para descompactar automaticamente os registros. Para obter mais informações, consulte Gravando no Kinesis Data CloudWatch Firehose usando registros.

Atenção

Antes de criar o stream do Firehose, calcule o volume de dados de registro que serão gerados. Certifique-se de criar um stream do Firehose que possa lidar com 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 stream do Firehose, consulte Amazon Data Firehose Data Limits.

Para criar um filtro de assinatura para 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 a função do IAM que concede permissão ao Amazon Data Firehose para colocar dados em seu bucket do Amazon S3.

Para obter mais informações, consulte Controlando o acesso com o Amazon Data Firehose no Guia do desenvolvedor do Amazon 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. Anote 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": "EXAMPLE50GAB4HC5F431",
        "CreateDate": "2023-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 Firehose pode fazer na 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 stream de entrega de destino do Firehose da seguinte forma, substituindo os valores de espaço reservado para 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"}'
                    
```
O NFirehose usa automaticamente um prefixo no formato de hora UTC YYYYY/MM/DD/HH para objetos Amazon S3 entregues. 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 alguns minutos até que o stream fique ativo. Você pode usar o describe-delivery-streamcomando 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 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 à função usando o put-role-policy comando:


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 Data Firehose estiver ativo e você tiver criado a função do IAM, você poderá criar a política de filtro de assinatura em nível de conta do CloudWatch Logs. A política inicia imediatamente o fluxo de dados de log em tempo real do grupo de log escolhido para o seu stream de entrega do 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"

Depois de configurar o filtro de assinatura, o CloudWatch Logs encaminha os eventos de log recebidos que correspondem ao padrão do filtro para o seu stream de entrega do Amazon Data Firehose.

O selection-criteria campo é opcional, mas é importante para excluir grupos de registros que podem causar uma recursão infinita de registros de um filtro de assinatura. Para obter mais informações sobre esse problema e determinar quais grupos de registros excluir, consultePrevenção de recursão de registros. Atualmente, NOT IN é o único operador compatível com selection-criteria o.

Seus dados começarão a aparecer no Amazon S3 com base no intervalo de tempo definido no stream de entrega do Amazon 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": "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 'my-bucket' --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": {}
}

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

Registre filtros de assinatura em nível de grupo

Assinaturas entre contas e regiões