Fonctionnement du contrôle d'accès IAM pour Amazon MSK Sémantique des actions et des ressources Cas d’utilisation courants

Contrôle d'accès IAM

Le contrôle d'accès IAM pour Amazon MSK vous permet de gérer à la fois l'authentification et l'autorisation pour votre cluster MSK. Cela élimine la nécessité d'utiliser un mécanisme unique pour l'authentification et un autre pour l'autorisation. Par exemple, lorsqu'un client tente d'écrire sur votre cluster, Amazon MSK utilise IAM pour vérifier si ce client est une identité authentifiée et s'il est autorisé à produire sur votre cluster. Le contrôle d'accès IAM fonctionne pour les clients Java et non-Java, y compris les clients Kafka écrits en Python JavaScript, Go et .NET.

Amazon MSK journalise les événements d'accès afin que vous puissiez les contrôler. Pour plus d’informations, consultez Journalisation des appels d'API AWS CloudTrail avec.

Pour rendre le contrôle d'accès IAM possible, Amazon MSK apporte des modifications mineures au code source d'Apache Kafka. Ces modifications n'entraîneront pas de différence notable dans votre expérience avec Apache Kafka.

Important

Le contrôle d'accès IAM ne s'applique pas aux ZooKeeper nœuds Apache. Pour plus d'informations sur la manière de contrôler l'accès à ces nœuds, consultez Contrôle de l'accès à Apache ZooKeeper.

Important

Le paramètre Apache Kafka allow.everyone.if.no.acl.found n'a aucun effet si votre cluster utilise le contrôle d'accès IAM.

Important

Vous pouvez invoquer les API ACL Apache Kafka pour un cluster MSK qui utilise le contrôle d'accès IAM. Cependant, les ACL Apache Kafka n'ont aucun effet sur l'autorisation pour les rôles IAM. Vous devez utiliser des politiques IAM pour le contrôle d'accès des rôles IAM.

Fonctionnement du contrôle d'accès IAM pour Amazon MSK

Pour utiliser le contrôle d'accès IAM pour Amazon MSK, effectuez les étapes suivantes, décrites en détail dans le reste de cette section.

Créer un cluster qui utilise le contrôle d'accès IAM
Configurer les clients pour le contrôle d'accès IAM
Créer des politiques d'autorisation
Obtenez les agents d'amorçage pour le contrôle d'accès IAM

Créer un cluster qui utilise le contrôle d'accès IAM

Cette section explique comment vous pouvez utiliser l' AWS Management Console API ou le AWS CLI pour créer un cluster qui utilise le contrôle d'accès IAM. Pour plus d'informations sur l'activation du contrôle d'accès IAM pour un cluster existant, consultez Mise à jour des paramètres de sécurité d'un cluster.

Utilisez le AWS Management Console pour créer un cluster qui utilise le contrôle d'accès IAM

Ouvrez la console Amazon MSK à l'adresse https://console.aws.amazon.com/msk/.
Choisissez Créer un cluster.
Choisissez Créer un cluster avec des paramètres personnalisés.
Dans la section Authentification, choisissez Contrôle d'accès IAM.
Suivez le reste du flux de travail pour créer un cluster.

Utilisez l'API ou le AWS CLI pour créer un cluster qui utilise le contrôle d'accès IAM

