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.
# Seguridad en Amazon MSK
La seguridad en la nube AWS es la máxima prioridad. Como AWS cliente, usted se beneficia de una arquitectura de centro de datos y red diseñada para cumplir con los requisitos de las organizaciones más sensibles a la seguridad.
La seguridad es una responsabilidad compartida entre usted AWS y usted. El [modelo de responsabilidad compartida](https://aws.amazon.com/compliance/shared-responsibility-model/) la describe como seguridad *de* la nube y seguridad *en* la nube:
+ **Seguridad de la nube**: AWS es responsable de proteger la infraestructura que ejecuta AWS los servicios en la AWS nube. AWS también le proporciona servicios que puede utilizar de forma segura. Los auditores externos prueban y verifican periódicamente la eficacia de nuestra seguridad como parte de los [AWS programas](https://aws.amazon.com/compliance/programs/) de de . Para obtener información sobre los programas de conformidad que se aplican a Amazon Managed Streaming para Apache Kafka, consulte [Servicios de Amazon Web Services en el ámbito del programa de conformidad](https://aws.amazon.com/compliance/services-in-scope/).
+ **Seguridad en la nube**: su responsabilidad viene determinada por el AWS servicio que utilice. También es responsable de otros factores, incluida la confidencialidad de los datos, los requisitos de la empresa y la legislación y los reglamentos vigentes.
Esta documentación le permite comprender cómo aplicar el modelo de responsabilidad compartida cuando se utiliza Amazon MSK. En los siguientes temas, se mostrará cómo configurar Amazon MSK para satisfacer sus objetivos de seguridad y conformidad. También puede aprender a utilizar otros servicios de Amazon Web Services que ayudan a supervisar y proteger los recursos de Amazon MSK.
**Topics**
+ [Protección de datos en Amazon Managed Streaming para Apache Kafka](data-protection.md)
+ [Autenticación y autorización para Amazon MSK APIs](security-iam.md)
+ [Autenticación y autorización para Apache Kafka APIs](kafka_apis_iam.md)
+ [Modificación del grupo de seguridad de un clúster de Amazon MSK](change-security-group.md)
+ [Controle el acceso a ZooKeeper los nodos de Apache en su clúster de Amazon MSK](zookeeper-security.md)
+ [Validación de la conformidad de Amazon Managed Streaming para Apache Kafka](MSK-compliance.md)
+ [Resiliencia en Amazon Managed Streaming para Apache Kafka](disaster-recovery-resiliency.md)
+ [Seguridad de la infraestructura en Amazon Managed Streaming para Apache Kafka](infrastructure-security.md)
# Protección de datos en Amazon Managed Streaming para Apache Kafka
El [modelo de ](https://aws.amazon.com/compliance/shared-responsibility-model/) se aplica a protección de datos en Amazon Managed Streaming for Apache Kafka. Como se describe en este modelo, AWS es responsable de proteger la infraestructura global en la que se ejecutan todos los Nube de AWS. Eres responsable de mantener el control sobre el contenido alojado en esta infraestructura. También eres responsable de las tareas de administración y configuración de seguridad para los Servicios de AWS que utiliza. Para obtener más información sobre la privacidad de los datos, consulte las [Preguntas frecuentes sobre la privacidad de datos](https://aws.amazon.com/compliance/data-privacy-faq/). Para obtener información sobre la protección de datos en Europa, consulte la publicación de blog sobre el [Modelo de responsabilidad compartida de AWS y GDPR](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) en el * Blog de seguridad de AWS *.
Con fines de protección de datos, le recomendamos que proteja Cuenta de AWS las credenciales y configure los usuarios individuales con AWS IAM Identity Center o AWS Identity and Access Management (IAM). De esta manera, solo se otorgan a cada usuario los permisos necesarios para cumplir sus obligaciones laborales. También recomendamos proteger sus datos de la siguiente manera:
+ Utiliza la autenticación multifactor (MFA) en cada cuenta.
+ Se utiliza SSL/TLS para comunicarse con AWS los recursos. Exigimos TLS 1.2 y recomendamos TLS 1.3.
+ Configure la API y el registro de actividad de los usuarios con AWS CloudTrail. Para obtener información sobre el uso de CloudTrail senderos para capturar AWS actividades, consulte [Cómo trabajar con CloudTrail senderos](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-trails.html) en la *Guía del AWS CloudTrail usuario*.
+ Utilice soluciones de AWS cifrado, junto con todos los controles de seguridad predeterminados Servicios de AWS.
+ Utiliza servicios de seguridad administrados avanzados, como Amazon Macie, que lo ayuden a detectar y proteger la información confidencial almacenada en Amazon S3.
+ Si necesita módulos criptográficos validados por FIPS 140-3 para acceder a AWS través de una interfaz de línea de comandos o una API, utilice un punto final FIPS. Para obtener más información sobre los puntos de conexión de FIPS disponibles, consulte [Estándar de procesamiento de la información federal (FIPS) 140-3](https://aws.amazon.com/compliance/fips/).
Se recomienda encarecidamente no introducir nunca información confidencial o sensible, como por ejemplo, direcciones de correo electrónico de clientes, en etiquetas o campos de formato libre, tales como el campo **Nombre**. Esto incluye cuando trabaja con Amazon MSK u otro Servicios de AWS mediante la consola, la API o AWS SDKs. AWS CLI Cualquier dato que introduzca en etiquetas o campos de formato libre utilizados para los nombres se pueden emplear para los registros de facturación o diagnóstico. Si proporciona una URL a un servidor externo, recomendamos encarecidamente que no incluya información de credenciales en la URL a fin de validar la solicitud para ese servidor.
**Topics**
+ [Cifrado de Amazon MSK](msk-encryption.md)
+ [Introducción al cifrado de Amazon MSK](msk-working-with-encryption.md)
+ [Utilice Amazon MSK APIs con puntos de enlace de VPC de interfaz](privatelink-vpc-endpoints.md)
# Cifrado de Amazon MSK
Amazon MSK proporciona opciones de cifrado de datos que puede utilizar para cumplir estrictos requisitos de administración de datos. Los certificados que Amazon MSK utiliza para el cifrado deben renovarse cada 13 meses. Amazon MSK renueva automáticamente estos certificados para todos los clústeres. Los clústeres con agentes Express permanecen en el estado `ACTIVE` cuando Amazon MSK inicia la operación de actualización de certificados. En los clústeres con agentes Standard, Amazon MSK establece el estado del clúster en `MAINTENANCE` cuando inicia la operación de actualización de certificados. MSK restablece el estado a `ACTIVE` cuando finaliza la actualización. Mientras un clúster se encuentra en la operación de actualización de certificados, puede continuar con la producción y el consumo de datos, pero no puede realizar ninguna operación de actualización en este.
## Cifrado en reposo de Amazon MSK
Amazon MSK se integra con [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/) (KMS) para ofrecer cifrado transparente del servidor. Amazon MSK siempre cifra sus datos en reposo. Al crear un clúster de MSK, puede especificar la propiedad AWS KMS key que desea que Amazon MSK utilice para cifrar sus datos en reposo. Si no se especifica una clave de KMS, Amazon MSK crea una administrada por [Clave administrada de AWS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk) y la utiliza en su nombre. Para obtener más información acerca de las claves de KMS, consulte [AWS KMS keys](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#kms_keys) en la *Guía para desarrolladores de AWS Key Management Service *.
## Cifrado en tránsito de Amazon MSK
Amazon MSK utiliza TLS 1.2. De forma predeterminada, cifra los datos en tránsito entre los agentes de su clúster de MSK. Puede anular este valor predeterminado en el momento en que cree el clúster.
Para la comunicación entre clientes y agentes, debe especificar una de las tres opciones siguientes:
+ Permitir solo datos cifrados TLS. Esta es la configuración predeterminada.
+ Permitir tanto datos de texto sin formato como datos cifrados TLS.
+ Permitir solo datos de texto sin formato.
Los corredores de Amazon MSK utilizan AWS Certificate Manager certificados públicos. Por lo tanto, cualquier almacén de confianza que confíe en Amazon Trust Services también confía en los certificados de los agentes de Amazon MSK.
Si bien recomendamos encarecidamente habilitar el cifrado en tránsito, puede agregar sobrecarga de CPU adicional y unos pocos milisegundos de latencia. Sin embargo, la mayoría de los casos de uso no son sensibles a estas diferencias y la magnitud del impacto depende de la configuración del clúster, los clientes y el perfil de uso.
# Introducción al cifrado de Amazon MSK
Al crear un clúster de MSK, puede especificar la configuración de cifrado en formato JSON. A continuación se muestra un ejemplo.
```
{
"EncryptionAtRest": {
"DataVolumeKMSKeyId": "arn:aws:kms:us-east-1:123456789012:key/abcdabcd-1234-abcd-1234-abcd123e8e8e"
},
"EncryptionInTransit": {
"InCluster": true,
"ClientBroker": "TLS"
}
}
```
Para `DataVolumeKMSKeyId`, puede especificar una [clave administrada por el cliente](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk) o la Clave administrada de AWS para MSK en su cuenta (`alias/aws/kafka`). Si no lo especifica`EncryptionAtRest`, Amazon MSK seguirá cifrando sus datos en reposo en. Clave administrada de AWS Para determinar qué clave está utilizando su clúster, envíe una solicitud `GET` o invoque la operación de la API de `DescribeCluster`.
En `EncryptionInTransit`, el valor predeterminado de `InCluster` es true, pero puede establecerlo en false si no desea que Amazon MSK cifre sus datos a medida que pasan entre los agentes.
Para especificar el modo de cifrado de los datos en tránsito entre clientes y agentes, establezca `ClientBroker` a uno de los tres valores: `TLS`, `TLS_PLAINTEXT`, o `PLAINTEXT`.
**Topics**
+ [Especificación de la configuración de cifrado al crear un clúster de Amazon MSK](msk-working-with-encryption-cluster-create.md)
+ [Prueba del cifrado TLS de Amazon MSK](msk-working-with-encryption-test-tls.md)
# Especificación de la configuración de cifrado al crear un clúster de Amazon MSK
En este proceso, se describe cómo especificar una configuración de cifrado al crear un clúster de Amazon MSK.
**Especificación de la configuración de cifrado al crear un clúster**
1. Guarde el contenido del ejemplo anterior en un archivo y asígnele el nombre que desee. Por ejemplo, llámalo `encryption-settings.json`.
1. Ejecute el comando `create-cluster` y use la opción `encryption-info` para señalar al archivo donde guardó su configuración JSON. A continuación se muestra un ejemplo. Sustitúyala por una versión que coincida *\$1YOUR MSK VERSION\$1* con la versión del cliente de Apache Kafka. Para obtener información sobre cómo encontrar la versión de clúster de MSK, consulte [Determinación de la versión del clúster de MSK](create-topic.md#find-msk-cluster-version). Tenga en cuenta que el uso de una versión de cliente de Apache Kafka que no sea la misma que su versión de clúster de MSK puede provocar la corrupción, la pérdida y el tiempo de inactividad de los datos de Apache Kafka.
```
aws kafka create-cluster --cluster-name "ExampleClusterName" --broker-node-group-info file://brokernodegroupinfo.json --encryption-info file://encryptioninfo.json --kafka-version "{YOUR MSK VERSION}" --number-of-broker-nodes 3
```
El siguiente es un ejemplo de una respuesta correcta después de ejecutar este comando.
```
{
"ClusterArn": "arn:aws:kafka:us-east-1:123456789012:cluster/SecondTLSTest/abcdabcd-1234-abcd-1234-abcd123e8e8e",
"ClusterName": "ExampleClusterName",
"State": "CREATING"
}
```
# Prueba del cifrado TLS de Amazon MSK
En este proceso, se describe cómo probar el cifrado TLS con Amazon MSK.
**Prueba del cifrado TLS**
1. Cree un equipo cliente siguiendo las instrucciones de [Paso 3: creación de un equipo cliente](create-client-machine.md).
1. Instale Apache Kafka en el equipo cliente.
1. En este ejemplo, usamos el almacén de confianza de JVM para comunicarnos con el clúster de MSK. Para ello, primero cree una carpeta denominada `/tmp` en el equipo cliente. Luego, vaya a la carpeta `bin` de la instalación de Apache Kafka y ejecute el siguiente comando. (Su ruta de JVM puede ser diferente).
```
cp /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.201.b09-0.amzn2.x86_64/jre/lib/security/cacerts /tmp/kafka.client.truststore.jks
```
1. Mientras esté aún en la carpeta `bin` de la instalación de Apache Kafka en el equipo cliente, cree un archivo de texto denominado `client.properties` con el siguiente contenido.
```
security.protocol=SSL
ssl.truststore.location=/tmp/kafka.client.truststore.jks
```
1. Ejecute el siguiente comando en una máquina que lo tenga AWS CLI instalado y *clusterARN* reemplácelo por el ARN de su clúster.
```
aws kafka get-bootstrap-brokers --cluster-arn clusterARN
```
Un resultado correcto sería como el siguiente. Guarde este resultado porque lo necesita para el siguiente paso.
```
{
"BootstrapBrokerStringTls": "a-1.example.g7oein.c2.kafka.us-east-1.amazonaws.com:0123,a-3.example.g7oein.c2.kafka.us-east-1.amazonaws.com:0123,a-2.example.g7oein.c2.kafka.us-east-1.amazonaws.com:0123"
}
```
1. Ejecute el siguiente comando y *BootstrapBrokerStringTls* reemplácelo por uno de los puntos finales del broker que obtuvo en el paso anterior.
```
/bin/kafka-console-producer.sh --broker-list BootstrapBrokerStringTls --producer.config client.properties --topic TLSTestTopic
```
1. Abra una nueva ventana de comandos y conéctese al mismo equipo cliente. A continuación, ejecute el siguiente comando para crear un consumidor de consola.
```
/bin/kafka-console-consumer.sh --bootstrap-server BootstrapBrokerStringTls --consumer.config client.properties --topic TLSTestTopic
```
1. En la ventana del productor, escriba un mensaje de texto seguido de una devolución y busque el mismo mensaje en la ventana del consumidor. Amazon MSK cifró este mensaje en tránsito.
Para obtener más información acerca de cómo configurar clientes Apache Kafka para que funcionen con datos cifrados, consulte [Configuración de clientes Kafka](https://kafka.apache.org/documentation/#security_configclients).
# Utilice Amazon MSK APIs con puntos de enlace de VPC de interfaz
Puede utilizar un punto de enlace de interfaz VPC, con tecnología de AWS PrivateLink, para evitar que el tráfico entre su Amazon VPC y Amazon APIs MSK salga de la red de Amazon. Los puntos finales de interfaz VPC no requieren una puerta de enlace a Internet, un dispositivo NAT, una conexión VPN o una conexión Direct AWS Connect. [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/what-is-privatelink.html)es una AWS tecnología que permite la comunicación privada entre AWS servicios mediante una interfaz de red elástica y privada IPs en su Amazon VPC. Para obtener más información, consulte [Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) e [Interface VPC Endpoints ()](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint).AWS PrivateLink
Sus aplicaciones se pueden conectar con Amazon MSK Provisioned y MSK Connect APIs mediante. AWS PrivateLink Para comenzar, cree un punto de conexión de VPC de interfaz para la API de Amazon MSK, con el fin de permitir el flujo de tráfico desde y hacia los recursos de la VPC de Amazon a través del punto de conexión de VPC de interfaz. Los puntos de conexión de VPC de interfaz con compatibilidad con FIPS están disponibles para las regiones de EE. UU. Para obtener más información, consulte [Creación de un punto de conexión de interfaz](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint).
Al utilizar esta característica, los clientes de Apache Kafka pueden recuperar dinámicamente las cadenas de conexión necesarias para conectarse a los recursos de MSK aprovisionado o MSK Connect, sin atravesar Internet para obtener dichas cadenas de conexión.
Cuando cree un punto de conexión de VPC de interfaz, elija uno de los siguientes puntos de conexión de nombre de servicio:
**Para MSK aprovisionado:**
+ Los siguientes puntos de enlace con nombres de servicio ya no son compatibles con las nuevas conexiones:
+ com.amazonaws.region.kafka
+ com.amazonaws.region.kafka-fips (con FIPS habilitado)
+ El servicio de punto final de Dualstack que admite tanto el tráfico como el IPv4 siguiente IPv6 :
+ aws.api.region.kafka-api
+ aws.api.region. kafka-api-fips (habilitado para FIPS)
[Para configurar los puntos finales de doble pila, debe seguir las pautas de los puntos finales de doble pila y FIPS.](https://docs.aws.amazon.com/sdkref/latest/guide/feature-endpoints.html)
Donde “region” es el nombre de la región. Elija este nombre de servicio para que funcione con MSK Provisioned-Compatible. APIs *Para obtener más información, consulte [Operaciones](https://docs.aws.amazon.com/msk/1.0/apireference/operations.html) en la versión 1.0/apireference/. https://docs.aws.amazon.com/msk/*
**Para MSK Connect:**
+ com.amazonaws.region.kafkaconnect
Donde “region” es el nombre de la región. Elija este nombre de servicio para que funcione con MSK Connect APIs compatible. Para obtener más información, consulte [Acciones](https://docs.aws.amazon.com/MSKC/latest/mskc/API_Operations.html) en la *Referencia de la API de Amazon MSK Connect*.
*Para obtener más información, incluidas step-by-step las instrucciones para crear un punto final de VPC de interfaz, consulte [Creación de un punto final de interfaz](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint) en la AWS PrivateLink Guía.*
## Controle el acceso a los puntos de enlace de VPC para Amazon MSK Provisioned o MSK Connect APIs
Las políticas de punto de conexión de VPC le permiten controlar el acceso asociando una política a un punto de conexión de VPC o utilizando campos adicionales en una política asociada a un usuario, grupo o rol de IAM para restringir el acceso para que solo se produzca a través del punto de conexión de VPC especificado. Utilice la política de ejemplo adecuada para definir los permisos de acceso para el servicio MSK aprovisionado o MSK Connect, según corresponda.
Si no adjunta una política al crear un punto de conexión, Amazon VPC adjunta una política predeterminada que le conceda acceso completo al servicio. Una política de punto de conexión no anula ni reemplaza las políticas basadas en identidad de IAM ni las políticas específicas del servicio. Se trata de una política independiente para controlar el acceso desde el punto de conexión al servicio especificado.
Para más información, consulte [Control del acceso a los servicios con puntos de conexión de VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html) en la *Guía de AWS PrivateLink *.
------
#### [ MSK Provisioned — VPC policy example ]
**Acceso de solo lectura**
Esta política de ejemplo se puede asociar a un punto de conexión de VPC. (Para obtener más información, consulte Control de acceso a recursos de Amazon VPC). Restringe las acciones únicamente a las operaciones de listado y descripción a través del punto de conexión de VPC al que está asociada.
```
{
"Statement": [
{
"Sid": "MSKReadOnly",
"Principal": "*",
"Action": [
"kafka:List*",
"kafka:Describe*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
**Ejemplo de política de punto de conexión de VPC para MSK aprovisionado**
Restricción del acceso a un clúster de MSK específico
Esta política de ejemplo se puede asociar a un punto de conexión de VPC. Restringe el acceso a un clúster específico de Kafka a través del punto de conexión de VPC al que está asociada.
```
{
"Statement": [
{
"Sid": "AccessToSpecificCluster",
"Principal": "*",
"Action": "kafka:*",
"Effect": "Allow",
"Resource": "arn:aws:kafka:us-east-1:123456789012:cluster/MyCluster"
}
]
}
```
------
#### [ MSK Connect — VPC endpoint policy example ]
**Enumeración de conectores y creación de un conector nuevo**
El siguiente es un ejemplo de una política de punto de conexión para MSK Connect. Esta política permite que el rol especificado enumere conectores y cree un conector nuevo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "MSKConnectPermissions",
"Effect": "Allow",
"Action": [
"kafkaconnect:ListConnectors",
"kafkaconnect:CreateConnector"
],
"Resource": "*",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:role/MyMSKConnectExecutionRole"
]
}
}
]
}
```
**Ejemplo de política de punto de conexión de VPC para MSK Connect**
Permite únicamente solicitudes provenientes de una dirección IP específica dentro de la VPC especificada
En el siguiente ejemplo, se muestra una política que solo permite que las solicitudes procedentes de una dirección IP específica en la VPC especificada se ejecuten correctamente. Las solicitudes de otras direcciones IP devolverán un error.
```
{
"Statement": [
{
"Action": "kafkaconnect:*",
"Effect": "Allow",
"Principal": "*",
"Resource": "*",
"Condition": {
"IpAddress": {
"aws:VpcSourceIp": "192.0.2.123"
},
"StringEquals": {
"aws:SourceVpc": "vpc-555555555555"
}
}
}
]
}
```
------
# Autenticación y autorización para Amazon MSK APIs
AWS Identity and Access Management (IAM) es una herramienta Servicio de AWS que ayuda al administrador a controlar de forma segura el acceso a los recursos. AWS Los administradores de IAM controlan quién se puede *autenticar* (iniciar sesión) y *autorizar* (tener permisos) para utilizar los recursos de Amazon MSK. La IAM es una Servicio de AWS herramienta que puede utilizar sin coste adicional.
**Topics**
+ [Cómo funciona Amazon MSK con IAM](security_iam_service-with-iam.md)
+ [Ejemplos de políticas de Amazon MSK basadas en identidades](security_iam_id-based-policy-examples.md)
+ [Roles vinculados a servicios para Amazon MSK](using-service-linked-roles.md)
+ [AWS políticas gestionadas para Amazon MSK](security-iam-awsmanpol.md)
+ [Solución de problemas de identidad y acceso de Amazon MSK](security_iam_troubleshoot.md)
# Cómo funciona Amazon MSK con IAM
Antes de utilizar IAM para administrar el acceso a Amazon MSK, debe conocer qué características de IAM se encuentran disponibles con Amazon MSK. Para obtener una visión general de cómo Amazon MSK y otros AWS servicios funcionan con IAM, consulte [AWS Servicios que funcionan con IAM en la Guía del usuario de *IAM*](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html).
**Topics**
+ [Políticas basadas en identidades de Amazon MSK](security_iam_service-with-iam-id-based-policies.md)
+ [Políticas basadas en recursos de Amazon MSK](security_iam_service-with-iam-resource-based-policies.md)
+ [Autorización basada en etiquetas de Amazon MSK](security_iam_service-with-iam-tags.md)
+ [Roles de IAM de Amazon MSK](security_iam_service-with-iam-roles.md)
# Políticas basadas en identidades de Amazon MSK
Con las políticas basadas en identidades de IAM, puede especificar las acciones y los recursos permitidos o denegados, así como las condiciones en las que se permiten o deniegan las acciones. Amazon MSK admite acciones, claves de condiciones y recursos específicos. Para obtener información sobre todos los elementos que utiliza en una política JSON, consulte [Referencia de los elementos de las políticas JSON de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) en la *Guía del usuario de IAM*.
## Acciones para las políticas basadas en identidades de Amazon MSK
Los administradores pueden usar las políticas de AWS JSON para especificar quién tiene acceso a qué. Es decir, qué **entidad principal** puede realizar **acciones** en qué **recursos** y en qué **condiciones**.
El elemento `Action` de una política JSON describe las acciones que puede utilizar para conceder o denegar el acceso en una política. Incluya acciones en una política para conceder permisos y así llevar a cabo la operación asociada.
Las acciones de políticas de Amazon MSK utilizan el siguiente prefijo antes de la acción: `kafka:`. Por ejemplo, para conceder a alguien permiso para describir un clúster de MSK con la operación de la API `DescribeCluster` de Amazon MSK, incluya la acción `kafka:DescribeCluster` en su política. Las instrucciones de la política deben incluir un elemento `Action` o un elemento `NotAction`. Amazon MSK define su propio conjunto de acciones que describen las tareas que se pueden realizar con este servicio.
Tenga en cuenta que las acciones políticas para el tema de MSK APIs usan el `kafka-cluster` prefijo antes de la acción; consulte la. [Semántica de las acciones y los recursos de la política de autorización de IAM](kafka-actions.md)
Para especificar varias acciones en una única instrucción, sepárelas con comas del siguiente modo:
```
"Action": ["kafka:action1", "kafka:action2"]
```
Puede utilizar caracteres comodín para especificar varias acciones (\$1). Por ejemplo, para especificar todas las acciones que comiencen con la palabra `Describe`, incluya la siguiente acción:
```
"Action": "kafka:Describe*"
```
Para consultar una lista de acciones de Amazon MSK, consulte [Acciones, recursos y claves de condición para Amazon Managed Streaming para Apache Kafka](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonmanagedstreamingforapachekafka.html) en la *Guía del usuario de IAM*.
## Recursos para las políticas basadas en identidades de Amazon MSK
Los administradores pueden usar las políticas de AWS JSON para especificar quién tiene acceso a qué. Es decir, qué **entidad principal** puede realizar **acciones** en qué **recursos** y en qué **condiciones**.
El elemento `Resource` de la política JSON especifica el objeto u objetos a los que se aplica la acción. Como práctica recomendada, especifique un recurso utilizando el [Nombre de recurso de Amazon (ARN)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html). En el caso de las acciones que no admiten permisos por recurso, utilice un carácter comodín (\$1) para indicar que la instrucción se aplica a todos los recursos.
```
"Resource": "*"
```
El recurso de instancia de Amazon MSK tiene el siguiente ARN:
```
arn:${Partition}:kafka:${Region}:${Account}:cluster/${ClusterName}/${UUID}
```
Para obtener más información sobre el formato de ARNs, consulte [Amazon Resource Names (ARNs) y AWS Service Namespaces](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
Por ejemplo, para especificar la instancia de `CustomerMessages` en su instrucción, utilice el siguiente ARN:
```
"Resource": "arn:aws:kafka:us-east-1:123456789012:cluster/CustomerMessages/abcd1234-abcd-dcba-4321-a1b2abcd9f9f-2"
```
Para especificar todas las instancias que pertenecen a una cuenta específica, utilice el carácter comodín (\$1):
```
"Resource": "arn:aws:kafka:us-east-1:123456789012:cluster/*"
```
Algunas acciones de Amazon MSK, como las que se utilizan para crear recursos, no se pueden llevar a cabo en un recurso específico. En dichos casos, debe utilizar el carácter comodín (\$1).
```
"Resource": "*"
```
Para especificar varios recursos en una sola sentencia, sepárelos ARNs con comas.
```
"Resource": ["resource1", "resource2"]
```
Para ver una lista de los tipos de recursos de Amazon MSK y sus tipos ARNs, consulte [Recursos definidos por Amazon Managed Streaming for Apache](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonmanagedstreamingforkafka.html#amazonmanagedstreamingforkafka-resources-for-iam-policies) Kafka Kafka en *la Guía del usuario de IAM*. Para obtener información acerca de las acciones con las que puede especificar el ARN de cada recurso, consulte [Acciones definidas por Amazon Managed Streaming para Apache Kafka](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonmanagedstreamingforkafka.html#amazonmanagedstreamingforkafka-actions-as-permissions).
## Claves de condición para las políticas basadas en identidades de Amazon MSK
Los administradores pueden usar las políticas de AWS JSON para especificar quién tiene acceso a qué. Es decir, qué **entidad principal** puede realizar **acciones** en qué **recursos** y en qué **condiciones**.
El elemento `Condition` especifica cuándo se ejecutan las instrucciones en función de criterios definidos. Puede crear expresiones condicionales que utilizan [operadores de condición](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html), tales como igual o menor que, para que la condición de la política coincida con los valores de la solicitud. Para ver todas las claves de condición AWS globales, consulte las claves de [contexto de condición AWS globales](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) en la *Guía del usuario de IAM*.
Amazon MSK define su propio conjunto de claves de condición y también admite el uso de algunas claves de condición globales. Para ver todas las claves de condición AWS globales, consulte las claves de [contexto de condición AWS globales](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) en la Guía del *usuario de IAM*.
Para consultar una lista de claves de condición de Amazon MSK, consulte [Claves de condición de Amazon Managed Streaming para Apache Kafka](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonmanagedstreamingforkafka.html#amazonmanagedstreamingforkafka-policy-keys) en la *Guía del usuario de IAM*. Para obtener más información acerca de las acciones y los recursos con los que puede utilizar una clave de condición, consulte [Acciones definidas por Amazon Managed Streaming para Apache Kafka](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonmanagedstreamingforkafka.html#amazonmanagedstreamingforkafka-actions-as-permissions).
## Ejemplos de políticas basadas en identidades de Amazon MSK
Para ver ejemplos de políticas basadas en identidades de Amazon MSK, consulte [Ejemplos de políticas de Amazon MSK basadas en identidades](security_iam_id-based-policy-examples.md).
# Políticas basadas en recursos de Amazon MSK
Amazon MSK admite una política de clústeres (también conocida como política basada en recursos) para su uso con los clústeres de Amazon MSK. Puede utilizar una política de clústeres para definir qué entidades principales de IAM tienen permisos entre cuentas para configurar la conectividad privada con su clúster de Amazon MSK. Si se utiliza con la autenticación de clientes de IAM, también puede utilizar la política de clústeres para definir de forma pormenorizada los permisos del plano de datos de Kafka para los clientes que se conectan.
El tamaño máximo admitido para una política de clúster es de 20 KB.
Para ver un ejemplo de cómo configurar una política de clúster, consulte [Paso 2: asociación de una política de clúster al clúster de MSK](mvpc-cluster-owner-action-policy.md).
# Autorización basada en etiquetas de Amazon MSK
Puede asociar etiquetas a clústeres de Amazon MSK. Para controlar el acceso en función de etiquetas, debe proporcionar información de las etiquetas en el [elemento de condición](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) de una política utilizando las claves de condición `kafka:ResourceTag/key-name`, `aws:RequestTag/key-name` o `aws:TagKeys`. Para obtener información sobre el etiquetado de los recursos de Amazon MSK, consulte [Etiquetado de un clúster de Amazon MSK](msk-tagging.md).
Puede controlar el acceso al clúster únicamente con la ayuda de etiquetas. Para etiquetar temas y grupos de consumidores, debe agregar una declaración independiente en las políticas sin etiquetas.
Para ver un ejemplo de una política basada en identidad que limita el acceso a un clúster en función de las etiquetas de ese clúster, consulte [Acceso a los clústeres de Amazon MSK basados en etiquetas](security_iam_id-based-policy-examples-view-widget-tags.md).
Puede utilizar condiciones en la política basada en identidades para controlar el acceso a los recursos de Amazon MSK basados en etiquetas. El siguiente ejemplo muestra una política que permite a un usuario describir el clúster, obtener sus agentes de arranque, enumerar sus nodos de agentes, actualizarlo y eliminarlo. Sin embargo, esta política concede permisos únicamente si la etiqueta del clúster `Owner` tiene el valor del `username` de ese usuario. La segunda declaración de la siguiente política permite el acceso a los temas del clúster. La primera declaración de esta política no autoriza ningún acceso a los temas.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AccessClusterIfOwner",
"Effect": "Allow",
"Action": [
"kafka:Describe*",
"kafka:Get*",
"kafka:List*",
"kafka:Update*",
"kafka:Delete*"
],
"Resource": "arn:aws:kafka:us-east-1:123456789012:cluster/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Owner": "${aws:username}"
}
}
},
{
"Effect": "Allow",
"Action": [
"kafka-cluster:*Topic*",
"kafka-cluster:WriteData",
"kafka-cluster:ReadData"
],
"Resource": [
"arn:aws:kafka:us-east-1:123456789012:topic/*"
]
}
]
}
```
------
# Roles de IAM de Amazon MSK
Un [rol de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) es una entidad de la cuenta de Amazon Web Services que dispone de permisos específicos.
## Uso de credenciales temporales con Amazon MSK
Puede utilizar credenciales temporales para iniciar sesión con federación, asumir un rol de IAM o asumir un rol de acceso entre cuentas. Las credenciales de seguridad temporales se obtienen llamando a operaciones de AWS STS API como [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)o [GetFederationToken](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetFederationToken.html).
Amazon MSK admite el uso de credenciales temporales.
## Roles vinculados a servicios
Los [roles vinculados a servicios](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) permiten que Amazon Web Services acceda a los recursos de otros servicios para completar una acción en su nombre. Los roles vinculados a servicios aparecen en la cuenta de IAM y son propiedad del servicio. Un administrador puede ver, pero no editar, los permisos de los roles vinculados a servicios.
Amazon MSK admite roles vinculados a servicios. Para obtener más información sobre cómo crear o administrar roles vinculados a servicios de Amazon MSK, consulte [Roles vinculados a servicios para Amazon MSK](using-service-linked-roles.md).
# Ejemplos de políticas de Amazon MSK basadas en identidades
De forma predeterminada, los usuarios y roles de IAM no tienen permiso para llevar a cabo operaciones de la API de Amazon MSK. Un administrador debe crear políticas de IAM que concedan permisos a los usuarios y a los roles para realizar operaciones de la API concretas en los recursos especificados que necesiten. El administrador debe adjuntar esas políticas a los usuarios o grupos de IAM que necesiten esos permisos.
Para obtener información acerca de cómo crear una política basada en identidad de IAM con estos documentos de políticas JSON de ejemplo, consulte [Creación de políticas en la pestaña JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor) en la *Guía del usuario de IAM*.
**Topics**
+ [Prácticas recomendadas relativas a políticas](security_iam_service-with-iam-policy-best-practices.md)
+ [Cómo permitir a los usuarios consultar sus propios permisos](security_iam_id-based-policy-examples-view-own-permissions.md)
+ [Acceso a un clúster de Amazon MSK](security_iam_id-based-policy-examples-access-one-cluster.md)
+ [Acceso a los clústeres de Amazon MSK basados en etiquetas](security_iam_id-based-policy-examples-view-widget-tags.md)
# Prácticas recomendadas relativas a políticas
Las políticas basadas en identidades determinan si alguien puede crear, eliminar o acceder a los recursos de Amazon MSK de la cuenta. Estas acciones pueden generar costos adicionales para su Cuenta de AWS. Siga estas directrices y recomendaciones al crear o editar políticas basadas en identidades:
+ **Comience con las políticas AWS administradas y avance hacia los permisos con privilegios mínimos**: para empezar a conceder permisos a sus usuarios y cargas de trabajo, utilice las *políticas AWS administradas* que otorgan permisos en muchos casos de uso comunes. Están disponibles en su. Cuenta de AWS Le recomendamos que reduzca aún más los permisos definiendo políticas administradas por el AWS cliente que sean específicas para sus casos de uso. Con el fin de obtener más información, consulte las [políticas administradas por AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) o las [políticas administradas por AWS para funciones de tarea](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) en la *Guía de usuario de IAM*.
+ **Aplique permisos de privilegio mínimo**: cuando establezca permisos con políticas de IAM, conceda solo los permisos necesarios para realizar una tarea. Para ello, debe definir las acciones que se pueden llevar a cabo en determinados recursos en condiciones específicas, también conocidos como *permisos de privilegios mínimos*. Con el fin de obtener más información sobre el uso de IAM para aplicar permisos, consulte [Políticas y permisos en IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) en la *Guía del usuario de IAM*.
+ **Utilice condiciones en las políticas de IAM para restringir aún más el acceso**: puede agregar una condición a sus políticas para limitar el acceso a las acciones y los recursos. Por ejemplo, puede escribir una condición de políticas para especificar que todas las solicitudes deben enviarse utilizando SSL. También puedes usar condiciones para conceder el acceso a las acciones del servicio si se utilizan a través de una acción específica Servicio de AWS, por ejemplo CloudFormation. Para obtener más información, consulte [Elementos de la política de JSON de IAM: Condición](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) en la *Guía del usuario de IAM*.
+ **Utiliza el analizador de acceso de IAM para validar las políticas de IAM con el fin de garantizar la seguridad y funcionalidad de los permisos**: el analizador de acceso de IAM valida políticas nuevas y existentes para que respeten el lenguaje (JSON) de las políticas de IAM y las prácticas recomendadas de IAM. El analizador de acceso de IAM proporciona más de 100 verificaciones de políticas y recomendaciones procesables para ayudar a crear políticas seguras y funcionales. Para más información, consulte [Validación de políticas con el Analizador de acceso de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html) en la *Guía del usuario de IAM*.
+ **Requerir autenticación multifactor (MFA**): si tiene un escenario que requiere usuarios de IAM o un usuario raíz en Cuenta de AWS su cuenta, active la MFA para mayor seguridad. Para exigir la MFA cuando se invoquen las operaciones de la API, añada condiciones de MFA a sus políticas. Para más información, consulte [Acceso seguro a la API con MFA](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html) en la *Guía del usuario de IAM*.
Para obtener más información sobre las prácticas recomendadas de IAM, consulte [Prácticas recomendadas de seguridad en IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) en la *Guía del usuario de IAM*.
# Cómo permitir a los usuarios consultar sus propios permisos
En este ejemplo, se muestra cómo podría crear una política que permita a los usuarios de IAM ver las políticas administradas e insertadas que se asocian a la identidad de sus usuarios. Esta política incluye permisos para completar esta acción en la consola o mediante programación mediante la API o. AWS CLI AWS
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ViewOwnUserInfo",
"Effect": "Allow",
"Action": [
"iam:GetUserPolicy",
"iam:ListGroupsForUser",
"iam:ListAttachedUserPolicies",
"iam:ListUserPolicies",
"iam:GetUser"
],
"Resource": ["arn:aws:iam::*:user/${aws:username}"]
},
{
"Sid": "NavigateInConsole",
"Effect": "Allow",
"Action": [
"iam:GetGroupPolicy",
"iam:GetPolicyVersion",
"iam:GetPolicy",
"iam:ListAttachedGroupPolicies",
"iam:ListGroupPolicies",
"iam:ListPolicyVersions",
"iam:ListPolicies",
"iam:ListUsers"
],
"Resource": "*"
}
]
}
```
# Acceso a un clúster de Amazon MSK
En este ejemplo, desea conceder acceso a un usuario de IAM de su cuenta de Amazon Web Services a uno de sus clústeres, `purchaseQueriesCluster`. Esta directiva permite al usuario describir el clúster, obtener sus agentes de arranque, enumerar sus nodos de agentes y actualizarlo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"UpdateCluster",
"Effect":"Allow",
"Action":[
"kafka:Describe*",
"kafka:Get*",
"kafka:List*",
"kafka:Update*"
],
"Resource":"arn:aws:kafka:us-east-1:012345678012:cluster/purchaseQueriesCluster/abcdefab-1234-abcd-5678-cdef0123ab01-2"
}
]
}
```
------
# Acceso a los clústeres de Amazon MSK basados en etiquetas
Puede utilizar condiciones en la política basada en identidades para controlar el acceso a los recursos de Amazon MSK basados en etiquetas. En este ejemplo se muestra cómo crear una directiva que permita al usuario describir el clúster, obtener sus agentes de arranque, enumerar sus nodos de agentes, actualizarla y eliminarla. Sin embargo, los permisos solo se conceden si la etiqueta de clúster `Owner` tiene el valor del nombre de usuario de dicho usuario.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AccessClusterIfOwner",
"Effect": "Allow",
"Action": [
"kafka:Describe*",
"kafka:Get*",
"kafka:List*",
"kafka:Update*",
"kafka:Delete*"
],
"Resource": "arn:aws:kafka:us-east-1:012345678012:cluster/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Owner": "${aws:username}"
}
}
}
]
}
```
------
También puede asociar esta política al usuario de IAM en su cuenta. Si un usuario llamado `richard-roe` intenta actualizar un clúster de MSK, el clúster debe tener la etiqueta `Owner=richard-roe` o `owner=richard-roe`. De lo contrario, se le deniega el acceso. La clave de la etiqueta de condición `Owner` coincide con los nombres de las claves de condición `Owner` y `owner` porque no distinguen entre mayúsculas y minúsculas. Para obtener más información, consulte [Elementos de la política de JSON de IAM: Condición](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) en la *Guía del usuario de IAM*.
# Roles vinculados a servicios para Amazon MSK
Amazon MSK utiliza funciones vinculadas a [servicios AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) (IAM). Un rol vinculado a servicios es un tipo único de rol de IAM que se encuentra vinculado directamente a Amazon MSK. Amazon MSK predefine las funciones vinculadas al servicio e incluyen todos los permisos que el servicio requiere para llamar a otros AWS servicios en su nombre.
Un rol vinculado a servicios simplifica la configuración de Amazon MSK porque ya no tendrá que agregar de forma manual los permisos necesarios. Amazon MSK define los permisos de sus roles vinculados a servicios. A menos que se defina lo contrario, solo Amazon MSK puede asumir sus roles. Los permisos definidos incluyen las políticas de confianza y de permisos, y que la política de permisos no se pueda asociar a ninguna otra entidad de IAM.
Para obtener información acerca de otros servicios que admiten roles vinculados a servicios, consulte [Servicios de Amazon Web Services que funcionan con IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) y busque los servicios que tengan **Sí** en la columna **Roles vinculados a servicios**. Elija una opción **Sí** con un enlace para ver la documentación acerca del rol vinculado al servicio en cuestión.
**Topics**
+ [Permisos de roles vinculados a servicios](slr-permissions.md)
+ [Creación de un rol vinculado al servicio](create-slr.md)
+ [Edición de un rol vinculado a servicios](edit-slr.md)
+ [Regiones admitidas para los roles vinculados a servicios de](slr-regions.md)
# Permisos de roles vinculados a servicios para Amazon MSK
Amazon MSK usa el rol vinculado a servicios denominado **AWSServiceRoleForKafka**. Amazon MSK utiliza esta función para acceder a sus recursos y realizar operaciones como las siguientes:
+ `*NetworkInterface`: cree y administre interfaces de red en la cuenta del cliente que hagan que los clientes de la VPC del cliente puedan acceder a los agentes de clústeres.
+ `*VpcEndpoints`— administre los puntos finales de la VPC en la cuenta del cliente para que los agentes de clústeres sean accesibles a los clientes de la VPC del cliente que utilizan. AWS PrivateLink Amazon MSK usa permisos para `DescribeVpcEndpoints`, `ModifyVpcEndpoint` y `DeleteVpcEndpoints`.
+ `secretsmanager`— gestione las credenciales de los clientes con. AWS Secrets Manager
+ `GetCertificateAuthorityCertificate`: recupere el certificado para su autoridad de certificación privada.
+ `*Ipv6Addresses`— asignar y desasignar IPv6 direcciones a las interfaces de red de la cuenta del cliente para permitir la IPv6 conectividad de los clústeres de MSK.
+ `ModifyNetworkInterfaceAttribute`— modifique los atributos de la interfaz de red en la cuenta del cliente para configurar los IPv6 ajustes de conectividad del clúster de MSK.
Este rol vinculado a un servicio se adjunta a la siguiente política administrada: `KafkaServiceRolePolicy`. Para obtener actualizaciones de esta política, consulte [KafkaServiceRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/KafkaServiceRolePolicy.html).
El rol vinculado al servicio AWSServiceRoleForKafka depende de los siguientes servicios para asumir el rol:
+ `kafka.amazonaws.com`
La política de permisos del rol permite que Amazon MSK realice las siguientes acciones en los recursos.
Debe configurar permisos para permitir a una entidad de IAM (como un usuario, grupo o rol) crear, editar o eliminar un rol vinculado a servicios. Para obtener más información, consulte [Permisos de roles vinculados a servicios](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#service-linked-role-permissions) en la *Guía del usuario de IAM*.
# Creación de un rol vinculado a los servicios para Amazon MSK
No necesita crear manualmente un rol vinculado a un servicio. Cuando crea un clúster de Amazon MSK en la Consola de administración de AWS, la o la AWS API AWS CLI, Amazon MSK crea el rol vinculado al servicio por usted.
Si elimina este rol vinculado a servicios y necesita crearlo de nuevo, puede utilizar el mismo proceso para volver a crear el rol en su cuenta. Al crear un clúster de Amazon MSK, Amazon MSK se encarga de crear de nuevo el rol vinculado a servicios en su nombre.
# Edición de un rol vinculado a los servicios para Amazon MSK
Amazon MSK no permite editar el rol vinculado a servicios de AWSServiceRoleForKafka. Después de crear un rol vinculado al servicio, no podrá cambiar el nombre del rol, ya que varias entidades podrían hacer referencia al rol. Sin embargo, sí puede editar la descripción del rol con IAM. Para obtener más información, consulte [Edición de un rol vinculado a servicios](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#edit-service-linked-role) en la *Guía del usuario de IAM*.
# Regiones admitidas para los roles vinculados a servicios de Amazon MSK
Amazon MSK admite el uso de roles vinculados a servicios en todas las regiones en las que se encuentra disponible el servicio. Para obtener más información, consulte [AWS Regiones y puntos de conexión](https://docs.aws.amazon.com/general/latest/gr/rande.html).
# AWS políticas gestionadas para Amazon MSK
Una política AWS administrada es una política independiente creada y administrada por. AWS AWS Las políticas administradas están diseñadas para proporcionar permisos para muchos casos de uso comunes, de modo que pueda empezar a asignar permisos a usuarios, grupos y funciones.
Ten en cuenta que es posible que las políticas AWS administradas no otorguen permisos con privilegios mínimos para tus casos de uso específicos, ya que están disponibles para que los usen todos los AWS clientes. Se recomienda definir [políticas administradas por el cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#customer-managed-policies) específicas para sus casos de uso a fin de reducir aún más los permisos.
No puedes cambiar los permisos definidos en AWS las políticas administradas. Si AWS actualiza los permisos definidos en una política AWS administrada, la actualización afecta a todas las identidades principales (usuarios, grupos y roles) a las que está asociada la política. AWS es más probable que actualice una política AWS administrada cuando Servicio de AWS se lance una nueva o cuando estén disponibles nuevas operaciones de API para los servicios existentes.
Para obtener más información, consulte [Políticas administradas por AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) en la *Guía del usuario de IAM*.
# AWS política gestionada: Amazon MSKFull Access
Esta política otorga permisos administrativos que brindan a una entidad principal acceso completo a todas las acciones de Amazon MSK. Los permisos de esta política se agrupan de la siguiente manera:
+ Los permisos de Amazon MSK permiten todas las acciones de Amazon MSK.
+ **Permisos de `Amazon EC2`**: en esta política, son obligatorios para validar los recursos transferidos en una solicitud de API. Esto es para garantizar que Amazon MSK pueda utilizar correctamente los recursos con un clúster. El resto de los permisos de Amazon EC2 de esta política permiten a Amazon MSK crear AWS los recursos necesarios para que pueda conectarse a sus clústeres.
+ **Permisos de `AWS KMS`**: se utilizan durante las llamadas a la API para validar los recursos transferidos en una solicitud. Son necesarios para que Amazon MSK pueda utilizar la clave pasada con el clúster de Amazon MSK.
+ **Permisos de `CloudWatch Logs, Amazon S3, and Amazon Data Firehose`**: son obligatorios para que Amazon MSK garantice que se pueda acceder a los destinos de entrega de registros y que sean válidos para el uso de los registros de los agentes.
+ **Permisos de `IAM`**: son obligatorios para que Amazon MSK pueda crear un rol vinculado a los servicios en su cuenta y para permitirle transferir un rol de ejecución de servicios a Amazon MSK.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"kafka:*",
"ec2:DescribeSubnets",
"ec2:DescribeVpcs",
"ec2:DescribeSecurityGroups",
"ec2:DescribeRouteTables",
"ec2:DescribeVpcEndpoints",
"ec2:DescribeVpcAttribute",
"kms:DescribeKey",
"kms:CreateGrant",
"logs:CreateLogDelivery",
"logs:GetLogDelivery",
"logs:UpdateLogDelivery",
"logs:DeleteLogDelivery",
"logs:ListLogDeliveries",
"logs:PutResourcePolicy",
"logs:DescribeResourcePolicies",
"logs:DescribeLogGroups",
"S3:GetBucketPolicy",
"firehose:TagDeliveryStream"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateVpcEndpoint"
],
"Resource": [
"arn:*:ec2:*:*:vpc/*",
"arn:*:ec2:*:*:subnet/*",
"arn:*:ec2:*:*:security-group/*"
]
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateVpcEndpoint"
],
"Resource": [
"arn:*:ec2:*:*:vpc-endpoint/*"
],
"Condition": {
"StringEquals": {
"aws:RequestTag/AWSMSKManaged": "true"
},
"StringLike": {
"aws:RequestTag/ClusterArn": "*"
}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateTags"
],
"Resource": "arn:*:ec2:*:*:vpc-endpoint/*",
"Condition": {
"StringEquals": {
"ec2:CreateAction": "CreateVpcEndpoint"
}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:DeleteVpcEndpoints"
],
"Resource": "arn:*:ec2:*:*:vpc-endpoint/*",
"Condition": {
"StringEquals": {
"ec2:ResourceTag/AWSMSKManaged": "true"
},
"StringLike": {
"ec2:ResourceTag/ClusterArn": "*"
}
}
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "*",
"Condition": {
"StringEquals": {
"iam:PassedToService": "kafka.amazonaws.com"
}
}
},
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/kafka.amazonaws.com/AWSServiceRoleForKafka*",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "kafka.amazonaws.com"
}
}
},
{
"Effect": "Allow",
"Action": [
"iam:AttachRolePolicy",
"iam:PutRolePolicy"
],
"Resource": "arn:aws:iam::*:role/aws-service-role/kafka.amazonaws.com/AWSServiceRoleForKafka*"
},
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/delivery.logs.amazonaws.com/AWSServiceRoleForLogDelivery*",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "delivery.logs.amazonaws.com"
}
}
}
]
}
```
------
# AWS política gestionada: Amazon MSKRead OnlyAccess
Esta política otorga permisos de solo lectura que permiten a los usuarios ver información en Amazon MSK. Las entidades principales con esta política asociada no pueden realizar actualizaciones ni eliminar los recursos existentes, ni pueden crear nuevos recursos de Amazon MSK. Por ejemplo, las entidades principales con estos permisos pueden ver la lista de configuraciones y clústeres asociados a su cuenta, pero no pueden cambiar la configuración ni los ajustes de ningún clúster. Los permisos de esta política se agrupan de la siguiente manera:
+ **Permisos de `Amazon MSK`**: permiten enumerar los recursos de Amazon MSK, describirlos y obtener información sobre ellos.
+ **`Amazon EC2`permisos**: se utilizan para describir la VPC de Amazon, las subredes y ENIs los grupos de seguridad asociados a un clúster.
+ **Permisos de `AWS KMS`**: se utiliza para describir la clave asociada al clúster.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"kafka:Describe*",
"kafka:List*",
"kafka:Get*",
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeVpcs",
"kms:DescribeKey"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
# AWS política gestionada: KafkaServiceRolePolicy
No puede adjuntarse KafkaServiceRolePolicy a sus entidades de IAM. Esta política se encuentra asociada a un rol vinculado a servicios que permite a Amazon MSK realizar acciones como administrar puntos de conexión (conectores) de VPC en clústeres de MSK, administrar interfaces de red y administrar credenciales de clúster con AWS Secrets Manager. Para obtener más información, consulte [Roles vinculados a servicios para Amazon MSK](using-service-linked-roles.md).
En la siguiente tabla se describen las actualizaciones de la política KafkaServiceRolePolicy gestionada desde que Amazon MSK comenzó a rastrear los cambios.
| Cambio | Descripción | Fecha |
| --- | --- | --- |
| [IPv6 soporte de conectividad agregado a KafkaServiceRolePolicy](#security-iam-awsmanpol-KafkaServiceRolePolicy): actualización a una política existente | Amazon MSK agregó permisos KafkaServiceRolePolicy para habilitar la IPv6 conectividad de los clústeres de MSK. Estos permisos permiten a Amazon MSK asignar y desasignar IPv6 direcciones a las interfaces de red y modificar los atributos de las interfaces de red en la cuenta del cliente. | 17 de noviembre de 2025 |
| [KafkaServiceRolePolicy](#security-iam-awsmanpol-KafkaServiceRolePolicy): actualización de una política actual | Amazon MSK agregó permisos para admitir la conectividad privada con varias VPC. | 8 de marzo de 2023 |
| Amazon MSK comenzó a hacer un seguimiento de los cambios | Amazon MSK ha empezado a realizar un seguimiento de los cambios de la política KafkaServiceRolePolicy gestionada. | 8 de marzo de 2023 |
# AWS política gestionada: AWSMSKReplicator ExecutionRole
La política `AWSMSKReplicatorExecutionRole` concede permisos al Replicador Amazon MSK para replicar datos entre los clústeres de MSK. Los permisos de esta política se agrupan de la siguiente manera:
+ **`cluster`**: otorga al Replicador Amazon MSK permisos para conectarse al clúster con la autenticación de IAM. También concede permisos para describir y modificar el clúster.
+ **`topic`**: otorga al Replicador Amazon MSK permisos para describir, crear y modificar un tema, así como para modificar la configuración dinámica del tema.
+ **`consumer group`**: otorga al Replicador Amazon MSK permisos para describir y modificar grupos de consumidores, leer y escribir datos de un clúster de MSK y eliminar temas internos que creó el Replicador.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ClusterPermissions",
"Effect": "Allow",
"Action": [
"kafka-cluster:Connect",
"kafka-cluster:DescribeCluster",
"kafka-cluster:AlterCluster",
"kafka-cluster:DescribeTopic",
"kafka-cluster:CreateTopic",
"kafka-cluster:AlterTopic",
"kafka-cluster:WriteData",
"kafka-cluster:ReadData",
"kafka-cluster:AlterGroup",
"kafka-cluster:DescribeGroup",
"kafka-cluster:DescribeTopicDynamicConfiguration",
"kafka-cluster:AlterTopicDynamicConfiguration",
"kafka-cluster:WriteDataIdempotently"
],
"Resource": [
"arn:aws:kafka:*:*:cluster/*"
]
},
{
"Sid": "TopicPermissions",
"Effect": "Allow",
"Action": [
"kafka-cluster:DescribeTopic",
"kafka-cluster:CreateTopic",
"kafka-cluster:AlterTopic",
"kafka-cluster:WriteData",
"kafka-cluster:ReadData",
"kafka-cluster:DescribeTopicDynamicConfiguration",
"kafka-cluster:AlterTopicDynamicConfiguration",
"kafka-cluster:AlterCluster"
],
"Resource": [
"arn:aws:kafka:*:*:topic/*/*"
]
},
{
"Sid": "GroupPermissions",
"Effect": "Allow",
"Action": [
"kafka-cluster:AlterGroup",
"kafka-cluster:DescribeGroup"
],
"Resource": [
"arn:aws:kafka:*:*:group/*/*"
]
}
]
}
```
------
# Amazon MSK actualiza las políticas AWS gestionadas
Consulta los detalles sobre las actualizaciones de las políticas AWS gestionadas de Amazon MSK desde que este servicio comenzó a realizar el seguimiento de estos cambios.
| Cambio | Descripción | Fecha |
| --- | --- | --- |
| [WriteDataIdempotently permiso agregado a AWSMSKReplicator ExecutionRole](security-iam-awsmanpol-AWSMSKReplicatorExecutionRole.md): actualización a una política existente | Amazon MSK ha añadido WriteDataIdempotently permisos a la AWSMSKReplicator ExecutionRole política para admitir la replicación de datos entre clústeres de MSK. | 12 de marzo de 2024 |
| [AWSMSKReplicatorExecutionRole](security-iam-awsmanpol-AWSMSKReplicatorExecutionRole.md): política nueva | Amazon MSK agregó una AWSMSKReplicator ExecutionRole política para admitir Amazon MSK Replicator. | 4 de diciembre de 2023 |
| [Amazon MSKFull Access](security-iam-awsmanpol-AmazonMSKFullAccess.md): actualización de una política existente | Amazon MSK agregó permisos para admitir el Replicador MSK de Amazon. | 28 de septiembre de 2023 |
| [KafkaServiceRolePolicy](security-iam-awsmanpol-KafkaServiceRolePolicy.md): actualización de una política actual | Amazon MSK agregó permisos para admitir la conectividad privada con varias VPC. | 8 de marzo de 2023 |
| [Amazon MSKFull Access](security-iam-awsmanpol-AmazonMSKFullAccess.md): actualización de una política existente | Amazon MSK agregó nuevos permisos de Amazon EC2 para permitir la conexión a un clúster. | 30 de noviembre de 2021 |
| [Amazon MSKFull Access](security-iam-awsmanpol-AmazonMSKFullAccess.md): actualización de una política existente | Amazon MSK agregó un nuevo permiso que le permite describir las tablas de enrutamiento de Amazon EC2. | 19 de noviembre de 2021 |
| Amazon MSK comenzó a hacer un seguimiento de los cambios | Amazon MSK comenzó a realizar un seguimiento de los cambios en sus políticas AWS gestionadas. | 19 de noviembre de 2021 |
# Solución de problemas de identidad y acceso de Amazon MSK
Utilice la siguiente información para diagnosticar y solucionar los problemas habituales que pueden surgir cuando se trabaja con Amazon MSK e IAM.
**Topics**
+ [No tengo autorización para realizar una acción en Amazon MSK](#security_iam_troubleshoot-no-permissions)
## No tengo autorización para realizar una acción en Amazon MSK
Si Consola de administración de AWS le indica que no está autorizado a realizar una acción, debe ponerse en contacto con su administrador para obtener ayuda. El administrador es la persona que le proporcionó las credenciales de inicio de sesión.
En el siguiente ejemplo, el error se produce cuando el usuario de IAM `mateojackson` intenta utilizar la consola para eliminar un clúster, pero no tiene permisos `kafka:DeleteCluster`.
```
User: arn:aws:iam::123456789012:user/mateojackson is not authorized to perform: kafka:DeleteCluster on resource: purchaseQueriesCluster
```
En este caso, Mateo pide a su administrador que actualice sus políticas de forma que pueda obtener acceso al recurso `purchaseQueriesCluster` mediante la acción `kafka:DeleteCluster`.
# Autenticación y autorización para Apache Kafka APIs
Puede utilizar IAM para autenticar clientes y permitir o denegar acciones de Apache Kafka. Como alternativa, puede usar TLS o SASL/SCRAM para autenticar clientes y Apache Kafka ACLs para permitir o denegar acciones.
Para obtener información sobre cómo controlar quién puede realizar las [operaciones de Amazon MSK](https://docs.aws.amazon.com/msk/1.0/apireference/operations.html) en su clúster, consulte [Autenticación y autorización para Amazon MSK APIs](security-iam.md).
**Topics**
+ [Control de acceso de IAM](iam-access-control.md)
+ [Autenticación TLS mutua de clientes para Amazon MSK](msk-authentication.md)
+ [Autenticación de credenciales de inicio de sesión con AWS Secrets Manager](msk-password.md)
+ [Apache Kafka ACLs](msk-acls.md)
# Control de acceso de IAM
El control de acceso de IAM para Amazon MSK le permite gestionar tanto la autenticación como la autorización de su clúster de MSK. Esto elimina la necesidad de utilizar un mecanismo de autenticación y otro mecanismo de autorización. Por ejemplo, cuando un cliente intenta escribir en su clúster, Amazon MSK utiliza IAM para verificar si el cliente es una identidad autenticada y si está autorizado para producir en su clúster.
El control de acceso de IAM funciona para clientes Java y no Java, incluidos los clientes de Kafka escritos en Python JavaScript, Go y.NET. El control de acceso mediante IAM para clientes que no son Java está disponible para clústeres de MSK con la versión 2.7.1 de Kafka o posterior.
Para hacer posible el control de acceso de IAM, Amazon MSK realiza pequeñas modificaciones en el código fuente de Apache Kafka. Estas modificaciones no supondrán una diferencia notable en su experiencia con Apache Kafka. Amazon MSK registra los eventos de acceso para que pueda auditarlos.
Puede invocar la ACL de Apache Kafka APIs para un clúster de MSK que utilice el control de acceso de IAM. Sin embargo, Apache Kafka no afecta a la ACLs autorización de las identidades de IAM. Debe utilizar políticas de IAM para controlar el acceso de las identidades de IAM.
**Consideraciones importantes**
Cuando utilice el control de acceso mediante IAM con el clúster de MSK, tenga en cuenta las siguientes consideraciones importantes:
El control de acceso de IAM no se aplica a los nodos de Apache. ZooKeeper Para obtener más información sobre cómo puede controlar el acceso a estos nodos, consulte [Controle el acceso a ZooKeeper los nodos de Apache en su clúster de Amazon MSK](zookeeper-security.md).
La configuración `allow.everyone.if.no.acl.found` de Apache Kafka no tiene efecto si el clúster utiliza el control de acceso de IAM.
Puede invocar la ACL de Apache Kafka APIs para un clúster de MSK que utilice el control de acceso de IAM. Sin embargo, Apache Kafka no afecta a la ACLs autorización de las identidades de IAM. Debe utilizar políticas de IAM para controlar el acceso de las identidades de IAM.
# Cómo funciona el control de acceso de IAM para Amazon MSK
Para utilizar el control de acceso de IAM para Amazon MSK, lleve a cabo los pasos que se describen en detalle en los siguientes temas:
+ [Creación de un clúster de Amazon MSK que utilice el control de acceso de IAM](create-iam-access-control-cluster-in-console.md)
+ [Configuración de clientes para el control de acceso de IAM](configure-clients-for-iam-access-control.md)
+ [Creación de políticas de autorización para el rol de IAM](create-iam-access-control-policies.md)
+ [Obtener los agentes de arranque para el control de acceso de IAM](get-bootstrap-brokers-for-iam.md)
# Creación de un clúster de Amazon MSK que utilice el control de acceso de IAM
En esta sección se explica cómo puede utilizar la Consola de administración de AWS API o la AWS CLI para crear un clúster de Amazon MSK que utilice el control de acceso de IAM. Para obtener información sobre cómo activar el control de acceso de IAM en un clúster existente, consulte [Actualización de la configuración de seguridad de un clúster de Amazon MSK](msk-update-security.md).
**Úselo Consola de administración de AWS para crear un clúster que utilice el control de acceso de IAM**
1. Abra la consola de Amazon MSK en [https://console.aws.amazon.com/msk/](https://console.aws.amazon.com/msk/).
1. Elija **Create cluster**.
1. Elija **Crear clúster con configuración personalizada**.
1. En la sección **Autenticación**, elija **Control de acceso de IAM**.
1. Complete el resto del flujo de trabajo para crear un clúster.
**Utilice la API o la AWS CLI para crear un clúster que utilice el control de acceso de IAM**
+ Para crear un clúster con el control de acceso de IAM habilitado, utilice la [CreateCluster](https://docs.aws.amazon.com/msk/1.0/apireference/clusters.html#CreateCluster)API o el comando CLI [create-cluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kafka/create-cluster.html) y pase el siguiente JSON para `ClientAuthentication` el parámetro:. `"ClientAuthentication": { "Sasl": { "Iam": { "Enabled": true } }`
# Configuración de clientes para el control de acceso de IAM
Para permitir que los clientes se comuniquen con un clúster de MSK que utiliza el control de acceso de IAM, elija uno de estos mecanismos:
+ Configuración de clientes que no son de Java mediante un mecanismo SASL\$1OAUTHBEARER
+ Configuración del cliente Java mediante SASL\$1OAUTHBEARER un mecanismo o AWS\$1MSK\$1IAM mecanismo
## Utilice el SASL\$1OAUTHBEARER mecanismo para configurar IAM
1. Edite el archivo de configuración client.properties con el siguiente ejemplo de cliente de Kafka en Python. Los cambios de configuración son parecidos en otros idiomas.
```
from kafka import KafkaProducer
from kafka.errors import KafkaError
from kafka.sasl.oauth import AbstractTokenProvider
import socket
import time
from aws_msk_iam_sasl_signer import MSKAuthTokenProvider
class MSKTokenProvider():
def token(self):
token, _ = MSKAuthTokenProvider.generate_auth_token('')
return token
tp = MSKTokenProvider()
producer = KafkaProducer(
bootstrap_servers='',
security_protocol='SASL_SSL',
sasl_mechanism='OAUTHBEARER',
sasl_oauth_token_provider=tp,
client_id=socket.gethostname(),
)
topic = ""
while True:
try:
inp=input(">")
producer.send(topic, inp.encode())
producer.flush()
print("Produced!")
except Exception:
print("Failed to send message:", e)
producer.close()
```
1. Descargue la biblioteca auxiliar para el lenguaje de configuración que haya elegido y siga las instrucciones de la sección *Introducción* de la página principal de la biblioteca correspondiente.
+ JavaScript: [https://github.com/aws/aws-msk-iam-sasl-signer-js \$1getting -started](https://github.com/aws/aws-msk-iam-sasl-signer-js#getting-started)
+ Python: [https://github.com/aws/aws-msk-iam-sasl-signer-python](https://github.com/aws/aws-msk-iam-sasl-signer-python#get-started) \$1get -started
+ [Go: -signer-go \$1getting -started https://github.com/aws/ aws-msk-iam-sasl](https://github.com/aws/aws-msk-iam-sasl-signer-go#getting-started)
+ [.NET: -signer-net \$1getting -started https://github.com/aws/ aws-msk-iam-sasl](https://github.com/aws/aws-msk-iam-sasl-signer-net#getting-started)
+ JAVA: el SASL\$1OAUTHBEARER soporte para Java está disponible a través del archivo jar [https://github.com/aws/aws-msk-iam-auth/releases](https://github.com/aws/aws-msk-iam-auth/releases)
## Utilice el AWS\$1MSK\$1IAM mecanismo personalizado de MSK para configurar IAM
1. Agregue la línea siguiente al archivo `client.properties`. **Sustitúyala por la ruta completa al archivo del almacén de confianza del cliente.
**nota**
Si no desea utilizar un certificado específico, puede eliminar `ssl.truststore.location=` del archivo `client.properties`. Cuando no especifica un valor para `ssl.truststore.location`, el proceso de Java utiliza el certificado predeterminado.
```
ssl.truststore.location=
security.protocol=SASL_SSL
sasl.mechanism=AWS_MSK_IAM
sasl.jaas.config=software.amazon.msk.auth.iam.IAMLoginModule required;
sasl.client.callback.handler.class=software.amazon.msk.auth.iam.IAMClientCallbackHandler
```
Para usar un perfil con nombre que haya creado para AWS las credenciales, inclúyalo `awsProfileName="your profile name";` en el archivo de configuración del cliente. Para obtener información sobre los perfiles con [nombre, consulte Perfiles](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-profiles.html) con nombre en la AWS CLI documentación.
1. Descargue el último archivo [aws-msk-iam-auth](https://github.com/aws/aws-msk-iam-auth/releases)JAR estable y colóquelo en la ruta de clases. Si usa Maven, agregue la siguiente dependencia y ajuste el número de versión según sea necesario:
```
software.amazon.msk
aws-msk-iam-auth
1.0.0
```
El complemento de cliente de Amazon MSK es de código abierto y cuenta con la licencia Apache 2.0.
# Creación de políticas de autorización para el rol de IAM
Asocie una política de autorización al rol de IAM que corresponda al cliente. En una política de autorización, se especifican las acciones que se van a permitir o denegar para el rol. Si su cliente está en una instancia de Amazon EC2, asocie la política de autorización al rol de IAM de esa instancia de Amazon EC2. Como alternativa, puede configurar su cliente para que utilice un perfil con nombre y, a continuación, asociar la política de autorización al rol de ese perfil con nombre. [Configuración de clientes para el control de acceso de IAM](configure-clients-for-iam-access-control.md) describe cómo configurar un cliente para utilizar un perfil con nombre asignado.
Para obtener más información sobre cómo crear una política de IAM, consulte [Creación de políticas de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html).
A continuación se muestra un ejemplo de política de autorización para un clúster denominado MyTestCluster. Para entender la semántica de los elementos `Action` y `Resource`, consulte [Semántica de las acciones y los recursos de la política de autorización de IAM](kafka-actions.md).
**importante**
Los cambios que realice en una política de IAM se reflejan en el IAM APIs e inmediatamente. AWS CLI Sin embargo, puede pasar un tiempo considerable hasta que el cambio en la política surta efecto. En la mayoría de los casos, los cambios en la política entran en vigor en menos de un minuto. En ocasiones, las condiciones de la red pueden aumentar la demora.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kafka-cluster:Connect",
"kafka-cluster:AlterCluster",
"kafka-cluster:DescribeCluster"
],
"Resource": [
"arn:aws:kafka:us-east-1:111122223333:cluster/MyTestCluster/abcd1234-0123-abcd-5678-1234abcd-1"
]
},
{
"Effect": "Allow",
"Action": [
"kafka-cluster:*Topic*",
"kafka-cluster:WriteData",
"kafka-cluster:ReadData"
],
"Resource": [
"arn:aws:kafka:us-east-1:123456789012:topic/MyTestCluster/*"
]
},
{
"Effect": "Allow",
"Action": [
"kafka-cluster:AlterGroup",
"kafka-cluster:DescribeGroup"
],
"Resource": [
"arn:aws:kafka:us-east-1:123456789012:group/MyTestCluster/*"
]
}
]
}
```
------
Para obtener información sobre cómo crear una política con elementos de acción que se correspondan con los casos de uso habituales de Apache Kafka, como la producción y el consumo de datos, consulte [Casos de uso habituales de la política de autorización de clientes](iam-access-control-use-cases.md).
[En las versiones 2.8.0 y posteriores de Kafka, el **WriteDataIdempotently**permiso está obsoleto (KIP-679).](https://cwiki.apache.org/confluence/display/KAFKA/KIP-679%3A+Producer+will+enable+the+strongest+delivery+guarantee+by+default) Se utiliza `enable.idempotence = true` de forma predeterminada. Por lo tanto, para las versiones 2.8.0 y posteriores de Kafka, IAM no ofrece la misma funcionalidad que Kafka. ACLs No es posible `WriteDataIdempotently` en un tema si se proporciona únicamente acceso de `WriteData` a ese tema. Esto no afecta al caso en el que se proporciona `WriteData` a **TODOS** los temas. En ese caso, `WriteDataIdempotently` está permitido. Esto se debe a las diferencias en la implementación de la lógica de IAM y en la forma en que se implementa la Kafka. ACLs Además, la escritura idempotente en un tema también requiere acceso a `transactional-ids`.
Para solucionar esta limitación, se recomienda utilizar una política similar a la que se muestra a continuación.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kafka-cluster:Connect",
"kafka-cluster:AlterCluster",
"kafka-cluster:DescribeCluster",
"kafka-cluster:WriteDataIdempotently"
],
"Resource": [
"arn:aws:kafka:us-east-1:123456789012:cluster/MyTestCluster/abcd1234-0123-abcd-5678-1234abcd-1"
]
},
{
"Effect": "Allow",
"Action": [
"kafka-cluster:*Topic*",
"kafka-cluster:WriteData",
"kafka-cluster:ReadData"
],
"Resource": [
"arn:aws:kafka:us-east-1:123456789012:topic/MyTestCluster/abcd1234-0123-abcd-5678-1234abcd-1/TestTopic",
"arn:aws:kafka:us-east-1:123456789012:transactional-id/MyTestCluster/abcd1234-0123-abcd-5678-1234abcd-1/*"
]
}
]
}
```
------
En este caso, `WriteData` permite escribir en `TestTopic` y, al mismo tiempo, `WriteDataIdempotently` permite escrituras idempotentes en el clúster. Esta política también agrega acceso a los recursos de `transactional-id` que serán necesarios.
Dado que `WriteDataIdempotently` es un permiso de clúster, no se puede utilizar en los temas. Si `WriteDataIdempotently` se restringe al nivel de tema, esta política no funcionará.
# Obtener los agentes de arranque para el control de acceso de IAM
Consulte [Obtención de agentes de arranque para un clúster de Amazon MSK](msk-get-bootstrap-brokers.md).
# Semántica de las acciones y los recursos de la política de autorización de IAM
**nota**
Para los clústeres que ejecutan la versión 3.8 o posterior de Apache Kafka, el control de acceso de IAM admite la WriteTxnMarkers API para finalizar las transacciones. En el caso de los clústeres que ejecutan versiones de Kafka anteriores a la 3.8, el control de acceso de IAM no admite ni siquiera las acciones internas del clúster. WriteTxnMarkers En estas versiones anteriores, para finalizar las transacciones, utiliza la autenticación SCRAM o mTLS con la autenticación adecuada ACLs en lugar de la autenticación de IAM.
En esta sección se explica la semántica de los elementos de acción y recursos que puede utilizar en una política de autorización de IAM. Para ver una política de ejemplo, consulte [Creación de políticas de autorización para el rol de IAM](create-iam-access-control-policies.md).
## Acciones de la política de autorización
En la siguiente tabla se enumeran las acciones que puede incluir en una política de autorización cuando utiliza el control de acceso de IAM para Amazon MSK. Si incluye en su política de autorización una acción de la columna *Acción* de la tabla, también debe incluir las acciones correspondientes de la columna *Acciones obligatorias*.
| Action | Description (Descripción) | Acciones obligatorias | Recursos necesarios de | Aplicable a los clústeres sin servidor |
| --- | --- | --- | --- | --- |
| kafka-cluster:Connect | Otorga permiso para conectarse y autenticarse en el clúster. | Ninguno | clúster | Sí |
| kafka-cluster:DescribeCluster | Otorga permiso para describir varios aspectos del clúster, equivalente a la ACL DESCRIBE CLUSTER de Apache Kafka. | `kafka-cluster:Connect` | clúster | Sí |
| kafka-cluster:AlterCluster | Otorga permiso para alterar varios aspectos del clúster, equivalente a la ACL ALTER CLUSTER de Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeCluster` | clúster | No |
| kafka-cluster:DescribeClusterDynamicConfiguration | Otorga permiso para describir la configuración dinámica de un clúster, equivalente a la ACL de CLÚSTER DESCRIBE\$1CONFIGS de Apache Kafka. | `kafka-cluster:Connect` | clúster | No |
| kafka-cluster:AlterClusterDynamicConfiguration | Otorga permiso para modificar la configuración dinámica de un clúster, equivalente a la ACL de CLÚSTER ALTER\$1CONFIGS de Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeClusterDynamicConfiguration` | clúster | No |
| kafka-cluster:WriteDataIdempotently | Otorga permiso para escribir datos idempotentemente en un clúster, equivalente a la ACL de CLÚSTER IDEMPOTENT\$1WRITE de Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:WriteData` | clúster | Sí |
| kafka-cluster:CreateTopic | Otorga permiso para crear temas en un clúster, lo que equivale a la ACL CREATE de Apache Kafka. CLUSTER/TOPIC | `kafka-cluster:Connect` | tema | Sí |
| kafka-cluster:DescribeTopic | Otorga permiso para describir temas en un clúster, equivalente a la ACL DESCRIBE TOPIC de Apache Kafka. | `kafka-cluster:Connect` | tema | Sí |
| kafka-cluster:AlterTopic | Otorga permiso para modificar temas en un clúster, equivalente a la ACL ALTER TOPIC de Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` | tema | Sí |
| kafka-cluster:DeleteTopic | Otorga permiso para eliminar temas de un clúster, equivalente a la ACL DELETE TOPIC de Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` | tema | Sí |
| kafka-cluster:DescribeTopicDynamicConfiguration | Otorga permiso para describir la configuración dinámica de temas en un clúster, equivalente a la ACL DESCRIBE\$1CONFIGS TOPIC de Apache Kafka. | `kafka-cluster:Connect` | tema | Sí |
| kafka-cluster:AlterTopicDynamicConfiguration | Otorga permiso para modificar la configuración dinámica de temas en un clúster, equivalente a la ACL de TEMA ALTER\$1CONFIGS de Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeTopicDynamicConfiguration` | tema | Sí |
| kafka-cluster:ReadData | Otorga permiso para leer datos de temas de un clúster, equivalente a la ACL READ TOPIC de Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:AlterGroup` | tema | Sí |
| kafka-cluster:WriteData | Otorga permiso para escribir datos en temas de un clúster, equivalente a la ACL WRITE TOPIC de Apache Kafka | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` | tema | Sí |
| kafka-cluster:DescribeGroup | Otorga permiso para describir grupos en un clúster, equivalente a la ACL DESCRIBE GROUP de Apache Kafka. | `kafka-cluster:Connect` | grupo | Sí |
| kafka-cluster:AlterGroup | Otorga permiso para unirse a grupos en un clúster, equivalente a la ACL READ GROUP de Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeGroup` | grupo | Sí |
| kafka-cluster:DeleteGroup | Otorga permiso para eliminar grupos de un clúster, equivalente a la ACL DELETE GROUP de Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeGroup` | grupo | Sí |
| kafka-cluster:DescribeTransactionalId | Otorga permiso para describir las transacciones IDs en un clúster, lo que equivale a la ACL DESCRIBE TRANSACTIONAL\$1ID de Apache Kafka. | `kafka-cluster:Connect` | transactional-id | Sí |
| kafka-cluster:AlterTransactionalId | Otorga permiso para modificar las transacciones IDs en un clúster, lo que equivale a la ACL WRITE TRANSACTIONAL\$1ID de Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeTransactionalId` `kafka-cluster:WriteData` | transactional-id | Sí |
Puede utilizar el carácter comodín asterisco (\$1) cualquier número de veces en una acción después de los dos puntos. A continuación se muestran algunos ejemplos.
+ `kafka-cluster:*Topic` significa `kafka-cluster:CreateTopic`, `kafka-cluster:DescribeTopic`, `kafka-cluster:AlterTopic` y `kafka-cluster:DeleteTopic`. No incluye `kafka-cluster:DescribeTopicDynamicConfiguration` ni `kafka-cluster:AlterTopicDynamicConfiguration`.
+ `kafka-cluster:*` se refiere a todos los permisos.
## Recursos de la política de autorización
En la siguiente tabla se muestran los cuatro tipos de recursos que puede utilizar en una política de autorización cuando utiliza el control de acceso de IAM para Amazon MSK. Puede obtener el nombre de recurso de Amazon (ARN) del clúster desde Consola de administración de AWS o mediante la [DescribeCluster](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn.html#DescribeCluster)API o el comando [AWS CLI describe-cluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kafka/describe-cluster.html). A continuación, puede usar el ARN del clúster para crear el tema, el grupo y el ID de transacción. ARNs Para especificar un recurso en una política de autorización, se utiliza el ARN de ese recurso.
| Recurso | Formato de ARN |
| --- | --- |
| Clúster | arn:aws:kafka: ::cluster//regionaccount-idcluster-namecluster-uuid |
| Topic | arn:aws:kafka: region :topic///account-idcluster-namecluster-uuidtopic-name |
| Group | arn:aws:kafka: region ::group///account-idcluster-namecluster-uuidgroup-name |
| ID de transacción | arn:aws:kafka: region ::transactional-id///account-idcluster-namecluster-uuidtransactional-id |
Puede utilizar el comodín asterisco (\$1) cualquier número de veces en cualquier parte del ARN que venga después de `:cluster/`, `:topic/`, `:group/` y `:transactional-id/`. A continuación, se muestran algunos ejemplos de cómo puede utilizar el carácter comodín asterisco (\$1) para hacer referencia a varios recursos:
+ `arn:aws:kafka:us-east-1:0123456789012:topic/MyTestCluster/*`: todos los temas de cualquier clúster con nombre, independientemente del UUID del clúster. MyTestCluster
+ `arn:aws:kafka:us-east-1:0123456789012:topic/MyTestCluster/abcd1234-0123-abcd-5678-1234abcd-1/*_test`: todos los temas cuyo nombre termine por «\$1test» del clúster cuyo nombre MyTestCluster y UUID sean abcd1234-0123-abcd-5678-1234abcd-1.
+ `arn:aws:kafka:us-east-1:0123456789012:transactional-id/MyTestCluster/*/5555abcd-1111-abcd-1234-abcd1234-1`: todas las transacciones cuyo identificador de transacción sea 5555abcd-1111-abcd-1234-abcd1234-1, en todas las versiones de un clúster con el nombre de tu cuenta. MyTestCluster Esto significa que si crea un clúster con el nombre MyTestCluster, lo elimina y, a continuación, crea otro clúster con el mismo nombre, puede usar este ARN de recurso para representar el mismo ID de transacciones en ambos clústeres. Sin embargo, no se puede acceder al clúster eliminado.
# Casos de uso habituales de la política de autorización de clientes
En la primera columna de la tabla siguiente se muestran algunos casos de uso habituales. Para autorizar a un cliente a llevar a cabo un caso de uso determinado, incluya las acciones necesarias para ese caso de uso en la política de autorización del cliente y establezca `Effect` en `Allow`.
Para obtener información sobre todas las acciones que forman parte del control de acceso de IAM para Amazon MSK, consulte [Semántica de las acciones y los recursos de la política de autorización de IAM](kafka-actions.md).
**nota**
Las acciones se deniegan de forma predeterminada. Debe permitir de forma explícita todas las acciones que quiera que el cliente pueda realizar.
****
| Caso de uso | Acciones obligatorias |
| --- | --- |
| Administrador | `kafka-cluster:*` |
| Crear un tema | `kafka-cluster:Connect` `kafka-cluster:CreateTopic` |
| Producir datos | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:WriteData` |
| Consumir datos | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:DescribeGroup` `kafka-cluster:AlterGroup` `kafka-cluster:ReadData` |
| Producir datos de forma idempotente | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:WriteData` `kafka-cluster:WriteDataIdempotently` |
| Producir datos de forma transaccional | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:WriteData` `kafka-cluster:DescribeTransactionalId` `kafka-cluster:AlterTransactionalId` |
| Describir la configuración de un clúster | `kafka-cluster:Connect` `kafka-cluster:DescribeClusterDynamicConfiguration` |
| Actualizar la configuración de un clúster | `kafka-cluster:Connect` `kafka-cluster:DescribeClusterDynamicConfiguration` `kafka-cluster:AlterClusterDynamicConfiguration` |
| Describir la configuración de un tema | `kafka-cluster:Connect` `kafka-cluster:DescribeTopicDynamicConfiguration` |
| Actualizar la configuración de un tema | `kafka-cluster:Connect` `kafka-cluster:DescribeTopicDynamicConfiguration` `kafka-cluster:AlterTopicDynamicConfiguration` |
| Modificar un tema | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:AlterTopic` |
# Autenticación TLS mutua de clientes para Amazon MSK
Puede habilitar la autenticación de clientes con TLS para las conexiones desde sus aplicaciones a sus agentes de Amazon MSK. Para usar la autenticación del cliente, necesita una Autoridad de certificación privada de AWS. Autoridad de certificación privada de AWS Puede estar en el Cuenta de AWS mismo clúster o en una cuenta diferente. Para obtener información sobre Autoridad de certificación privada de AWS s, consulte [Creación y administración de un Autoridad de certificación privada de AWS](https://docs.aws.amazon.com/acm-pca/latest/userguide/create-CA.html).
Amazon MSK no admite listas de revocación de certificados ()CRLs. Para controlar el acceso a los temas de su clúster o bloquear los certificados comprometidos, utilice Apache Kafka ACLs y AWS los grupos de seguridad. Para obtener información sobre el uso de Apache Kafka ACLs, consulte. [Apache Kafka ACLs](msk-acls.md)
**Topics**
+ [Creación de un clúster de Amazon MSK compatible con la autenticación de clientes](msk-authentication-cluster.md)
+ [Configuración de un cliente para que utilice la autenticación](msk-authentication-client.md)
+ [Producción y consumo de mensajes con la autenticación](msk-authentication-messages.md)
# Creación de un clúster de Amazon MSK compatible con la autenticación de clientes
Este procedimiento le muestra cómo habilitar la autenticación de clientes mediante un Autoridad de certificación privada de AWS.
**nota**
Recomendamos encarecidamente utilizar un TLS independiente Autoridad de certificación privada de AWS para cada clúster de MSK cuando utilice un TLS mutuo para controlar el acceso. De este modo, se asegurará de que los certificados TLS firmados PCAs únicamente se autentiquen con un único clúster de MSK.
1. Cree un archivo denominado `clientauthinfo.json` con el siguiente contenido. *Private-CA-ARN*Sustitúyalo por el ARN de su PCA.
```
{
"Tls": {
"CertificateAuthorityArnList": ["Private-CA-ARN"]
}
}
```
1. Cree un archivo llamado `brokernodegroupinfo.json` tal y como se describe en [Cree un clúster de Amazon MSK aprovisionado mediante AWS CLI](create-cluster-cli.md).
1. La autenticación del cliente precisa que también habilite el cifrado en tránsito entre clientes y agentes. Cree un archivo denominado `encryptioninfo.json` con el siguiente contenido. *KMS-Key-ARN*Sustitúyala por el ARN de la clave KMS. Puede establecer `ClientBroker` en `TLS` o `TLS_PLAINTEXT`.
```
{
"EncryptionAtRest": {
"DataVolumeKMSKeyId": "KMS-Key-ARN"
},
"EncryptionInTransit": {
"InCluster": true,
"ClientBroker": "TLS"
}
}
```
Para obtener más información sobre el cifrado, consulte [Cifrado de Amazon MSK](msk-encryption.md).
1. En una máquina en la que la tengas AWS CLI instalada, ejecuta el siguiente comando para crear un clúster con la autenticación y el cifrado en tránsito habilitados. Guarde el ARN del clúster proporcionado en la respuesta.
```
aws kafka create-cluster --cluster-name "AuthenticationTest" --broker-node-group-info file://brokernodegroupinfo.json --encryption-info file://encryptioninfo.json --client-authentication file://clientauthinfo.json --kafka-version "{YOUR KAFKA VERSION}" --number-of-broker-nodes 3
```
# Configuración de un cliente para que utilice la autenticación
En este proceso, se describe cómo configurar una instancia de Amazon EC2 para utilizarla como cliente para la autenticación.
En este proceso, se describe cómo producir y consumir mensajes con la autenticación mediante la creación de un equipo cliente, la creación de un tema y la configuración de los ajustes de seguridad necesarios.
1. Cree una instancia de Amazon EC2 para utilizarla como un equipo cliente. Para simplificar, cree esta instancia en la misma VPC que utilizó para el clúster. Consulte [Paso 3: creación de un equipo cliente](create-client-machine.md) para ver un ejemplo sobre cómo crear dicho equipo cliente.
1. Cree un tema. Para ver un ejemplo, consulte las instrucciones en [Paso 4: creación de un tema en el clúster de Amazon MSK](create-topic.md).
1. En una máquina en la que lo tenga AWS CLI instalado, ejecute el siguiente comando para obtener los agentes de arranque del clúster. *Cluster-ARN*Sustitúyalo por el ARN de su clúster.
```
aws kafka get-bootstrap-brokers --cluster-arn Cluster-ARN
```
Guarde la cadena asociada a `BootstrapBrokerStringTls` en la respuesta.
1. En la máquina de su cliente, ejecute el siguiente comando para utilizar el almacén de confianza de JVM para crear su almacén de confianza del cliente. Si su ruta de JVM es diferente, ajuste el comando en consecuencia.
```
cp /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.201.b09-0.amzn2.x86_64/jre/lib/security/cacerts kafka.client.truststore.jks
```
1. En la máquina de su cliente, ejecute el siguiente comando para crear una clave privada para su cliente. Sustituya *Distinguished-Name**Example-Alias*,*Your-Store-Pass*, y por *Your-Key-Pass* las cadenas que prefiera.
```
keytool -genkey -keystore kafka.client.keystore.jks -validity 300 -storepass Your-Store-Pass -keypass Your-Key-Pass -dname "CN=Distinguished-Name" -alias Example-Alias -storetype pkcs12 -keyalg rsa
```
1. En la máquina de su cliente, ejecute el siguiente comando para crear una solicitud de certificado con la clave privada que creo en el paso anterior.
```
keytool -keystore kafka.client.keystore.jks -certreq -file client-cert-sign-request -alias Example-Alias -storepass Your-Store-Pass -keypass Your-Key-Pass
```
1. Abra el archivo `client-cert-sign-request` y asegúrese de que comience por `-----BEGIN CERTIFICATE REQUEST-----` y termine por `-----END CERTIFICATE REQUEST-----`. Si comienza por `-----BEGIN NEW CERTIFICATE REQUEST-----`, elimine la palabra `NEW` (y el espacio único que le sigue) desde el comienzo hasta el final del archivo.
1. En una máquina en la que lo tenga AWS CLI instalado, ejecute el siguiente comando para firmar la solicitud de certificado. *Private-CA-ARN*Sustitúyalo por el ARN de su PCA. Puede cambiar el valor de la validez si lo desea. Aquí utilizamos 300 como ejemplo.
```
aws acm-pca issue-certificate --certificate-authority-arn Private-CA-ARN --csr fileb://client-cert-sign-request --signing-algorithm "SHA256WITHRSA" --validity Value=300,Type="DAYS"
```
Guarde el ARN del certificado proporcionado en la respuesta.
**nota**
Para recuperar el certificado de cliente, utilice el comando `acm-pca get-certificate` y especifique el ARN del certificado. Para obtener más información, consulte [get-certificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/acm-pca/get-certificate.html) en la *Referencia de comandos de la AWS CLI *.
1. Ejecute el siguiente comando para obtener el certificado Autoridad de certificación privada de AWS firmado por usted. *Certificate-ARN*Sustitúyalo por el ARN que obtuvo de la respuesta al comando anterior.
```
aws acm-pca get-certificate --certificate-authority-arn Private-CA-ARN --certificate-arn Certificate-ARN
```
1. A partir del resultado de JSON de la ejecución del comando anterior, copie las cadenas asociadas a `Certificate` y `CertificateChain`. Pegue estas dos cadenas en un nuevo archivo llamado signed-certificate-from-acm. Pegue la siguiente cadena asociada a `Certificate` primero, seguido de la cadena asociada a `CertificateChain`. Sustituya los caracteres `\n` por las nuevas líneas. La siguiente es la estructura del archivo después de pegarle el certificado y la cadena del certificado.
```
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
```
1. Ejecute el siguiente comando en el equipo cliente para agregar este certificado a su almacén de claves para que puede presentarlo al hablar con los agentes de MSK.
```
keytool -keystore kafka.client.keystore.jks -import -file signed-certificate-from-acm -alias Example-Alias -storepass Your-Store-Pass -keypass Your-Key-Pass
```
1. Cree un archivo denominado `client.properties` con el siguiente contenido. Ajuste las ubicaciones del almacén de confianza y de claves a las rutas en las que guardó `kafka.client.truststore.jks`. Sustituya los *\$1YOUR KAFKA VERSION\$1* marcadores de posición por su versión de cliente de Kafka.
```
security.protocol=SSL
ssl.truststore.location=/tmp/kafka_2.12-{YOUR KAFKA VERSION}/kafka.client.truststore.jks
ssl.keystore.location=/tmp/kafka_2.12-{YOUR KAFKA VERSION}/kafka.client.keystore.jks
ssl.keystore.password=Your-Store-Pass
ssl.key.password=Your-Key-Pass
```
# Producción y consumo de mensajes con la autenticación
En este proceso, se describe cómo producir y consumir mensajes con la autenticación.
1. Ejecute el siguiente comando para crear un tema. El archivo denominado `client.properties` es el que creó en el procedimiento anterior.
```
/bin/kafka-topics.sh --create --bootstrap-server BootstrapBroker-String --replication-factor 3 --partitions 1 --topic ExampleTopic --command-config client.properties
```
1. Ejecute el siguiente comando para iniciar un productor de la consola. El archivo denominado `client.properties` es el que creó en el procedimiento anterior.
```
/bin/kafka-console-producer.sh --bootstrap-server BootstrapBroker-String --topic ExampleTopic --producer.config client.properties
```
1. En una nueva ventana de comandos en la máquina de su cliente, ejecute el siguiente comando para iniciar un consumidor de la consola.
```
/bin/kafka-console-consumer.sh --bootstrap-server BootstrapBroker-String --topic ExampleTopic --consumer.config client.properties
```
1. Escriba mensajes en la ventana del productor y observe cómo aparecen en la ventana del consumidor.
# Autenticación de credenciales de inicio de sesión con AWS Secrets Manager
Puede controlar el acceso a sus clústeres de Amazon MSK mediante credenciales de inicio de sesión que se almacenan y protegen mediante AWS Secrets Manager. El almacenamiento de las credenciales de usuario en Secrets Manager reduce la sobrecarga de la autenticación de clústeres, como la auditoría, la actualización y la rotación de credenciales. Secrets Manager también le permite compartir las credenciales de usuario entre clústeres.
Después de asociar un secreto a un clúster de MSK, MSK sincroniza periódicamente los datos de credenciales.
**Topics**
+ [Funcionamiento de la autenticación de las credenciales de inicio de sesión](msk-password-howitworks.md)
+ [Configurar la SASL/SCRAM autenticación para un clúster de Amazon MSK](msk-password-tutorial.md)
+ [Uso de los usuarios](msk-password-users.md)
+ [Limitaciones al momento de utilizar los secretos SCRAM](msk-password-limitations.md)
# Funcionamiento de la autenticación de las credenciales de inicio de sesión
La autenticación con credenciales de inicio de sesión para Amazon MSK utiliza la autenticación SASL/SCRAM (Simple Authentication and Security Layer/ Salted Challenge Response Mechanism). A fin de configurar la autenticación con credenciales de inicio de sesión para un clúster, debe crear un recurso de secreto en [AWS Secrets Manager](https://docs.aws.amazon.com//secretsmanager/?id=docs_gateway) y asociar las credenciales de inicio de sesión a ese secreto.
SASL/SCRAM se define en [RFC 5802](https://tools.ietf.org/html/rfc5802). SCRAM utiliza algoritmos hash seguros y no transmite credenciales de inicio de sesión de texto sin formato entre el cliente y el servidor.
**nota**
Al configurar la SASL/SCRAM autenticación para el clúster, Amazon MSK activa el cifrado TLS para todo el tráfico entre clientes y agentes.
# Configurar la SASL/SCRAM autenticación para un clúster de Amazon MSK
Para configurar un secreto en AWS Secrets Manager, sigue el tutorial [Cómo crear y recuperar un secreto](https://docs.aws.amazon.com/secretsmanager/latest/userguide/tutorials_basic.html) en la [Guía del usuario de AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html).
Tenga en cuenta los siguientes requisitos al crear un secreto para un clúster de Amazon MSK:
+ En el tipo de secreto, elija **Otro tipo de secretos (por ejemplo, clave de API)**.
+ El nombre secreto debe comenzar con el prefijo **AmazonMSK\$1**.
+ Debes usar una AWS KMS clave personalizada existente o crear una nueva AWS KMS clave personalizada para tu secreto. Secrets Manager usa la AWS KMS clave predeterminada para un secreto de forma predeterminada.
**importante**
Un secreto creado con la AWS KMS clave predeterminada no se puede usar con un clúster de Amazon MSK.
+ Los datos de sus credenciales de inicio de sesión deben tener el siguiente formato para poder ingresar pares clave-valor mediante la opción **Texto no cifrado**.
```
{
"username": "alice",
"password": "alice-secret"
}
```
+ Registre el valor del ARN (nombre del recurso de Amazon) de su secreto.
+
**importante**
No puede asociar un secreto de Secrets Manager a un clúster que supere los límites descritos en [Dimensione correctamente el clúster: número de particiones por agente Standard](bestpractices.md#partitions-per-broker).
+ Si utiliza el AWS CLI para crear el secreto, especifique un ID de clave o un ARN para el `kms-key-id` parámetro. No especifique un alias.
+ Para asociar el secreto a su clúster, utilice la consola de Amazon MSK o la [ BatchAssociateScramSecret](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn-scram-secrets.html#BatchAssociateScramSecret)operación.
**importante**
Al asociar un secreto a un clúster, Amazon MSK asocia una política de recursos al secreto que permite al clúster acceder a los valores de los secretos que ha definido y leerlos. No debe modificar esta política de recursos. Si lo hace, puede impedir que el clúster acceda a su secreto. Si realiza cambios en la política del recurso de Secretos o en la clave de KMS utilizada para el cifrado del secreto, asegúrese de volver a asociar los secretos al clúster de MSK. Esto garantiza que el clúster mantenga el acceso al secreto.
El siguiente ejemplo de entrada JSON para la operación `BatchAssociateScramSecret` asocia un secreto a un clúster:
```
{
"clusterArn" : "arn:aws:kafka:us-west-2:0123456789019:cluster/SalesCluster/abcd1234-abcd-cafe-abab-9876543210ab-4",
"secretArnList": [
"arn:aws:secretsmanager:us-west-2:0123456789019:secret:AmazonMSK_MyClusterSecret"
]
}
```
# Conexión a un clúster con credenciales de inicio de sesión
Después de crear un secreto y asociarlo al clúster, puede conectar el cliente con el clúster. El siguiente procedimiento muestra cómo conectar un cliente a un clúster que utiliza la SASL/SCRAM autenticación. También muestra cómo producir y consumir datos desde un tema de ejemplo.
**Topics**
+ [Conectar un cliente a un clúster mediante SASL/SCRAM autenticación](#w2aab9c13c29c17c13c11b9b7)
+ [Solución de problemas de conexión](#msk-password-tutorial-connect-troubleshooting)
## Conectar un cliente a un clúster mediante SASL/SCRAM autenticación
1. Ejecute el siguiente comando en una máquina que AWS CLI esté instalada. *clusterARN*Sustitúyalo por el ARN de su clúster.
```
aws kafka get-bootstrap-brokers --cluster-arn clusterARN
```
Del resultado JSON de este comando, guarde el valor asociado a la cadena llamada `BootstrapBrokerStringSaslScram`. Utilizará este valor en pasos posteriores.
1. En su equipo cliente, cree un archivo de configuración JAAS que contenga las credenciales de usuario almacenadas en su secreto. Por ejemplo, para el usuario **alice**, cree un archivo llamado `users_jaas.conf` con el siguiente contenido.
```
KafkaClient {
org.apache.kafka.common.security.scram.ScramLoginModule required
username="alice"
password="alice-secret";
};
```
1. Utilice el siguiente comando para exportar el archivo de configuración de JAAS como parámetro de entorno `KAFKA_OPTS`.
```
export KAFKA_OPTS=-Djava.security.auth.login.config=/users_jaas.conf
```
1. Cree un archivo denominado `kafka.client.truststore.jks` en el directorio `/tmp`.
1. (Opcional) Utilice el siguiente comando para copiar el archivo del almacén de claves del JDK desde la carpeta `cacerts` del JVM al archivo `kafka.client.truststore.jks` que creó en el paso anterior. *JDKFolder*Sustitúyalo por el nombre de la carpeta JDK de la instancia. Por ejemplo, su carpeta JDK podría llamarse `java-1.8.0-openjdk-1.8.0.201.b09-0.amzn2.x86_64`.
```
cp /usr/lib/jvm/JDKFolder/lib/security/cacerts /tmp/kafka.client.truststore.jks
```
1. En el directorio `bin` de su instalación de Apache Kafka, cree un archivo de propiedades del cliente llamado `client_sasl.properties` con el siguiente contenido. Este archivo define el mecanismo y el protocolo SASL.
```
security.protocol=SASL_SSL
sasl.mechanism=SCRAM-SHA-512
```
1. Para crear un tema de ejemplo, ejecute el siguiente comando. *BootstrapBrokerStringSaslScram*Sustitúyala por la cadena del broker bootstrap que obtuviste en el paso 1 de este tema.
```
/bin/kafka-topics.sh --create --bootstrap-server BootstrapBrokerStringSaslScram --command-config /client_sasl.properties --replication-factor 3 --partitions 1 --topic ExampleTopicName
```
1. Para continuar con el tema de ejemplo que ha creado, ejecute el siguiente comando en su equipo cliente. *BootstrapBrokerStringSaslScram*Sustitúyala por la cadena bootstrap broker que recuperaste en el paso 1 de este tema.
```
/bin/kafka-console-producer.sh --broker-list BootstrapBrokerStringSaslScram --topic ExampleTopicName --producer.config client_sasl.properties
```
1. Para continuar con el tema que ha creado, ejecute el siguiente comando en el equipo cliente. *BootstrapBrokerStringSaslScram*Sustitúyala por la cadena bootstrap broker que obtuviste en el paso 1 de este tema.
```
/bin/kafka-console-consumer.sh --bootstrap-server BootstrapBrokerStringSaslScram --topic ExampleTopicName --from-beginning --consumer.config client_sasl.properties
```
## Solución de problemas de conexión
Cuando ejecute comandos de cliente de Kafka, es posible que encuentre errores de memoria del montón de Java, especialmente al trabajar con temas o conjuntos de datos de gran tamaño. Estos errores se producen porque las herramientas de Kafka se ejecutan como aplicaciones Java con configuraciones de memoria predeterminadas que pueden ser insuficientes para la carga de trabajo.
Para resolver los errores `Out of Memory Java Heap`, puede aumentar el tamaño del montón de Java mediante la modificación de la variable de entorno `KAFKA_OPTS` para incluir la configuración de memoria.
El siguiente ejemplo establece el tamaño máximo del montón en 1 GB (`-Xmx1G`). Puede ajustar este valor en función de la memoria del sistema disponible y de los requisitos.
```
export KAFKA_OPTS="-Djava.security.auth.login.config=/users_jaas.conf -Xmx1G"
```
Para consumir temas de gran tamaño, considere el uso de parámetros basados en tiempo o en desplazamientos, en lugar de `--from-beginning`, con el fin de limitar el uso de memoria.
```
/bin/kafka-console-consumer.sh --bootstrap-server BootstrapBrokerStringSaslScram --topic ExampleTopicName --max-messages 1000 --consumer.config client_sasl.properties
```
# Uso de los usuarios
**Creación de usuarios**: los usuarios se crean en su secreto como pares clave-valor. Al utilizar la opción **Texto no cifrado** de la consola de Secrets Manager, debe especificar los datos de las credenciales de inicio de sesión en el siguiente formato:
```
{
"username": "alice",
"password": "alice-secret"
}
```
**Revocar el acceso de un usuario:** para revocar las credenciales de un usuario para acceder a un clúster, le recomendamos que primero elimine o aplique una ACL en el clúster y, a continuación, desasocie el secreto. Esto se debe a lo siguiente:
+ La eliminación de un usuario no cierra las conexiones existentes.
+ Los cambios realizados en el secreto tardan hasta 10 minutos en propagarse.
Para obtener más información acerca del uso de ACL con Amazon MSK, consulte [Apache Kafka ACLs](msk-acls.md).
En el caso de los clústeres que utilizan el ZooKeeper modo, se recomienda restringir el acceso a ZooKeeper los nodos para evitar que los usuarios los modifiquen ACLs. Para obtener más información, consulte [Controle el acceso a ZooKeeper los nodos de Apache en su clúster de Amazon MSK](zookeeper-security.md).
# Limitaciones al momento de utilizar los secretos SCRAM
Cuando utilice secretos SCRAM, tenga en cuenta las siguientes limitaciones:
+ Amazon MSK solo admite la autenticación SCRAM-SHA-512.
+ Un clúster de Amazon MSK puede tener hasta 1000 usuarios.
+ Debes usar un AWS KMS key con tu secreto. No puede usar un secreto que utilice la clave de cifrado predeterminada de Secrets Manager con Amazon MSK. Para obtener información sobre cómo crear una clave de KMS, consulte [Creating symmetric encryption KMS keys](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk).
+ No puede utilizar una clave de KMS asimétrica con Secrets Manager.
+ Puedes asociar hasta 10 secretos a un clúster a la vez mediante la [ BatchAssociateScramSecret](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn-scram-secrets.html#BatchAssociateScramSecret)operación.
+ El nombre de los secretos asociados a un clúster de Amazon MSK debe tener el prefijo **AmazonMSK\$1**.
+ Los secretos asociados a un clúster de Amazon MSK deben estar en la misma cuenta y AWS región de Amazon Web Services que el clúster.
# Apache Kafka ACLs
Apache Kafka tiene un autorizador conectable y viene con una implementación de autorizador. out-of-box Amazon MSK habilita este autorizador en el archivo `server.properties` de los agentes.
Apache Kafka ACLs tiene el formato «La P principal es la operación O [permitida/denegada] del host H en cualquier recurso R que coincida con el RP». ResourcePattern Si RP no coincide con un recurso R específico, R no tiene asociado y ACLs, por lo tanto, solo los superusuarios pueden acceder a R. Para cambiar este comportamiento de Apache Kafka, establezca la propiedad en `allow.everyone.if.no.acl.found` true. Amazon MSK lo establece como true de forma predeterminada. Esto significa que con los clústeres de Amazon MSK, si no se establece ACLs un recurso de forma explícita, todos los principales pueden acceder a este recurso. Si habilita ACLs un recurso, solo los principales autorizados pueden acceder a él. Si desea restringir el acceso a un tema y autorizar a un cliente mediante la autenticación mutua TLS, agréguelo ACLs mediante la CLI del autorizador Apache Kafka. Para obtener más información sobre cómo añadir, eliminar y enumerar ACLs, consulte la interfaz de línea de comandos de [autorización de Kafka](https://cwiki.apache.org/confluence/display/KAFKA/Kafka+Authorization+Command+Line+Interface).
Dado que Amazon MSK configura los agentes como superusuarios, estos pueden acceder a todos los temas. Esto ayuda a los agentes a replicar mensajes desde la partición principal, independientemente de que la propiedad `allow.everyone.if.no.acl.found` esté definida o no en la configuración del clúster.
**Adición o eliminación del acceso de lectura y escritura a un tema**
1. Añada a sus corredores a la tabla de ACL para que puedan leer todos los temas ACLs existentes. Para conceder a los agentes acceso de lectura a un tema, ejecute el siguiente comando en un equipo cliente que pueda comunicarse con el clúster de MSK.
Reemplácelo *Distinguished-Name* por el DNS de cualquiera de los agentes de arranque del clúster y, a continuación, sustituya la cadena situada antes del primer punto de este nombre distintivo por un asterisco ()`*`. Por ejemplo, si uno de los agentes de arranque del clúster tiene el DNS`b-6.mytestcluster.67281x.c4.kafka.us-east-1.amazonaws.com`, sustituya el siguiente *Distinguished-Name* comando por. `*.mytestcluster.67281x.c4.kafka.us-east-1.amazonaws.com` Para obtener información sobre cómo obtener los agentes de arranque, consulte [Obtención de agentes de arranque para un clúster de Amazon MSK](msk-get-bootstrap-brokers.md).
```
/bin/kafka-acls.sh --bootstrap-server BootstrapServerString --add --allow-principal "User:CN=Distinguished-Name" --operation Read --group=* --topic Topic-Name
```
1. Para conceder a una aplicación cliente acceso de lectura a un tema, ejecute el siguiente comando en la máquina cliente. Si utilizas la autenticación TLS mutua, usa la misma *Distinguished-Name* que usaste cuando creaste la clave privada.
```
/bin/kafka-acls.sh --bootstrap-server BootstrapServerString --add --allow-principal "User:CN=Distinguished-Name" --operation Read --group=* --topic Topic-Name
```
Para eliminar el acceso de lectura, puede ejecutar el mismo comando, sustituyendo `--add` por `--remove`.
1. Para conceder acceso de escritura a un tema, ejecute el siguiente comando en su máquina del cliente. Si utilizas la autenticación TLS mutua, usa la misma *Distinguished-Name* que usaste cuando creaste la clave privada.
```
/bin/kafka-acls.sh --bootstrap-server BootstrapServerString --add --allow-principal "User:CN=Distinguished-Name" --operation Write --topic Topic-Name
```
Para eliminar el acceso de escritura, puede ejecutar el mismo comando, sustituyendo `--add` por `--remove`.
# Modificación del grupo de seguridad de un clúster de Amazon MSK
En esta página, se explica cómo cambiar el grupo de seguridad de un clúster de MSK existente. Es posible que tenga que cambiar el grupo de seguridad de un clúster para proporcionar acceso a un determinado conjunto de usuarios o para limitar el acceso al clúster. Para obtener más información sobre los grupos de seguridad, consulte [Grupos de seguridad de la VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) en la Guía de usuario de Amazon VPC.
1. Utilice la [ListNodes](https://docs.amazonaws.cn/en_us/msk/1.0/apireference/clusters-clusterarn-nodes.html#ListNodes)API o el comando [list-nodes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kafka/list-nodes.html) del AWS CLI para obtener una lista de los corredores de su clúster. Los resultados de esta operación incluyen las interfaces IDs de red elásticas (ENIs) asociadas a los corredores.
1. Inicie sesión en la consola Amazon EC2 Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. En la lista desplegable situada cerca de la esquina superior derecha de la pantalla, seleccione la región en la que se implementa el clúster.
1. En el panel izquierdo, en **Red y seguridad**, seleccione **Interfaces de red**.
1. Seleccione la primera ENI que obtuvo en el primer paso. Seleccione el menú **Acciones** en la parte superior de la pantalla y, a continuación, seleccione **Cambiar grupos de seguridad**. Asigne el nuevo grupo de seguridad a esta ENI. Repita este paso para cada uno de los pasos ENIs que obtuvo en el primer paso.
**nota**
Los cambios que realice en el grupo de seguridad de un clúster mediante la consola de Amazon EC2 no se reflejan en la consola de MSK en **Configuración de redes**.
1. Configure las reglas del nuevo grupo de seguridad para garantizar que sus clientes tengan acceso a los agentes. Para obtener información acerca de cómo establecer reglas de grupo de seguridad, consulte [Adición, eliminación y actualización de reglas](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html?shortFooter=true#AddRemoveRules) en la Guía del usuario de Amazon VPC.
**importante**
Si cambia el grupo de seguridad asociado a los agentes de un clúster y, a continuación, agrega nuevos agentes a ese clúster, Amazon MSK asocia los nuevos agentes al grupo de seguridad original que estaba asociado al clúster cuando se creó el clúster. Sin embargo, para que un clúster funcione correctamente, todos sus agentes deben estar asociados al mismo grupo de seguridad. Por lo tanto, si añade nuevos corredores después de cambiar el grupo de seguridad, debe volver a seguir el procedimiento anterior y actualizar ENIs los nuevos corredores.
# Controle el acceso a ZooKeeper los nodos de Apache en su clúster de Amazon MSK
Por motivos de seguridad, puede limitar el acceso a los ZooKeeper nodos de Apache que forman parte de su clúster de Amazon MSK. Para limitar el acceso a los nodos, puede asignarles un grupo de seguridad independiente. A continuación, puede decidir quién obtiene acceso a ese grupo de seguridad.
**importante**
Esta sección no se aplica a los clústeres que se ejecutan en KRaft modo. Consulte [KRaft modo](metadata-management.md#kraft-intro).
**Topics**
+ [Para colocar ZooKeeper los nodos de Apache en un grupo de seguridad independiente](zookeeper-security-group.md)
+ [Uso de la seguridad TLS con Apache ZooKeeper](zookeeper-security-tls.md)
# Para colocar ZooKeeper los nodos de Apache en un grupo de seguridad independiente
Para limitar el acceso a ZooKeeper los nodos de Apache, puede asignarles un grupo de seguridad independiente. Puede establecer reglas del grupo de seguridad para elegir quién tiene acceso a este nuevo grupo de seguridad.
1. Obtenga la cadena de ZooKeeper conexión de Apache para su clúster. Para aprender a hacerlo, consulte [ZooKeeper modo](metadata-management.md#msk-get-connection-string). La cadena de conexión contiene los nombres DNS de sus ZooKeeper nodos de Apache.
1. Utilice una herramienta como `host` o `ping` para convertir los nombres de los DNS que obtuvo en el paso anterior a las direcciones IP. Guarde estas direcciones IP porque las necesitará más adelante en este procedimiento.
1. Inicie sesión en la consola Amazon EC2 Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. En el panel izquierdo, en **NETWORK & SECURITY (Red y seguridad)**, seleccione **Network Interfaces (Interfaces de red)**.
1. En el campo de búsqueda situado encima de la tabla de interfaces de red, escriba el nombre del clúster y, a continuación, escriba return. Esto limita el número de interfaces de red que aparecen en la tabla a las interfaces asociadas al clúster.
1. Marque la casilla de verificación al principio de la fila correspondiente a la primera interfaz de red de la lista.
1. En el panel de detalles de la parte inferior de la página, busque la ** IPv4 IP privada principal**. Si esta dirección IP coincide con una de las direcciones IP que obtuvo en el primer paso de este procedimiento, significa que esta interfaz de red está asignada a un ZooKeeper nodo de Apache que forma parte de su clúster. De lo contrario, anule la selección de la casilla de verificación situada junto a esta interfaz de red y seleccione la siguiente interfaz de red de la lista. El orden en el que selecciona las interfaces de red no importa. En los siguientes pasos, realizará las mismas operaciones en todas las interfaces de red que estén asignadas a ZooKeeper los nodos de Apache, una por una.
1. Cuando seleccione una interfaz de red que corresponda a un ZooKeeper nodo de Apache, elija el menú **Acciones** en la parte superior de la página y, a continuación, elija **Cambiar grupos de seguridad**. Asigne un nuevo grupo de seguridad a esta interfaz de red. Para obtener más información acerca de la creación de grupos de seguridad, consulte [Creación de un grupo de seguridad](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html?shortFooter=true#CreatingSecurityGroups) en la documentación de Amazon VPC.
1. Repita el paso anterior para asignar el mismo grupo de seguridad nuevo a todas las interfaces de red asociadas a ZooKeeper los nodos Apache del clúster.
1. Ahora puede elegir quién tiene acceso a este nuevo grupo de seguridad. Para obtener información acerca de cómo establecer reglas de grupo de seguridad, consulte [Adición, eliminación y actualización de reglas](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html?shortFooter=true#AddRemoveRules) en la documentación de Amazon VPC.
# Uso de la seguridad TLS con Apache ZooKeeper
Puede utilizar la seguridad TLS para el cifrado en tránsito entre sus clientes y sus nodos de Apache ZooKeeper . Para implementar la seguridad TLS en sus ZooKeeper nodos de Apache, haga lo siguiente:
+ Los clústeres deben usar la versión 2.5.1 o posterior de Apache Kafka para usar la seguridad TLS con Apache. ZooKeeper
+ Active la seguridad TLS al crear o configurar el clúster. Los clústeres creados con la versión 2.5.1 o posterior de Apache Kafka con TLS activado utilizan automáticamente la seguridad TLS con los puntos de conexión de Apache. ZooKeeper Para obtener información sobre la configuración de la seguridad TLS, consulte [Introducción al cifrado de Amazon MSK](msk-working-with-encryption.md).
+ Recupere los puntos finales TLS de Apache mediante la operación. ZooKeeper [DescribeCluster ](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn.html#DescribeCluster)
+ Cree un archivo ZooKeeper de configuración de Apache para usarlo con las [https://kafka.apache.org/documentation/#security_authz_cli](https://kafka.apache.org/documentation/#security_authz_cli)herramientas `kafka-configs.sh` y o con el ZooKeeper shell. Con cada herramienta, se utiliza el `--zk-tls-config-file` parámetro para especificar la ZooKeeper configuración de Apache.
El siguiente ejemplo muestra un archivo de ZooKeeper configuración típico de Apache:
```
zookeeper.ssl.client.enable=true
zookeeper.clientCnxnSocket=org.apache.zookeeper.ClientCnxnSocketNetty
zookeeper.ssl.keystore.location=kafka.jks
zookeeper.ssl.keystore.password=test1234
zookeeper.ssl.truststore.location=truststore.jks
zookeeper.ssl.truststore.password=test1234
```
+ Para otros comandos (como`kafka-topics`), debe usar la variable de `KAFKA_OPTS` entorno para configurar ZooKeeper los parámetros de Apache. El siguiente ejemplo muestra cómo configurar la variable de `KAFKA_OPTS` entorno para pasar ZooKeeper los parámetros de Apache a otros comandos:
```
export KAFKA_OPTS="
-Dzookeeper.clientCnxnSocket=org.apache.zookeeper.ClientCnxnSocketNetty
-Dzookeeper.client.secure=true
-Dzookeeper.ssl.trustStore.location=/home/ec2-user/kafka.client.truststore.jks
-Dzookeeper.ssl.trustStore.password=changeit"
```
Después de configurar la variable de entorno `KAFKA_OPTS`, puede utilizar los comandos de la CLI con normalidad. En el siguiente ejemplo, se crea un tema de Apache Kafka con la ZooKeeper configuración de Apache de la variable de `KAFKA_OPTS` entorno:
```
/bin/kafka-topics.sh --create --zookeeper ZooKeeperTLSConnectString --replication-factor 3 --partitions 1 --topic AWSKafkaTutorialTopic
```
**nota**
Los nombres de los parámetros que utiliza en el archivo de ZooKeeper configuración de Apache y los que utiliza en la variable de `KAFKA_OPTS` entorno no son coherentes. Preste atención a los nombres que utiliza con los parámetros del archivo de configuración y la variable de entorno `KAFKA_OPTS`.
Para obtener más información sobre cómo acceder a ZooKeeper los nodos de Apache con TLS, consulte el artículo [KIP-515: Habilitar el cliente ZK para utilizar la nueva](https://cwiki.apache.org/confluence/display/KAFKA/KIP-515%3A+Enable+ZK+client+to+use+the+new+TLS+supported+authentication) autenticación compatible con TLS.
# Validación de la conformidad de Amazon Managed Streaming para Apache Kafka
Los auditores externos evalúan la seguridad y la conformidad de Amazon Managed Streaming para Apache Kafka en distintos programas de conformidad de AWS . Estos incluyen PCI y HIPAA BAA.
Para obtener una lista de AWS los servicios incluidos en el ámbito de los programas de conformidad específicos, consulte [Amazon Services in Scope by Compliance Program](https://aws.amazon.com/compliance/services-in-scope/) . Para obtener información general, consulte Programas de [AWS cumplimiento > Programas AWS](https://aws.amazon.com/compliance/programs/) .
Puede descargar informes de auditoría de terceros utilizando AWS Artifact. Para obtener más información, consulte [Descarga de informes en AWS Artifact](https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html) .
Su responsabilidad de conformidad al utilizar Amazon MSK viene determinada por la confidencialidad de sus datos, los objetivos de conformidad de su empresa y las leyes y reglamentos aplicables. AWS proporciona los siguientes recursos para ayudar con el cumplimiento:
+ [Security and Compliance Quick Start Guides](https://aws.amazon.com/quickstart/?awsf.quickstart-homepage-filter=categories%23security-identity-compliance) (Guías de inicio rápido de seguridad y conformidad) (Guías de inicio rápido de seguridad y conformidad): Estas guías de implementación analizan las consideraciones en materia de arquitectura y proporcionan los pasos para implementar los entornos de referencia centrados en la seguridad y la conformidad en AWS.
+ Documento técnico sobre [cómo diseñar una arquitectura basada en la seguridad y el cumplimiento de la HIPAA: en este documento técnico](https://docs.aws.amazon.com/whitepapers/latest/architecting-hipaa-security-and-compliance-on-aws/architecting-hipaa-security-and-compliance-on-aws.html) se describe cómo pueden utilizar las empresas para crear aplicaciones que cumplan con la HIPAA. AWS
+ [AWS Recursos de cumplimiento Recursos](https://aws.amazon.com/compliance/resources/) de de trabajo y guías puede aplicarse a su sector y ubicación.
+ [Evaluación de los recursos con las reglas](https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config.html) de la *guía para AWS Config desarrolladores*: el AWS Config servicio evalúa en qué medida las configuraciones de los recursos cumplen con las prácticas internas, las directrices del sector y las normas.
+ [AWS Security Hub CSPM](https://docs.aws.amazon.com/securityhub/latest/userguide/what-is-securityhub.html)— Este AWS servicio proporciona una visión integral del estado de su seguridad AWS que le ayuda a comprobar su conformidad con los estándares y las mejores prácticas del sector de la seguridad.
# Resiliencia en Amazon Managed Streaming para Apache Kafka
La infraestructura AWS global se basa en AWS regiones y zonas de disponibilidad. AWS Las regiones proporcionan varias zonas de disponibilidad aisladas y separadas físicamente, que están conectadas mediante redes de baja latencia, alto rendimiento y alta redundancia. Con las zonas de disponibilidad, puede diseñar y utilizar aplicaciones y bases de datos que realizan una conmutación por error automática entre las zonas sin interrupciones. Las zonas de disponibilidad tienen una mayor disponibilidad, tolerancia a errores y escalabilidad que las infraestructuras tradicionales de uno o varios centros de datos.
[Para obtener más información sobre AWS las regiones y las zonas de disponibilidad, consulte Infraestructura global.AWS](https://aws.amazon.com/about-aws/global-infrastructure/)
# Seguridad de la infraestructura en Amazon Managed Streaming para Apache Kafka
Como servicio gestionado, Amazon Managed Streaming for Apache Kafka Kafka está protegido por los procedimientos de seguridad de red AWS global que se describen en el documento técnico [Amazon Web Services: Overview of Security Processes](https://d0.awsstatic.com/whitepapers/Security/AWS_Security_Whitepaper.pdf).
Utiliza las llamadas a la API AWS publicadas para acceder a Amazon MSK a través de la red. Los clientes deben ser compatibles con la seguridad de la capa de transporte (TLS) 1.0 o una versión posterior. Recomendamos TLS 1.2 o una versión posterior. Los clientes también deben ser compatibles con conjuntos de cifrado con confidencialidad directa total (PFS) tales como Ephemeral Diffie-Hellman (DHE) o Elliptic Curve Ephemeral Diffie-Hellman (ECDHE). La mayoría de los sistemas modernos como Java 7 y posteriores son compatibles con estos modos.
Además, las solicitudes deben estar firmadas mediante un ID de clave de acceso y una clave de acceso secreta que esté asociada a una entidad principal de IAM. También puedes utilizar [AWS Security Token Service](https://docs.aws.amazon.com/STS/latest/APIReference/Welcome.html) (AWS STS) para generar credenciales de seguridad temporales para firmar solicitudes.