Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Suscripciones a nivel de cuenta entre cuentas y regiones mediante Firehose
Para compartir los datos de registro entre cuentas, es necesario establecer un emisor y receptor de datos de registro:
+ **Remitente de los datos de registro**: obtiene la información de destino del destinatario e informa a CloudWatch Logs de que está listo para enviar sus eventos de registro al destino especificado. En los procedimientos descritos en el resto de esta sección, se muestra al remitente de los datos de registro con un número de AWS cuenta ficticio de 1111.
+ **Destinatario de los datos de registro**: configura un destino que encapsula una transmisión de Amazon Kinesis Data Streams y permite a CloudWatch Logs saber que el destinatario desea recibir los datos de registro. A continuación, el destinatario comparte la información sobre este destino con el remitente. En los procedimientos descritos en el resto de esta sección, se muestra al destinatario de los datos de registro con un número de AWS cuenta ficticio, 222222222222.
En el ejemplo de esta sección, se utiliza un flujo de entrega de Firehose con almacenamiento de Amazon S3. También puede configurar flujos de entrega de Firehose con diferentes parámetros. Para obtener más información, consulte [Creación de un flujo de entrega de Firehose](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html).
**nota**
El grupo de registros y el destino deben estar en la misma AWS región. Sin embargo, el AWS recurso al que apunta el destino puede estar ubicado en una región diferente.
**nota**
Se admite el filtro de suscripción de Firehose para el flujo de entrega de una ***misma cuenta*** y ***entre regiones***.
**Topics**
+ [Paso 1: creación de un flujo de entrega de Firehose](CreateFirehoseStream-Account.md)
+ [Paso 2: creación de un destino](CreateFirehoseStreamDestination-Account.md)
+ [Paso 3: crear una política de filtrado de suscripciones a nivel de cuenta](CreateSubscriptionFilterFirehose-Account.md)
+ [Validación del flujo de eventos de registro](ValidateLogEventFlowFirehose-Account.md)
+ [Modificación de la suscripción al destino en tiempo de ejecución](ModifyDestinationMembershipFirehose-Account.md)
# Paso 1: creación de un flujo de entrega de Firehose
**importante**
Antes de realizar los siguientes pasos, debe utilizar una política de acceso para que Firehose pueda acceder a su bucket de Amazon S3. Para obtener más información, consulte [Control del acceso](https://docs.aws.amazon.com/firehose/latest/dev/controlling-access.html#using-iam-s3) en la *Guía para desarrolladores de Amazon Data Firehose*.
Todos los pasos en esta sección (Paso 1) deben realizarse en la cuenta del destinatario de los datos de registro.
En los ejemplos siguientes, se utiliza Este de EE. UU. (Norte de Virginia). Reemplace esta región por la región correcta para su implementación.
**Creación de un flujo de entrega de Firehose que se utilice como destino**
1. Cree un bucket de Amazon S3:
```
aws s3api create-bucket --bucket amzn-s3-demo-bucket --create-bucket-configuration LocationConstraint=us-east-1
```
1. Cree el rol de IAM que concede permiso a Firehose para incluir datos en el bucket.
1. En primer lugar, utilice un editor de texto para crear una política de confianza en un archivo `~/TrustPolicyForFirehose.json`.
```
{ "Statement": { "Effect": "Allow", "Principal": { "Service": "firehose.amazonaws.com" }, "Action": "sts:AssumeRole", "Condition": { "StringEquals": { "sts:ExternalId":"222222222222" } } } }
```
1. Cree el rol de IAM y especifique el archivo de política de confianza que acaba de crear.
```
aws iam create-role \
--role-name FirehosetoS3Role \
--assume-role-policy-document file://~/TrustPolicyForFirehose.json
```
1. El resultado de este comando debería ser similar a lo siguiente. Haga una nota del nombre del rol y del ARN del rol.
```
{
"Role": {
"Path": "/",
"RoleName": "FirehosetoS3Role",
"RoleId": "AROAR3BXASEKW7K635M53",
"Arn": "arn:aws:iam::222222222222:role/FirehosetoS3Role",
"CreateDate": "2021-02-02T07:53:10+00:00",
"AssumeRolePolicyDocument": {
"Statement": {
"Effect": "Allow",
"Principal": {
"Service": "firehose.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"sts:ExternalId": "222222222222"
}
}
}
}
}
}
```
1. Cree una política de permisos para definir las acciones que Firehose puede realizar en su cuenta.
1. En primer lugar, utilice un editor de texto para crear la siguiente política de permisos en un archivo denominado: `~/PermissionsForFirehose.json`. Según el caso de uso, es posible que tenga que agregar más permisos a este archivo.
```
{
"Statement": [{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:PutObjectAcl",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}]
}
```
1. Ingrese el siguiente comando para asociar la política de permisos que acaba de crear con el rol de IAM.
```
aws iam put-role-policy --role-name FirehosetoS3Role --policy-name Permissions-Policy-For-Firehose-To-S3 --policy-document file://~/PermissionsForFirehose.json
```
1. Introduzca el comando siguiente para crear el flujo de entrega de Firehose. Sustituya *my-role-arn* y *amzn-s3-demo-bucket2-arn* por los valores correctos para su implementación.
```
aws firehose create-delivery-stream \
--delivery-stream-name 'my-delivery-stream' \
--s3-destination-configuration \
'{"RoleARN": "arn:aws:iam::222222222222:role/FirehosetoS3Role", "BucketARN": "arn:aws:s3:::amzn-s3-demo-bucket"}'
```
El resultado debería tener un aspecto similar al siguiente:
```
{
"DeliveryStreamARN": "arn:aws:firehose:us-east-1:222222222222:deliverystream/my-delivery-stream"
}
```
# Paso 2: creación de un destino
**importante**
Todos los pasos de este procedimiento deben realizarse en la cuenta del destinatario de los datos de registro.
Cuando se crea el destino, CloudWatch Logs envía un mensaje de prueba al destino en nombre de la cuenta del destinatario. Cuando el filtro de suscripciones se active más adelante, CloudWatch Logs envía los eventos de registro al destino en nombre de la cuenta de origen.
**Para crear un destino**
1. Espere a que el flujo de Firehose que creó en [Paso 1: creación de un flujo de entrega de Firehose](CreateFirehoseStream-Account.md) se active. Puede utilizar el siguiente comando para comprobar la **StreamDescription. StreamStatus**propiedad.
```
aws firehose describe-delivery-stream --delivery-stream-name "my-delivery-stream"
```
Además, tome nota de la **DeliveryStreamDescription. DeliveryStreamValor ARN**, ya que tendrá que usarlo en un paso posterior. Resultado de ejemplo de este comando:
```
{
"DeliveryStreamDescription": {
"DeliveryStreamName": "my-delivery-stream",
"DeliveryStreamARN": "arn:aws:firehose:us-east-1:222222222222:deliverystream/my-delivery-stream",
"DeliveryStreamStatus": "ACTIVE",
"DeliveryStreamEncryptionConfiguration": {
"Status": "DISABLED"
},
"DeliveryStreamType": "DirectPut",
"VersionId": "1",
"CreateTimestamp": "2021-02-01T23:59:15.567000-08:00",
"Destinations": [
{
"DestinationId": "destinationId-000000000001",
"S3DestinationDescription": {
"RoleARN": "arn:aws:iam::222222222222:role/FirehosetoS3Role",
"BucketARN": "arn:aws:s3:::amzn-s3-demo-bucket",
"BufferingHints": {
"SizeInMBs": 5,
"IntervalInSeconds": 300
},
"CompressionFormat": "UNCOMPRESSED",
"EncryptionConfiguration": {
"NoEncryptionConfig": "NoEncryption"
},
"CloudWatchLoggingOptions": {
"Enabled": false
}
},
"ExtendedS3DestinationDescription": {
"RoleARN": "arn:aws:iam::222222222222:role/FirehosetoS3Role",
"BucketARN": "arn:aws:s3:::amzn-s3-demo-bucket",
"BufferingHints": {
"SizeInMBs": 5,
"IntervalInSeconds": 300
},
"CompressionFormat": "UNCOMPRESSED",
"EncryptionConfiguration": {
"NoEncryptionConfig": "NoEncryption"
},
"CloudWatchLoggingOptions": {
"Enabled": false
},
"S3BackupMode": "Disabled"
}
}
],
"HasMoreDestinations": false
}
}
```
El flujo de entrega puede tardar un minuto o dos en mostrarse en el estado activo.
1. Cuando la transmisión de entrega esté activa, crea la función de IAM que concederá a CloudWatch Logs el permiso para colocar datos en tu transmisión de Firehose. En primer lugar, tendrás que crear una política de confianza en un archivo **TrustPolicyFor\$1/** CWL.json. Utilice un editor de texto para crear esta política. Para obtener más información sobre CloudWatch los puntos de enlace de Logs, consulte los puntos de [enlace y las cuotas de Amazon CloudWatch Logs](https://docs.aws.amazon.com/general/latest/gr/cwl_region.html).
Esta política incluye una clave de contexto de condición global `aws:SourceArn` que especifica la `sourceAccountId` para ayudar a prevenir el problema de seguridad de suplente confuso. Si aún no conoce el ID de cuenta de origen en la primera llamada, le recomendamos que coloque el ARN de destino en el campo ARN de origen. En las llamadas posteriores, debe configurar el ARN de origen para que sea el ARN de origen real que recopiló desde la primera llamada. Para obtener más información, consulte [Prevención del suplente confuso](Subscriptions-confused-deputy.md).
```
{
"Statement": {
"Effect": "Allow",
"Principal": {
"Service": "logs.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringLike": {
"aws:SourceArn": [
"arn:aws:logs:region:sourceAccountId:*",
"arn:aws:logs:region:recipientAccountId:*"
]
}
}
}
}
```
1. Utilice **aws iam create-role** para crear el rol de IAM y especifique el archivo de política de confianza que acaba de crear.
```
aws iam create-role \
--role-name CWLtoKinesisFirehoseRole \
--assume-role-policy-document file://~/TrustPolicyForCWL.json
```
A continuación, se muestra un ejemplo de la salida. Anote el valor de `Role.Arn` devuelto, ya que lo necesitará en un paso posterior.
```
{
"Role": {
"Path": "/",
"RoleName": "CWLtoKinesisFirehoseRole",
"RoleId": "AROAR3BXASEKYJYWF243H",
"Arn": "arn:aws:iam::222222222222:role/CWLtoKinesisFirehoseRole",
"CreateDate": "2023-02-02T08:10:43+00:00",
"AssumeRolePolicyDocument": {
"Statement": {
"Effect": "Allow",
"Principal": {
"Service": "logs.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringLike": {
"aws:SourceArn": [
"arn:aws:logs:region:sourceAccountId:*",
"arn:aws:logs:region:recipientAccountId:*"
]
}
}
}
}
}
}
```
1. Cree una política de permisos para definir qué acciones puede realizar CloudWatch Logs en su cuenta. Primero, usa un editor de texto para crear una política de permisos en un archivo **\$1/ PermissionsFor CWL.json:**
```
{
"Statement":[
{
"Effect":"Allow",
"Action":["firehose:*"],
"Resource":["arn:aws:firehose:region:222222222222:*"]
}
]
}
```
1. Asocie la política de permisos con el rol mediante el siguiente comando:
```
aws iam put-role-policy --role-name CWLtoKinesisFirehoseRole --policy-name Permissions-Policy-For-CWL --policy-document file://~/PermissionsForCWL.json
```
1. Una vez que la transmisión de entrega de Firehose esté en estado activo y hayas creado la función de IAM, puedes crear el destino de los CloudWatch registros.
1. Este paso no asociará una política de acceso a su destino y solo es el primer paso de los dos que completan la creación de un destino. Anote el ARN del nuevo destino que se devuelve en la carga, porque lo utilizará como `destination.arn` en un paso posterior.
```
aws logs put-destination \
--destination-name "testFirehoseDestination" \
--target-arn "arn:aws:firehose:us-east-1:222222222222:deliverystream/my-delivery-stream" \
--role-arn "arn:aws:iam::222222222222:role/CWLtoKinesisFirehoseRole"
{
"destination": {
"destinationName": "testFirehoseDestination",
"targetArn": "arn:aws:firehose:us-east-1:222222222222:deliverystream/my-delivery-stream",
"roleArn": "arn:aws:iam::222222222222:role/CWLtoKinesisFirehoseRole",
"arn": "arn:aws:logs:us-east-1:222222222222:destination:testFirehoseDestination"}
}
```
1. Después de completar el paso previo, en la cuenta del destinatario de los datos de registro (222222222222), asocie una política de acceso con el destino. Esta política permite que la cuenta del remitente de los datos de registro (111111111111) tenga acceso al destino justo en la cuenta del destinatario de los datos de registro (222222222222). Puede utilizar un editor de texto para incluir esta política en el archivo `~/AccessPolicy.json`:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Sid" : "",
"Effect" : "Allow",
"Principal" : {
"AWS" : "111111111111"
},
"Action" : ["logs:PutSubscriptionFilter","logs:PutAccountPolicy"],
"Resource" : "arn:aws:logs:us-east-1:222222222222:destination:testFirehoseDestination"
}
]
}
```
------
1. Esto crea una política que define quién tiene acceso de escritura al destino. Esta política debe especificar las acciones `logs:PutSubscriptionFilter` y `logs:PutAccountPolicy` para acceder al destino. Los usuarios entre cuentas utilizarán las acciones `PutSubscriptionFilter` y `PutAccountPolicy` para enviar eventos de registro al destino.
```
aws logs put-destination-policy \
--destination-name "testFirehoseDestination" \
--access-policy file://~/AccessPolicy.json
```
# Paso 3: crear una política de filtrado de suscripciones a nivel de cuenta
Cambie a la cuenta de envío, que es 111111111111 en este ejemplo. Ahora creará la política de filtrado de suscripciones a nivel de cuenta en la cuenta de envío. En el siguiente ejemplo, el filtro hace que cada evento de registro que contiene la cadena `ERROR` en todos los grupos de registro excepto en dos se envíe al destino creado anteriormente.
```
aws logs put-account-policy \
--policy-name "CrossAccountFirehoseExamplePolicy" \
--policy-type "SUBSCRIPTION_FILTER_POLICY" \
--policy-document '{"DestinationArn":"arn:aws:logs:us-east-1:222222222222:destination:testFirehoseDestination", "FilterPattern": "{$.userIdentity.type = AssumedRole}", "Distribution": "Random"}' \
--selection-criteria 'LogGroupName NOT IN ["LogGroupToExclude1", "LogGroupToExclude2"]' \
--scope "ALL"
```
Los grupos de registro y el destino de la cuenta desde la que se realiza el envío deben estar en la misma región de AWS . Sin embargo, el destino puede apuntar a un AWS recurso, como un arroyo Firehose, que se encuentra en una región diferente.
# Validación del flujo de eventos de registro
Tras crear el filtro de suscripción, CloudWatch Logs reenvía todos los eventos de registro entrantes que coincidan con el patrón de filtro y los criterios de selección al flujo de entrega de Firehose. Los datos comienzan a aparecer en su bucket de Amazon S3 en función del intervalo de tiempo de búfer que se establece en el flujo de entrega de Firehose. Una vez que haya transcurrido el tiempo suficiente, puede verificar los datos comprobando su bucket de Amazon S3. Escriba el siguiente comando para comprobar el bucket:
```
aws s3api list-objects --bucket 'amzn-s3-demo-bucket'
```
El resultado de ese comando será similar a lo siguiente:
```
{
"Contents": [
{
"Key": "2021/02/02/08/my-delivery-stream-1-2021-02-02-08-55-24-5e6dc317-071b-45ba-a9d3-4805ba39c2ba",
"LastModified": "2023-02-02T09:00:26+00:00",
"ETag": "\"EXAMPLEa817fb88fc770b81c8f990d\"",
"Size": 198,
"StorageClass": "STANDARD",
"Owner": {
"DisplayName": "firehose+2test",
"ID": "EXAMPLE27fd05889c665d2636218451970ef79400e3d2aecca3adb1930042e0"
}
}
]
}
```
Puede recuperar un objeto específico del bucket al introducir el siguiente comando. Reemplace el valor de `key` con el valor que encontró en el comando anterior.
```
aws s3api get-object --bucket 'amzn-s3-demo-bucket' --key '2021/02/02/08/my-delivery-stream-1-2021-02-02-08-55-24-5e6dc317-071b-45ba-a9d3-4805ba39c2ba' testfile.gz
```
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 mediante uno de los siguientes comandos:
Linux:
```
zcat testfile.gz
```
macOS:
```
zcat
Puede encontrar situaciones en las que tenga que agregar o eliminar remitentes de registros de un destino de su propiedad. Puedes usar las `PutAccountPolicy` acciones **PutDestinationPolicy**y en tu destino con la nueva política de acceso. En el siguiente ejemplo, una cuenta **111111111111** agregada anteriormente deja de enviar datos de registro y se habilita la cuenta **333333333333**.
1. Busca la política que está asociada actualmente con el destino **TestDestination** y anota lo siguiente: **AccessPolicy**
```
aws logs describe-destinations \
--destination-name-prefix "testFirehoseDestination"
```
Los datos devueltos pueden tener el siguiente aspecto.
```
{
"destinations": [
{
"destinationName": "testFirehoseDestination",
"targetArn": "arn:aws:firehose:us-east-1:222222222222:deliverystream/my-delivery-stream",
"roleArn": "arn:aws:iam:: 222222222222:role/CWLtoKinesisFirehoseRole",
"accessPolicy": "{\n \"Version\" : \"2012-10-17\",\n \"Statement\" : [\n {\n \"Sid\" : \"\",\n \"Effect\" : \"Allow\",\n \"Principal\" : {\n \"AWS\" : \"111111111111 \"\n },\n \"Action\" : \"logs:PutSubscriptionFilter\",\n \"Resource\" : \"arn:aws:logs:us-east-1:222222222222:destination:testFirehoseDestination\"\n }\n ]\n}\n\n",
"arn": "arn:aws:logs:us-east-1: 222222222222:destination:testFirehoseDestination",
"creationTime": 1612256124430
}
]
}
```
1. Actualice la política para reflejar que la cuenta **111111111111** está detenida y que la cuenta **333333333333** está habilitada. Coloca esta política en el archivo **\$1/ .json: NewAccessPolicy**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Sid" : "",
"Effect" : "Allow",
"Principal" : {
"AWS" : "333333333333 "
},
"Action" : ["logs:PutSubscriptionFilter","logs:PutAccountPolicy"],
"Resource" : "arn:aws:logs:us-east-1:222222222222:destination:testFirehoseDestination"
}
]
}
```
------
1. Use el siguiente comando para asociar la política definida en el **NewAccessPolicyarchivo.json** con el destino:
```
aws logs put-destination-policy \
--destination-name "testFirehoseDestination" \
--access-policy file://~/NewAccessPolicy.json
```
Esto finalmente deshabilita los eventos de registro del ID de cuenta **111111111111**. Los eventos de registro del ID de cuenta **333333333333** empiezan a fluir al destino en cuanto el propietario de la cuenta **333333333333** crea un filtro de suscripción.