Pour créer un cluster avec le contrôle d'accès IAM activé, utilisez l'CreateClusterAPI ou la commande create-cluster CLI et transmettez le JSON suivant pour ClientAuthentication le paramètre :. "ClientAuthentication": { "Sasl": { "Iam": { "Enabled": true } }

Configurer les clients pour le contrôle d'accès IAM

Pour permettre aux clients de communiquer avec un cluster MSK qui utilise le contrôle d’accès IAM, vous pouvez utiliser l’un des mécanismes suivants :

Configuration du client non Java à l’aide du mécanisme SASL_OAUTHBEARER
Configuration du client Java à l’aide du mécanisme SASL_OAUTHBEARER ou AWS_MSK_IAM

Utilisation du mécanisme SASL_OAUTHBEARER pour configurer IAM

Modifiez votre fichier de configuration client.properties en utilisant la syntaxe surlignée dans l’exemple de client Python Kafka ci-dessous à titre de guide. Les modifications de configuration sont similaires dans les autres langages.


#!/usr/bin/python3from kafka import KafkaProducer
from kafka.errors import KafkaError
import socket
import time
from aws_msk_iam_sasl_signer import MSKAuthTokenProvider

class MSKTokenProvider():
    def token(self):
        token, _ = MSKAuthTokenProvider.generate_auth_token('<my aws region>')
        return token

tp = MSKTokenProvider()

producer = KafkaProducer(
    bootstrap_servers='<my bootstrap string>',
    security_protocol='SASL_SSL',
    sasl_mechanism='OAUTHBEARER',
    sasl_oauth_token_provider=tp,
    client_id=socket.gethostname(),
)

topic = "<my-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()

Téléchargez la bibliothèque d’assistance correspondant à la langue de configuration que vous avez choisie et suivez les instructions de la section Démarrage de la page d’accueil de cette bibliothèque de langages.
- JavaScript: https://github.com/aws/aws-msk-iam-sasl-signer-js#getting-started
- Python : https://github.com/aws/aws-msk-iam-sasl-signer-python#get-started
- Go : https://github.com/aws/aws-msk-iam-sasl-signer-go#getting-started
- .NET : https://github.com/aws/aws-msk-iam-sasl-signer-net#getting-started
- JAVA : la prise en charge de SASL_OAUTHBEARER pour Java est disponible via le fichier jar aws-msk-iam-auth

Utilisation du mécanisme personnalisé AWS_MSK_IAM de MSK pour configurer IAM

Ajoutez ce qui suit dans le fichier client.properties. Remplacez <PATH_TO_TRUST_STORE_FILE> par le chemin d'accès qualifié complet vers le fichier de magasin d'approbations sur le client.

Note
Si vous ne souhaitez pas utiliser un certificat spécifique, vous pouvez supprimer ssl.truststore.location=<PATH_TO_TRUST_STORE_FILE> de votre fichier client.properties. Si vous ne spécifiez aucune valeur pour ssl.truststore.location, le processus Java utilise le certificat par défaut.
```
ssl.truststore.location=<PATH_TO_TRUST_STORE_FILE>
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
```
Pour utiliser un profil nommé que vous avez créé pour les AWS informations d'identification, awsProfileName="your profile name"; incluez-le dans votre fichier de configuration client. Pour plus d'informations sur les profils nommés, consultez la section Profils nommés dans la AWS CLI documentation.
Téléchargez le dernier fichier JAR stable aws-msk-iam-auth et placez-le dans le chemin de classe. Si vous utilisez Maven, ajoutez la dépendance suivante, en ajustant le numéro de version selon les besoins :
```
<dependency>
    <groupId>software.amazon.msk</groupId>
    <artifactId>aws-msk-iam-auth</artifactId>
    <version>1.0.0</version>
</dependency>
```

Le plug-in client Amazon MSK est open source sous la licence Apache 2.0.

Créer des politiques d'autorisation

Attachez une politique d'autorisation au rôle IAM qui correspond au client. Dans une politique d'autorisation, vous spécifiez les actions à autoriser ou à refuser pour le rôle. Si votre client utilise une instance Amazon EC2, associez la politique d'autorisation au rôle IAM pour cette instance Amazon EC2. Vous pouvez également configurer votre client pour qu'il utilise un profil nommé, puis associer la politique d'autorisation au rôle de ce profil nommé. Configurer les clients pour le contrôle d'accès IAM décrit comment configurer un client pour utiliser un profil nommé.

Pour plus d'informations sur la création d'une politique IAM, consultez Création de politiques IAM.

Voici un exemple de politique d'autorisation pour un cluster nommé MyTestCluster. Pour comprendre la sémantique des éléments Action et Resource, consultez Sémantique des actions et des ressources.

Important

Les modifications que vous apportez à une politique IAM sont immédiatement reflétées dans les API IAM et l' AWS CLI . Cependant, la modification de la politique peut prendre un certain temps avant d'être effective. Dans la plupart des cas, les modifications de politique prennent effet en moins d'une minute. Les conditions du réseau peuvent parfois augmenter le délai.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "kafka-cluster:Connect",
                "kafka-cluster:AlterCluster",
                "kafka-cluster:DescribeCluster"
            ],
            "Resource": [
                "arn:aws:kafka:us-east-1:0123456789012: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:0123456789012:topic/MyTestCluster/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "kafka-cluster:AlterGroup",
                "kafka-cluster:DescribeGroup"
            ],
            "Resource": [
                "arn:aws:kafka:us-east-1:0123456789012:group/MyTestCluster/*"
            ]
        }
    ]
}

Pour savoir comment créer une politique avec des éléments d'action correspondant aux cas d'utilisation courants d'Apache Kafka, tels que la production et la consommation de données, consultez Cas d’utilisation courants.

Pour les versions 2.8.0 et supérieures de Kafka, l'autorisation WriteDataIdempotently est obsolète (KIP-679). Par défaut, enable.idempotence = true est défini. Par conséquent, pour les versions 2.8.0 et supérieures de Kafka, IAM n'offre pas les mêmes fonctionnalités que les listes de contrôle d'accès (ACL) Kafka. Il n'est pas possible de définir WriteDataIdempotently à une rubrique en fournissant uniquement un accès WriteData à cette rubrique. Cela n'affecte pas le cas lorsque WriteData est fourni à TOUTES les rubriques. Dans ce cas, WriteDataIdempotently est autorisé. Cela est dû à des différences dans l'implémentation de la logique IAM par rapport à la manière dont les listes de contrôle d'accès (ACL) Kafka sont implémentées.

Pour contourner ce problème, nous vous recommandons d'utiliser une politique similaire à l'exemple ci-dessous :


{
    "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:0123456789012: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:0123456789012:topic/MyTestCluster/abcd1234-0123-abcd-5678-1234abcd-1/TestTopic"
            ]
        }
    ]
}

Dans ce cas, WriteData autorise les écritures vers la TestTopic, pendant que WriteDataIdempotently autorise les écritures idempotentes sur le cluster. Il est important de noter que WriteDataIdempotently est une autorisation au niveau du cluster. Il ne peut pas être utilisé au niveau de la rubrique. Si WriteDataIdempotently est limité au niveau de la rubrique, cette politique ne fonctionnera pas.

Obtenez les agents d'amorçage pour le contrôle d'accès IAM

veuillez consulter Obtention des agents d'amorçage pour un cluster Amazon MSK.

Sémantique des actions et des ressources

Cette section explique la sémantique des éléments d'action et de ressource que vous pouvez utiliser dans une politique d'autorisation IAM. Pour un exemple de politique, consultez Créer des politiques d'autorisation.

Actions

Le tableau suivant répertorie les actions que vous pouvez inclure dans une politique d'autorisation lorsque vous utilisez le contrôle d'accès IAM pour Amazon MSK. Lorsque vous incluez dans votre politique d'autorisation une action de la colonne Action du tableau, vous devez également inclure les actions correspondantes de la colonne Actions requises.

Action	Description	Actions requises	Ressources requises	Applicable aux clusters sans serveur
`kafka-cluster:Connect`	Octroie l'autorisation de se connecter et de s'authentifier à un cluster.	Aucun	cluster	Oui
`kafka-cluster:DescribeCluster`	Octroie l'autorisation de décrire divers aspects du cluster, équivalent à l'ACL DESCRIBE CLUSTER d'Apache Kafka.	`kafka-cluster:Connect`	cluster	Oui
`kafka-cluster:AlterCluster`	Octroi l'autorisation de modifier divers aspects du cluster, équivalent à l'ACL ALTER CLUSTER d'Apache Kafka.	`kafka-cluster:Connect` `kafka-cluster:DescribeCluster`	cluster	Non
`kafka-cluster:DescribeClusterDynamicConfiguration`	Octroie l'autorisation de décrire la configuration dynamique d'un cluster, équivalent à l'ACL DESCRIBE_CONFIGS CLUSTER d'Apache Kafka.	`kafka-cluster:Connect`	cluster	Non
`kafka-cluster:AlterClusterDynamicConfiguration`	Octroie l'autorisation de modifier la configuration dynamique d'un cluster, équivalente à l'ACL ALTER_CONFIGS CLUSTER d'Apache Kafka.	`kafka-cluster:Connect` `kafka-cluster:DescribeClusterDynamicConfiguration`	cluster	Non
`kafka-cluster:WriteDataIdempotently`	Octroie l'autorisation d'écrire des données de manière idempotente dans un cluster, équivalent à l'ACL IDEMPOTENT_WRITE CLUSTER d'Apache Kafka.	`kafka-cluster:Connect` `kafka-cluster:WriteData`	cluster	Oui
`kafka-cluster:CreateTopic`	Octroie l'autorisation de créer des rubriques dans un cluster, équivalent à l'ACL CREATE CLUSTER/TOPIC d'Apache Kafka.	`kafka-cluster:Connect`	topic	Oui
`kafka-cluster:DescribeTopic`	Octroie l'autorisation de décrire des rubriques dans un cluster, équivalent à l'ACL DESCRIBE TOPIC d'Apache Kafka.	`kafka-cluster:Connect`	topic	Oui
`kafka-cluster:AlterTopic`	Octroie l'autorisation de modifier des rubriques dans un cluster, équivalent à l'ACL ALTER TOPIC d'Apache Kafka.	`kafka-cluster:Connect` `kafka-cluster:DescribeTopic`	topic	Oui
`kafka-cluster:DeleteTopic`	Octroie l'autorisation de supprimer des rubriques dans un cluster, équivalent à l'ACL DELETE TOPIC d'Apache Kafka.	`kafka-cluster:Connect` `kafka-cluster:DescribeTopic`	topic	Oui
`kafka-cluster:DescribeTopicDynamicConfiguration`	Octroie l'autorisation de décrire la configuration dynamique des rubriques dans un cluster, équivalent à l'ACL DESCRIBE_CONFIGS TOPIC d'Apache Kafka.	`kafka-cluster:Connect`	topic	Oui
`kafka-cluster:AlterTopicDynamicConfiguration`	Octroie l'autorisation de modifier la configuration dynamique des rubriques dans un cluster, équivalent à l'ACL ALTER_CONFIGS TOPIC d'Apache Kafka.	`kafka-cluster:Connect` `kafka-cluster:DescribeTopicDynamicConfiguration`	topic	Oui
`kafka-cluster:ReadData`	Octroie l'autorisation de lire des données provenant de rubriques dans un cluster, équivalent à l'ACL READ TOPIC d'Apache Kafka.	`kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:AlterGroup`	topic	Oui
`kafka-cluster:WriteData`	Autorise l'écriture des données dans les rubriques d'un cluster, équivalent à l'ACL WRITE TOPIC d'Apache Kafka.	`kafka-cluster:Connect` `kafka-cluster:DescribeTopic`	topic	Oui
`kafka-cluster:DescribeGroup`	Octroie l'autorisation de décrire des groupes dans un cluster, équivalent à l'ACL DESCRIBE GROUP d'Apache Kafka.	`kafka-cluster:Connect`	groupe	Oui
`kafka-cluster:AlterGroup`	Octroie l'autorisation de rejoindre des groupes dans un cluster, équivalent à l'ACL READ GROUP d'Apache Kafka.	`kafka-cluster:Connect` `kafka-cluster:DescribeGroup`	groupe	Oui
`kafka-cluster:DeleteGroup`	Octroie l'autorisation de supprimer des groupes d'un cluster, équivalent à l'ACL DELETE GROUP d'Apache Kafka.	`kafka-cluster:Connect` `kafka-cluster:DescribeGroup`	groupe	Oui
`kafka-cluster:DescribeTransactionalId`	Octroie l'autorisation de décrire des ID transactionnels dans un cluster, équivalent à l'ACL DESCRIBE TRANSACTIONAL_ID d'Apache Kafka.	`kafka-cluster:Connect`	transactional-id	Oui
`kafka-cluster:AlterTransactionalId`	Octroie l'autorisation de modifier des ID transactionnels dans un cluster, équivalent à l'ACL WRITE TRANSACTIONAL_ID d'Apache Kafka.	`kafka-cluster:Connect` `kafka-cluster:DescribeTransactionalId` `kafka-cluster:WriteData`	transactional-id	Oui

Vous pouvez utiliser le caractère générique astérisque (*) autant de fois que vous le souhaitez dans une action après deux points. Voici quelques exemples.

kafka-cluster:*Topic représente kafka-cluster:CreateTopic, kafka-cluster:DescribeTopic, kafka-cluster:AlterTopic et kafka-cluster:DeleteTopic. Cela n'inclut pas kafka-cluster:DescribeTopicDynamicConfiguration ou kafka-cluster:AlterTopicDynamicConfiguration.
kafka-cluster:* représente toutes les autorisations.

Ressources

Le tableau suivant montre les quatre types de ressources que vous pouvez utiliser dans une politique d'autorisation lorsque vous utilisez le contrôle d'accès IAM pour Amazon MSK. Vous pouvez obtenir le nom de ressource Amazon (ARN) du cluster à partir du AWS Management Console ou en utilisant l'DescribeClusterAPI ou la commande describe-cluster AWS CLI . Vous pouvez ensuite utiliser l'ARN du cluster pour construire des ARN de rubrique, de groupe et d'ID transactionnel. Pour spécifier une ressource dans une politique d'autorisation, utilisez l'ARN de cette ressource.

Ressource	Format ARN
Cluster	arn:aws:kafka:`region`:`account-id`:cluster/`cluster-name`/`cluster-uuid`
Rubrique	arn:aws:kafka:`region`:`account-id`:topic/`cluster-name`/`cluster-uuid`/`topic-name`
Groupe	arn:aws:kafka:`region`:`account-id`:group/`cluster-name`/`cluster-uuid`/`group-name`
ID transactionnel	arn:aws:kafka:`region`:`account-id`:transactional-id/`cluster-name`/`cluster-uuid`/`transactional-id`

Vous pouvez utiliser le caractère générique astérisque (*) autant de fois que vous le souhaitez dans la partie de l'ARN située après :cluster/, :topic/, :group/ et :transactional-id/. Les exemples suivants illustrent la manière dont vous pouvez utiliser le caractère générique astérisque (*) pour faire référence à plusieurs ressources :

arn:aws:kafka:us-east-1:0123456789012:topic/MyTestCluster/*: tous les sujets de n'importe quel cluster nommé MyTestCluster, quel que soit l'UUID du cluster.
arn:aws:kafka:us-east-1:0123456789012:topic/MyTestCluster/abcd1234-0123-abcd-5678-1234abcd-1/*_test: toutes les rubriques dont le nom se termine par « _test » dans le cluster dont le nom est MyTestCluster et dont l'UUID est abcd1234-0123-abcd-5678-1234abcd-1.
arn:aws:kafka:us-east-1:0123456789012:transactional-id/MyTestCluster/*/5555abcd-1111-abcd-1234-abcd1234-1: toutes les transactions dont l'ID transactionnel est 5555abcd-1111-abcd-1234-abcd1234-1, dans toutes les incarnations d'un cluster nommé dans votre compte. MyTestCluster Cela signifie que si vous créez un cluster nommé MyTestCluster, que vous le supprimez, puis que vous créez un autre cluster portant le même nom, vous pouvez utiliser cet ARN de ressource pour représenter le même identifiant de transaction sur les deux clusters. Cependant, le cluster supprimé n'est pas accessible.

Cas d’utilisation courants

La première colonne du tableau suivant présente certains cas d'utilisation courants. Pour autoriser un client à exécuter un cas d'utilisation donné, incluez les actions requises pour ce cas d'utilisation dans la politique d'autorisation du client et définissez Effect sur Allow.

Pour plus d'informations sur toutes les actions faisant partie du contrôle d'accès IAM pour Amazon MSK, consultez Sémantique des actions et des ressources.

Note

Les actions sont refusées par défaut. Vous devez autoriser explicitement chaque action que vous souhaitez autoriser le client à effectuer.

Cas d’utilisation	Actions requises
Administrateur	`kafka-cluster:*`
Créer une rubrique	`kafka-cluster:Connect` `kafka-cluster:CreateTopic`
Produire des données	`kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:WriteData`
Consommer des données	`kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:DescribeGroup` `kafka-cluster:AlterGroup` `kafka-cluster:ReadData`
Produire des données de manière idempotente	`kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:WriteData` `kafka-cluster:WriteDataIdempotently`
Produire des données de manière transactionnelle	`kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:WriteData` `kafka-cluster:DescribeTransactionalId` `kafka-cluster:AlterTransactionalId`
Décrire la configuration d'un cluster	`kafka-cluster:Connect` `kafka-cluster:DescribeClusterDynamicConfiguration`
Mettre à jour la configuration d'un cluster	`kafka-cluster:Connect` `kafka-cluster:DescribeClusterDynamicConfiguration` `kafka-cluster:AlterClusterDynamicConfiguration`
Décrire la configuration d'une rubrique	`kafka-cluster:Connect` `kafka-cluster:DescribeTopicDynamicConfiguration`
Mettre à jour la configuration d'une rubrique	`kafka-cluster:Connect` `kafka-cluster:DescribeTopicDynamicConfiguration` `kafka-cluster:AlterTopicDynamicConfiguration`
Modifier une rubrique	`kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:AlterTopic`

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Authentification et autorisation pour les API Apache Kafka

Authentification TLS mutuelle