Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Configuration AWS Config avec le AWS CLI
<a name="gs-cli"></a>

 AWS CLI Il s'agit d'un outil unifié pour gérer vos AWS services. Avec un seul outil à télécharger et à configurer, vous pouvez contrôler plusieurs AWS services depuis la ligne de commande et utiliser des scripts pour les automatiser. Pour plus d'informations sur les AWS CLI outils AWS CLI et pour obtenir des instructions sur leur installation, reportez-vous à ce qui suit dans le *guide de AWS Command Line Interface l'utilisateur*.
+ [AWS Command Line Interface Guide de l'utilisateur](https://docs.aws.amazon.com/cli/latest/userguide/)
+ [Préparation de l’installation de l’ AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) 

Si nécessaire, entrez `aws configure` pour configurer le AWS CLI afin d'utiliser une AWS région AWS Config disponible.

## Configuration
<a name="gs-cli-setting-up.title"></a>

Consultez les rubriques suivantes pour configurer AWS Config le AWS CLI.

**Topics**
+ [

## Configuration
](#gs-cli-setting-up.title)
+ [Conditions préalables](gs-cli-prereq.md)
+ [Démarrage AWS Config](gs-cli-subscribe.md)
+ [Vérification de l'installation](gs-cli-verify-subscribe.md)

# Conditions préalables à la configuration AWS Config avec le AWS CLI
<a name="gs-cli-prereq"></a>

Avant de procéder à la configuration AWS avec le AWS CLI, vous devez créer un compartiment Amazon S3, une rubrique Amazon SNS et un rôle IAM avec des politiques associées comme conditions préalables. Vous pouvez ensuite utiliser le AWS CLI pour spécifier le compartiment, le sujet et le rôle pour AWS Config. Suivez cette procédure pour configurer les conditions préalables pour AWS Config.

**Topics**
+ [

## Étape 1 : Création d'un compartiment Amazon S3
](#gs-cli-create-s3bucket)
+ [

## Étape 2 : Création d'une rubrique Amazon SNS
](#gs-cli-create-snstopic)
+ [

## Étape 3 : Création d'un rôle IAM
](#gs-cli-create-iamrole)

## Étape 1 : Création d'un compartiment Amazon S3
<a name="gs-cli-create-s3bucket"></a>

Si vous avez déjà un compartiment Amazon S3 dans votre compte et si vous voulez l'utiliser, ignorez cette étape et passez à l'étape [Étape 2 : Création d'une rubrique Amazon SNS](#gs-cli-create-snstopic).

### Utilisation de la console S3
<a name="create-bucket"></a>

**Pour créer un compartiment**

1. Ouvrez la console Amazon S3 à l'adresse [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Choisissez **Créer un compartiment**.

1. Dans **Nom du compartiment**, saisissez un nom compatible DNS pour votre compartiment.

   Le nom du compartiment doit présenter les caractéristiques suivantes :
   + Il doit être unique sur l'ensemble d'Amazon S3.
   + Il doit comporter entre 3 et 63 caractères.
   + Ne contient pas de majuscules.
   + Il doit commencer par une minuscule ou un chiffre.

   Une fois le compartiment créé, vous ne pouvez pas changer son nom. Vérifiez que le nom de compartiment que vous choisissez n'existe pas déjà parmi tous les noms de compartiment existant dans Amazon S3. Pour plus d'informations sur les règles et les conventions de dénomination de compartiment, consultez [Limites et restrictions applicables aux compartiments](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) dans le *Guide de l'utilisateur Amazon Simple Storage Service*.
**Important**  
Évitez d'inclure des informations sensibles dans le nom du compartiment. Le nom du compartiment est visible en pointant vers les objets URLs qu'il contient.

1. Dans **Région**, choisissez la AWS région dans laquelle vous souhaitez que le bucket réside. 

   Choisissez une Région proche de vous afin de limiter la latence et les coûts, et répondre aux exigences légales. Les objets stockés dans une Région ne la quittent jamais, sauf si vous les transférez explicitement vers une autre Région. Pour obtenir la liste des AWS régions Amazon S3, consultez la section [Points AWS de terminaison de service](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) dans le *Référence générale d'Amazon Web Services*.

1. Dans **Paramètres de compartiment pour Bloquer l'accès public**, choisissez les paramètres de blocage de l'accès public que vous souhaitez appliquer au compartiment. 

   Nous vous recommandons de laisser tous les paramètres activés, sauf si vous savez que vous devez en désactiver un ou plusieurs d'entre eux pour votre cas d'utilisation, par exemple pour héberger un site web public. Les paramètres de blocage de l’accès public que vous activez pour le compartiment seront également activés pour tous les points d'accès que vous créez dans le compartiment. Pour plus d'informations sur le blocage de l'accès public, consultez [Utilisation de la fonctionnalité de blocage de l'accès public Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/access-control-block-public-access.html) dans le *Guide de l'utilisateur Amazon Simple Storage Service*.

1. (Facultatif) Si vous souhaitez activer la fonctionnalité de verrouillage d'objet S3 :

   1. Choisissez **Paramètres avancés** et lisez le message qui s'affiche.
**Important**  
Vous ne pouvez activer la fonctionnalité de verrouillage d'objet S3 pour un compartiment que lors de sa création. Si vous activez le verrouillage d'objet pour le compartiment, vous ne pouvez pas le désactiver ultérieurement. L'activation du verrouillage d'objet active également la gestion des versions pour le compartiment. Après avoir activé le verrouillage d'objet pour le compartiment, vous devez configurer les paramètres de la fonctionnalité de verrouillage d'objet avant que les objets du compartiment ne soient protégés. Pour plus d'informations sur la configuration de la protection des objets, consultez [Configuration du verrouillage d'objet S3 à l'aide de la console Amazon S3](https://docs.aws.amazon.com//AmazonS3/latest/dev/object-lock-console.html).

   1. Si vous souhaitez activer la fonctionnalité de verrouillage d'objet, entrez *activer* dans la zone de texte et choisissez **Confirmer**.

   Pour plus d'informations sur la fonctionnalité de verrouillage d'objet S3, consultez [Verrouillage d'objets à l'aide de la fonctionnalité de verrouillage d'objet Amazon S3](https://docs.aws.amazon.com//AmazonS3/latest/dev/object-lock.html) dans le *Guide de l'utilisateur Amazon Simple Storage Service*.

1. Choisissez **Créer un compartiment**.

### En utilisant le AWS SDKs
<a name="create-bucket-intro"></a>

Lorsque vous utilisez le AWS SDKs pour créer un bucket, vous devez créer un client, puis utiliser le client pour envoyer une demande de création d'un bucket. En tant que bonne pratique, vous devez créer votre client et votre compartiment dans la même Région AWS. Si vous ne spécifiez pas de Région lorsque vous créez un client ou un compartiment, Amazon S3 utilise USA Est (Virginie du Nord), la Région par défaut. 

Pour créer un client permettant d'accéder à un point de terminaison à double pile, vous devez spécifier un Région AWS. Pour plus d'informations, consultez [Points de terminaison Amazon S3 Dual-Stack](https://docs.aws.amazon.com//AmazonS3/latest/dev/dual-stack-endpoints.html#dual-stack-endpoints-description). Pour obtenir la liste des régions disponibles Régions AWS, consultez la section [Régions et points de terminaison](https://docs.aws.amazon.com/general/latest/gr/s3.html) dans le *Références générales AWS*. 

Lorsque vous créez un client, la Région est mappée au point de terminaison spécifique à la Région. Le client utilise ce point de terminaison pour communiquer avec Amazon S3 : `s3.<region>.amazonaws.com`. Si votre Région a été lancée après le 20 mars 2019, votre client et votre compartiment doivent se trouver dans la même Région. Par conséquent, vous pouvez utiliser un client dans la Région USA Est (Virginie du Nord) pour créer un compartiment dans n’importe quelle Région lancée avant le 20 mars 2019. Pour plus d'informations, consultez [Points de terminaison hérités](https://docs.aws.amazon.com//AmazonS3/latest/dev/VirtualHosting.html#s3-legacy-endpoints).

Ces exemples de code AWS SDK exécutent les tâches suivantes :
+ **Créer un client en indiquant explicitement une Région AWS** – Dans l'exemple, le client utilise le point de terminaison `s3.us-west-2.amazonaws.com` pour communiquer avec Amazon S3. Vous pouvez spécifier n'importe quelle Région AWS. Pour en obtenir la liste Régions AWS, voir [Régions et points de terminaison](https://docs.aws.amazon.com/general/latest/gr/s3.html) dans le manuel de *référence AWS général*. 
+ **Envoyer une demande de création de compartiment en indiquant uniquement un nom de compartiment** — Le client envoie une demande à Amazon S3 pour créer le compartiment dans la Région où vous avez créé un client. 
+ *Récupérer des informations relatives à l'emplacement du compartiment* – Amazon S3 stocke les informations relatives à l'emplacement du compartiment dans la sous-ressource de l'**emplacement** associée au compartiment.

Les exemples de code suivants illustrent comment utiliser `CreateBucket`.

------
#### [ .NET ]

**SDK pour .NET (v4)**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/S3#code-examples). 

```
    /// <summary>
    /// Shows how to create a new Amazon S3 bucket.
    /// </summary>
    /// <param name="bucketName">The name of the bucket to create.</param>
    /// <returns>A boolean value representing the success or failure of
    /// the bucket creation process.</returns>
    public async Task<bool> CreateBucketAsync(string bucketName)
    {
        try
        {
            var request = new PutBucketRequest
            {
                BucketName = bucketName,
                UseClientRegion = true,
            };

            var response = await _amazonS3.PutBucketAsync(request);
            return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
        }
        catch (AmazonS3Exception ex)
        {
            Console.WriteLine($"Error creating bucket: '{ex.Message}'");
            return false;
        }
    }
```
+  Pour plus de détails sur l'API, reportez-vous [CreateBucket](https://docs.aws.amazon.com/goto/DotNetSDKV4/s3-2006-03-01/CreateBucket)à la section *Référence des AWS SDK pour .NET API*. 

**SDK pour .NET**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/S3#code-examples). 
Créez un compartiment avec le verrouillage d’objet activé.  

```
    /// <summary>
    /// Create a new Amazon S3 bucket with object lock actions.
    /// </summary>
    /// <param name="bucketName">The name of the bucket to create.</param>
    /// <param name="enableObjectLock">True to enable object lock on the bucket.</param>
    /// <returns>True if successful.</returns>
    public async Task<bool> CreateBucketWithObjectLock(string bucketName, bool enableObjectLock)
    {
        Console.WriteLine($"\tCreating bucket {bucketName} with object lock {enableObjectLock}.");
        try
        {
            var request = new PutBucketRequest
            {
                BucketName = bucketName,
                UseClientRegion = true,
                ObjectLockEnabledForBucket = enableObjectLock,
            };

            var response = await _amazonS3.PutBucketAsync(request);

            return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
        }
        catch (AmazonS3Exception ex)
        {
            Console.WriteLine($"Error creating bucket: '{ex.Message}'");
            return false;
        }
    }
```
+  Pour plus de détails sur l'API, reportez-vous [CreateBucket](https://docs.aws.amazon.com/goto/DotNetSDKV3/s3-2006-03-01/CreateBucket)à la section *Référence des AWS SDK pour .NET API*. 

------
#### [ Bash ]

**AWS CLI avec le script Bash**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/s3#code-examples). 

```
###############################################################################
# function iecho
#
# This function enables the script to display the specified text only if
# the global variable $VERBOSE is set to true.
###############################################################################
function iecho() {
  if [[ $VERBOSE == true ]]; then
    echo "$@"
  fi
}

###############################################################################
# function errecho
#
# This function outputs everything sent to it to STDERR (standard error output).
###############################################################################
function errecho() {
  printf "%s\n" "$*" 1>&2
}

###############################################################################
# function create-bucket
#
# This function creates the specified bucket in the specified AWS Region, unless
# it already exists.
#
# Parameters:
#       -b bucket_name  -- The name of the bucket to create.
#       -r region_code  -- The code for an AWS Region in which to
#                          create the bucket.
#
# Returns:
#       The URL of the bucket that was created.
#     And:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function create_bucket() {
  local bucket_name region_code response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function create_bucket"
    echo "Creates an Amazon S3 bucket. You must supply a bucket name:"
    echo "  -b bucket_name    The name of the bucket. It must be globally unique."
    echo "  [-r region_code]    The code for an AWS Region in which the bucket is created."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "b:r:h" option; do
    case "${option}" in
      b) bucket_name="${OPTARG}" ;;
      r) region_code="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done

  if [[ -z "$bucket_name" ]]; then
    errecho "ERROR: You must provide a bucket name with the -b parameter."
    usage
    return 1
  fi

  local bucket_config_arg
  # A location constraint for "us-east-1" returns an error.
  if [[ -n "$region_code" ]] && [[ "$region_code" != "us-east-1" ]]; then
    bucket_config_arg="--create-bucket-configuration LocationConstraint=$region_code"
  fi

  iecho "Parameters:\n"
  iecho "    Bucket name:   $bucket_name"
  iecho "    Region code:   $region_code"
  iecho ""

  # If the bucket already exists, we don't want to try to create it.
  if (bucket_exists "$bucket_name"); then
    errecho "ERROR: A bucket with that name already exists. Try again."
    return 1
  fi

  # shellcheck disable=SC2086
  response=$(aws s3api create-bucket \
    --bucket "$bucket_name" \
    $bucket_config_arg)

  # shellcheck disable=SC2181
  if [[ ${?} -ne 0 ]]; then
    errecho "ERROR: AWS reports create-bucket operation failed.\n$response"
    return 1
  fi
}
```
+  Pour plus de détails sur l'API, reportez-vous [CreateBucket](https://docs.aws.amazon.com/goto/aws-cli/s3-2006-03-01/CreateBucket)à la section *Référence des AWS CLI commandes*. 

------
#### [ C\$1\$1 ]

**SDK pour C\$1\$1**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3#code-examples). 

```
bool AwsDoc::S3::createBucket(const Aws::String &bucketName,
                              const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client client(clientConfig);
    Aws::S3::Model::CreateBucketRequest request;
    request.SetBucket(bucketName);

    if (clientConfig.region != "us-east-1") {
        Aws::S3::Model::CreateBucketConfiguration createBucketConfig;
        createBucketConfig.SetLocationConstraint(
                Aws::S3::Model::BucketLocationConstraintMapper::GetBucketLocationConstraintForName(
                        clientConfig.region));
        request.SetCreateBucketConfiguration(createBucketConfig);
    }

    Aws::S3::Model::CreateBucketOutcome outcome = client.CreateBucket(request);
    if (!outcome.IsSuccess()) {
        auto err = outcome.GetError();
        std::cerr << "Error: createBucket: " <<
                  err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        std::cout << "Created bucket " << bucketName <<
                  " in the specified AWS Region." << std::endl;
    }

    return outcome.IsSuccess();
}
```
+  Pour plus de détails sur l'API, reportez-vous [CreateBucket](https://docs.aws.amazon.com/goto/SdkForCpp/s3-2006-03-01/CreateBucket)à la section *Référence des AWS SDK pour C\$1\$1 API*. 

------
#### [ CLI ]

**AWS CLI**  
**Exemple 1 : pour créer un compartiment**  
L’exemple `create-bucket` suivant crée un compartiment nommé `amzn-s3-demo-bucket` :  

```
aws s3api create-bucket \
    --bucket amzn-s3-demo-bucket \
    --region us-east-1
```
Sortie :  

```
{
    "Location": "/amzn-s3-demo-bucket"
}
```
Pour plus d’informations, consultez [Création d’un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) dans le *Guide de l’utilisateur Amazon S3*.  
**Exemple 2 : pour créer un compartiment avec un propriétaire appliqué**  
L’exemple `create-bucket` suivant crée un compartiment nommé `amzn-s3-demo-bucket` qui utilise le paramètre de propriétaire du compartiment appliqué pour la propriété de l’objet S3.  

```
aws s3api create-bucket \
    --bucket amzn-s3-demo-bucket \
    --region us-east-1 \
    --object-ownership BucketOwnerEnforced
```
Sortie :  

```
{
    "Location": "/amzn-s3-demo-bucket"
}
```
Pour plus d'informations, consultez la section [Contrôle de la propriété des objets et désactivation ACLs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/about-object-ownership.html) dans le *guide de l'utilisateur Amazon S3*.  
**Exemple 3 : pour créer un compartiment en dehors de la région us-east-1**  
L’exemple `create-bucket` suivant crée un compartiment nommé `amzn-s3-demo-bucket` dans la région `eu-west-1`. Les régions autres que `us-east-1` exigent la bonne `LocationConstraint` pour créer le compartiment dans la région souhaitée.  

```
aws s3api create-bucket \
    --bucket amzn-s3-demo-bucket \
    --region eu-west-1 \
    --create-bucket-configuration LocationConstraint=eu-west-1
```
Sortie :  

```
{
    "Location": "http://amzn-s3-demo-bucket.s3.amazonaws.com/"
}
```
Pour plus d’informations, consultez [Création d’un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) dans le *Guide de l’utilisateur Amazon S3*.  
+  Pour plus de détails sur l'API, reportez-vous [CreateBucket](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/create-bucket.html)à la section *Référence des AWS CLI commandes*. 

------
#### [ Go ]

**Kit SDK pour Go V2**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/s3#code-examples). 
Créez un compartiment avec la configuration par défaut.  

```
import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"io"
	"log"
	"os"
	"time"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/feature/s3/manager"
	"github.com/aws/aws-sdk-go-v2/service/s3"
	"github.com/aws/aws-sdk-go-v2/service/s3/types"
	"github.com/aws/smithy-go"
)

// BucketBasics encapsulates the Amazon Simple Storage Service (Amazon S3) actions
// used in the examples.
// It contains S3Client, an Amazon S3 service client that is used to perform bucket
// and object actions.
type BucketBasics struct {
	S3Client *s3.Client
}



// CreateBucket creates a bucket with the specified name in the specified Region.
func (basics BucketBasics) CreateBucket(ctx context.Context, name string, region string) error {
	_, err := basics.S3Client.CreateBucket(ctx, &s3.CreateBucketInput{
		Bucket: aws.String(name),
		CreateBucketConfiguration: &types.CreateBucketConfiguration{
			LocationConstraint: types.BucketLocationConstraint(region),
		},
	})
	if err != nil {
		var owned *types.BucketAlreadyOwnedByYou
		var exists *types.BucketAlreadyExists
		if errors.As(err, &owned) {
			log.Printf("You already own bucket %s.\n", name)
			err = owned
		} else if errors.As(err, &exists) {
			log.Printf("Bucket %s already exists.\n", name)
			err = exists
		}
	} else {
		err = s3.NewBucketExistsWaiter(basics.S3Client).Wait(
			ctx, &s3.HeadBucketInput{Bucket: aws.String(name)}, time.Minute)
		if err != nil {
			log.Printf("Failed attempt to wait for bucket %s to exist.\n", name)
		}
	}
	return err
}
```
Créez un compartiment avec verrouillage d’objets et attendez qu’il existe.  

```
import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"log"
	"time"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/feature/s3/manager"
	"github.com/aws/aws-sdk-go-v2/service/s3"
	"github.com/aws/aws-sdk-go-v2/service/s3/types"
	"github.com/aws/smithy-go"
)

// S3Actions wraps S3 service actions.
type S3Actions struct {
	S3Client  *s3.Client
	S3Manager *manager.Uploader
}



// CreateBucketWithLock creates a new S3 bucket with optional object locking enabled
// and waits for the bucket to exist before returning.
func (actor S3Actions) CreateBucketWithLock(ctx context.Context, bucket string, region string, enableObjectLock bool) (string, error) {
	input := &s3.CreateBucketInput{
		Bucket: aws.String(bucket),
		CreateBucketConfiguration: &types.CreateBucketConfiguration{
			LocationConstraint: types.BucketLocationConstraint(region),
		},
	}

	if enableObjectLock {
		input.ObjectLockEnabledForBucket = aws.Bool(true)
	}

	_, err := actor.S3Client.CreateBucket(ctx, input)
	if err != nil {
		var owned *types.BucketAlreadyOwnedByYou
		var exists *types.BucketAlreadyExists
		if errors.As(err, &owned) {
			log.Printf("You already own bucket %s.\n", bucket)
			err = owned
		} else if errors.As(err, &exists) {
			log.Printf("Bucket %s already exists.\n", bucket)
			err = exists
		}
	} else {
		err = s3.NewBucketExistsWaiter(actor.S3Client).Wait(
			ctx, &s3.HeadBucketInput{Bucket: aws.String(bucket)}, time.Minute)
		if err != nil {
			log.Printf("Failed attempt to wait for bucket %s to exist.\n", bucket)
		}
	}

	return bucket, err
}
```
+  Pour plus de détails sur l'API, reportez-vous [CreateBucket](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3#Client.CreateBucket)à la section *Référence des AWS SDK pour Go API*. 

------
#### [ Java ]

**SDK pour Java 2.x**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/s3#code-examples). 
Créez un compartiment.  

```
    /**
     * Creates an S3 bucket asynchronously.
     *
     * @param bucketName the name of the S3 bucket to create
     * @return a {@link CompletableFuture} that completes when the bucket is created and ready
     * @throws RuntimeException if there is a failure while creating the bucket
     */
    public CompletableFuture<Void> createBucketAsync(String bucketName) {
        CreateBucketRequest bucketRequest = CreateBucketRequest.builder()
            .bucket(bucketName)
            .build();

        CompletableFuture<CreateBucketResponse> response = getAsyncClient().createBucket(bucketRequest);
        return response.thenCompose(resp -> {
            S3AsyncWaiter s3Waiter = getAsyncClient().waiter();
            HeadBucketRequest bucketRequestWait = HeadBucketRequest.builder()
                .bucket(bucketName)
                .build();

            CompletableFuture<WaiterResponse<HeadBucketResponse>> waiterResponseFuture =
                s3Waiter.waitUntilBucketExists(bucketRequestWait);
            return waiterResponseFuture.thenAccept(waiterResponse -> {
                waiterResponse.matched().response().ifPresent(headBucketResponse -> {
                    logger.info(bucketName + " is ready");
                });
            });
        }).whenComplete((resp, ex) -> {
            if (ex != null) {
                throw new RuntimeException("Failed to create bucket", ex);
            }
        });
    }
```
Créez un compartiment avec le verrouillage d’objet activé.  

```
    // Create a new Amazon S3 bucket with object lock options.
    public void createBucketWithLockOptions(boolean enableObjectLock, String bucketName) {
        S3Waiter s3Waiter = getClient().waiter();
        CreateBucketRequest bucketRequest = CreateBucketRequest.builder()
            .bucket(bucketName)
            .objectLockEnabledForBucket(enableObjectLock)
            .build();

        getClient().createBucket(bucketRequest);
        HeadBucketRequest bucketRequestWait = HeadBucketRequest.builder()
            .bucket(bucketName)
            .build();

        // Wait until the bucket is created and print out the response.
        s3Waiter.waitUntilBucketExists(bucketRequestWait);
        System.out.println(bucketName + " is ready");
    }
```
+  Pour plus de détails sur l'API, reportez-vous [CreateBucket](https://docs.aws.amazon.com/goto/SdkForJavaV2/s3-2006-03-01/CreateBucket)à la section *Référence des AWS SDK for Java 2.x API*. 

------
#### [ JavaScript ]

**SDK pour JavaScript (v3)**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/s3#code-examples). 
Créer le compartiment.  

```
import {
  BucketAlreadyExists,
  BucketAlreadyOwnedByYou,
  CreateBucketCommand,
  S3Client,
  waitUntilBucketExists,
} from "@aws-sdk/client-s3";

/**
 * Create an Amazon S3 bucket.
 * @param {{ bucketName: string }} config
 */
export const main = async ({ bucketName }) => {
  const client = new S3Client({});

  try {
    const { Location } = await client.send(
      new CreateBucketCommand({
        // The name of the bucket. Bucket names are unique and have several other constraints.
        // See https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html
        Bucket: bucketName,
      }),
    );
    await waitUntilBucketExists({ client }, { Bucket: bucketName });
    console.log(`Bucket created with location ${Location}`);
  } catch (caught) {
    if (caught instanceof BucketAlreadyExists) {
      console.error(
        `The bucket "${bucketName}" already exists in another AWS account. Bucket names must be globally unique.`,
      );
    }
    // WARNING: If you try to create a bucket in the North Virginia region,
    // and you already own a bucket in that region with the same name, this
    // error will not be thrown. Instead, the call will return successfully
    // and the ACL on that bucket will be reset.
    else if (caught instanceof BucketAlreadyOwnedByYou) {
      console.error(
        `The bucket "${bucketName}" already exists in this AWS account.`,
      );
    } else {
      throw caught;
    }
  }
};
```
+  Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/s3-example-creating-buckets.html#s3-example-creating-buckets-new-bucket-2). 
+  Pour plus de détails sur l'API, reportez-vous [CreateBucket](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/CreateBucketCommand)à la section *Référence des AWS SDK pour JavaScript API*. 

------
#### [ Kotlin ]

**SDK pour Kotlin**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/s3#code-examples). 

```
suspend fun createNewBucket(bucketName: String) {
    val request =
        CreateBucketRequest {
            bucket = bucketName
        }

    S3Client.fromEnvironment { region = "us-east-1" }.use { s3 ->
        s3.createBucket(request)
        println("$bucketName is ready")
    }
}
```
+  Pour plus de détails sur l'API, reportez-vous [CreateBucket](https://sdk.amazonaws.com/kotlin/api/latest/index.html)à la section *AWS SDK pour la référence de l'API Kotlin*. 

------
#### [ PHP ]

**Kit SDK pour PHP**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3#code-examples). 
Créez un compartiment.  

```
        $s3client = new Aws\S3\S3Client(['region' => 'us-west-2']);

        try {
            $this->s3client->createBucket([
                'Bucket' => $this->bucketName,
                'CreateBucketConfiguration' => ['LocationConstraint' => $region],
            ]);
            echo "Created bucket named: $this->bucketName \n";
        } catch (Exception $exception) {
            echo "Failed to create bucket $this->bucketName with error: " . $exception->getMessage();
            exit("Please fix error with bucket creation before continuing.");
        }
```
+  Pour plus de détails sur l'API, reportez-vous [CreateBucket](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/CreateBucket)à la section *Référence des AWS SDK pour PHP API*. 

------
#### [ Python ]

**Kit SDK for Python (Boto3)**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/s3/s3_basics#code-examples). 
Créer un compartiment avec les paramètres par défaut.  

```
class BucketWrapper:
    """Encapsulates S3 bucket actions."""

    def __init__(self, bucket):
        """
        :param bucket: A Boto3 Bucket resource. This is a high-level resource in Boto3
                       that wraps bucket actions in a class-like structure.
        """
        self.bucket = bucket
        self.name = bucket.name


    def create(self, region_override=None):
        """
        Create an Amazon S3 bucket in the default Region for the account or in the
        specified Region.

        :param region_override: The Region in which to create the bucket. If this is
                                not specified, the Region configured in your shared
                                credentials is used.
        """
        if region_override is not None:
            region = region_override
        else:
            region = self.bucket.meta.client.meta.region_name
        try:
            self.bucket.create(CreateBucketConfiguration={"LocationConstraint": region})

            self.bucket.wait_until_exists()
            logger.info("Created bucket '%s' in region=%s", self.bucket.name, region)
        except ClientError as error:
            logger.exception(
                "Couldn't create bucket named '%s' in region=%s.",
                self.bucket.name,
                region,
            )
            raise error
```
Créer un compartiment soumis à la gestion des versions avec une configuration de cycle de vie.  

```
def create_versioned_bucket(bucket_name, prefix):
    """
    Creates an Amazon S3 bucket, enables it for versioning, and configures a lifecycle
    that expires noncurrent object versions after 7 days.

    Adding a lifecycle configuration to a versioned bucket is a best practice.
    It helps prevent objects in the bucket from accumulating a large number of
    noncurrent versions, which can slow down request performance.

    Usage is shown in the usage_demo_single_object function at the end of this module.

    :param bucket_name: The name of the bucket to create.
    :param prefix: Identifies which objects are automatically expired under the
                   configured lifecycle rules.
    :return: The newly created bucket.
    """
    try:
        bucket = s3.create_bucket(
            Bucket=bucket_name,
            CreateBucketConfiguration={
                "LocationConstraint": s3.meta.client.meta.region_name
            },
        )
        logger.info("Created bucket %s.", bucket.name)
    except ClientError as error:
        if error.response["Error"]["Code"] == "BucketAlreadyOwnedByYou":
            logger.warning("Bucket %s already exists! Using it.", bucket_name)
            bucket = s3.Bucket(bucket_name)
        else:
            logger.exception("Couldn't create bucket %s.", bucket_name)
            raise

    try:
        bucket.Versioning().enable()
        logger.info("Enabled versioning on bucket %s.", bucket.name)
    except ClientError:
        logger.exception("Couldn't enable versioning on bucket %s.", bucket.name)
        raise

    try:
        expiration = 7
        bucket.LifecycleConfiguration().put(
            LifecycleConfiguration={
                "Rules": [
                    {
                        "Status": "Enabled",
                        "Prefix": prefix,
                        "NoncurrentVersionExpiration": {"NoncurrentDays": expiration},
                    }
                ]
            }
        )
        logger.info(
            "Configured lifecycle to expire noncurrent versions after %s days "
            "on bucket %s.",
            expiration,
            bucket.name,
        )
    except ClientError as error:
        logger.warning(
            "Couldn't configure lifecycle on bucket %s because %s. "
            "Continuing anyway.",
            bucket.name,
            error,
        )

    return bucket
```
+  Pour plus de détails sur l'API, consultez [CreateBucket](https://docs.aws.amazon.com/goto/boto3/s3-2006-03-01/CreateBucket)le *AWS manuel de référence de l'API SDK for Python (Boto3*). 

------
#### [ Ruby ]

**Kit SDK pour Ruby**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/s3#code-examples). 

```
require 'aws-sdk-s3'

# Wraps Amazon S3 bucket actions.
class BucketCreateWrapper
  attr_reader :bucket

  # @param bucket [Aws::S3::Bucket] An Amazon S3 bucket initialized with a name. This is a client-side object until
  #                                 create is called.
  def initialize(bucket)
    @bucket = bucket
  end

  # Creates an Amazon S3 bucket in the specified AWS Region.
  #
  # @param region [String] The Region where the bucket is created.
  # @return [Boolean] True when the bucket is created; otherwise, false.
  def create?(region)
    @bucket.create(create_bucket_configuration: { location_constraint: region })
    true
  rescue Aws::Errors::ServiceError => e
    puts "Couldn't create bucket. Here's why: #{e.message}"
    false
  end

  # Gets the Region where the bucket is located.
  #
  # @return [String] The location of the bucket.
  def location
    if @bucket.nil?
      'None. You must create a bucket before you can get its location!'
    else
      @bucket.client.get_bucket_location(bucket: @bucket.name).location_constraint
    end
  rescue Aws::Errors::ServiceError => e
    "Couldn't get the location of #{@bucket.name}. Here's why: #{e.message}"
  end
end

# Example usage:
def run_demo
  region = "us-west-2"
  wrapper = BucketCreateWrapper.new(Aws::S3::Bucket.new("amzn-s3-demo-bucket-#{Random.uuid}"))
  return unless wrapper.create?(region)

  puts "Created bucket #{wrapper.bucket.name}."
  puts "Your bucket's region is: #{wrapper.location}"
end

run_demo if $PROGRAM_NAME == __FILE__
```
+  Pour plus de détails sur l'API, reportez-vous [CreateBucket](https://docs.aws.amazon.com/goto/SdkForRubyV3/s3-2006-03-01/CreateBucket)à la section *Référence des AWS SDK pour Ruby API*. 

------
#### [ Rust ]

**SDK pour Rust**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/s3#code-examples). 

```
pub async fn create_bucket(
    client: &aws_sdk_s3::Client,
    bucket_name: &str,
    region: &aws_config::Region,
) -> Result<Option<aws_sdk_s3::operation::create_bucket::CreateBucketOutput>, S3ExampleError> {
    let constraint = aws_sdk_s3::types::BucketLocationConstraint::from(region.to_string().as_str());
    let cfg = aws_sdk_s3::types::CreateBucketConfiguration::builder()
        .location_constraint(constraint)
        .build();
    let create = client
        .create_bucket()
        .create_bucket_configuration(cfg)
        .bucket(bucket_name)
        .send()
        .await;

    // BucketAlreadyExists and BucketAlreadyOwnedByYou are not problems for this task.
    create.map(Some).or_else(|err| {
        if err
            .as_service_error()
            .map(|se| se.is_bucket_already_exists() || se.is_bucket_already_owned_by_you())
            == Some(true)
        {
            Ok(None)
        } else {
            Err(S3ExampleError::from(err))
        }
    })
}
```
+  Pour plus de détails sur l'API, voir [CreateBucket](https://docs.rs/aws-sdk-s3/latest/aws_sdk_s3/client/struct.Client.html#method.create_bucket)la section de *référence de l'API AWS SDK for Rust*. 

------
#### [ SAP ABAP ]

**Kit SDK pour SAP ABAP**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/s3#code-examples). 

```
    TRY.
        " determine our region from our session
        DATA(lv_region) = CONV /aws1/s3_bucketlocationcnstrnt( lo_session->get_region( ) ).
        DATA lo_constraint TYPE REF TO /aws1/cl_s3_createbucketconf.
        " When in the us-east-1 region, you must not specify a constraint
        " In all other regions, specify the region as the constraint
        IF lv_region = 'us-east-1'.
          CLEAR lo_constraint.
        ELSE.
          lo_constraint = NEW /aws1/cl_s3_createbucketconf( lv_region ).
        ENDIF.

        lo_s3->createbucket(
            iv_bucket = iv_bucket_name
            io_createbucketconfiguration  = lo_constraint ).
        MESSAGE 'S3 bucket created.' TYPE 'I'.
      CATCH /aws1/cx_s3_bucketalrdyexists.
        MESSAGE 'Bucket name already exists.' TYPE 'E'.
      CATCH /aws1/cx_s3_bktalrdyownedbyyou.
        MESSAGE 'Bucket already exists and is owned by you.' TYPE 'E'.
    ENDTRY.
```
+  Pour plus de détails sur l'API, reportez-vous [CreateBucket](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)à la section de référence du *AWS SDK pour l'API SAP ABAP*. 

------
#### [ Swift ]

**Kit SDK pour Swift**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/s3/basics#code-examples). 

```
import AWSS3

    public func createBucket(name: String) async throws {
        var input = CreateBucketInput(
            bucket: name
        )
        
        // For regions other than "us-east-1", you must set the locationConstraint in the createBucketConfiguration.
        // For more information, see LocationConstraint in the S3 API guide.
        // https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateBucket.html#API_CreateBucket_RequestBody
        if let region = configuration.region {
            if region != "us-east-1" {
                input.createBucketConfiguration = S3ClientTypes.CreateBucketConfiguration(locationConstraint: S3ClientTypes.BucketLocationConstraint(rawValue: region))
            }
        }

        do {
            _ = try await client.createBucket(input: input)
        }
        catch let error as BucketAlreadyOwnedByYou {
            print("The bucket '\(name)' already exists and is owned by you. You may wish to ignore this exception.")
            throw error
        }
        catch {
            print("ERROR: ", dump(error, name: "Creating a bucket"))
            throw error
        }
    }
```
+  Pour plus de détails sur l'API, reportez-vous [CreateBucket](https://sdk.amazonaws.com/swift/api/awss3/latest/documentation/awss3/s3client/createbucket(input:))à la section *AWS SDK pour la référence de l'API Swift*. 

------

**Note**  
Vous pouvez également utiliser un compartiment Amazon S3 d'un autre compte, mais vous devrez peut-être créer une politique pour le compartiment qui accorde des autorisations d'accès à AWS Config. Pour en savoir plus sur l'accord d'autorisations à un compartiment Amazon S3, consultez [Autorisations pour le compartiment Amazon S3 pour le canal AWS Config de diffusion](s3-bucket-policy.md), puis passer à [Étape 2 : Création d'une rubrique Amazon SNS](#gs-cli-create-snstopic).

## Étape 2 : Création d'une rubrique Amazon SNS
<a name="gs-cli-create-snstopic"></a>

Si vous avez déjà une rubrique Amazon SNS dans votre compte et que vous souhaitez l'utiliser, ignorez cette étape et passez à [Étape 3 : Création d'un rôle IAM](#gs-cli-create-iamrole).

### Utilisation de la console SNS
<a name="create-snstopic"></a>

**Pour créer une rubrique Amazon SNS**

1. [Ouvrez la console Amazon SNS à l'adresse v3/home. https://console.aws.amazon.com/sns/](https://console.aws.amazon.com/sns/v3/home)

1. Effectuez l’une des actions suivantes :
   + Si aucun sujet n'a encore été créé sous votre Compte AWS nom, lisez la description d'Amazon SNS sur la page d'accueil.
   + Si des sujets ont déjà été créés sous votre Compte AWS nom, dans le panneau de navigation, sélectionnez **Sujets**.

1. Sur la page **Rubriques**, choisissez **Créer une rubrique**.

1. Sur la page **Créer une rubrique**, dans la section **Détails**, procédez comme suit :

   1. Pour **Type**, choisissez un type de rubrique (**Standard** ou **FIFO**).

   1. Entrez un **Nom** pour la rubrique. Pour une [rubrique FIFO](https://docs.aws.amazon.com/sns/latest/dg/sns-fifo-topics.html), ajoutez **.fifo** à la fin du nom.

   1. (Facultatif) Entrez un **Nom d'affichage** pour votre rubrique.

   1. (Facultatif) Pour une rubrique FIFO, vous pouvez choisir **déduplication des messages basée sur le contenu** pour activer la déduplication des messages par défaut. Pour plus d'informations, consultez [Déduplication de message pour les rubriques FIFO](https://docs.aws.amazon.com/sns/latest/dg/fifo-message-dedup.html).

1. (Facultatif) Développez la section **Chiffrement** et effectuez les opérations suivantes. Pour plus d'informations, consultez [Chiffrement au repos](https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html).

   1. Choisissez **Activer le chiffrement**.

   1. Spécifiez la clé principale client (CMK). Pour plus d'informations, veuillez consulter la rubrique [Termes clés](https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html#sse-key-terms).

      Pour chaque type de CMK, les champs **Description**, **Compte** et **CARN CMK** s'affichent.
**Important**  
Si vous n'êtes pas le propriétaire de la clé CMK, ou si vous vous connectez avec un compte n'ayant pas les autorisations `kms:ListAliases` et `kms:DescribeKey`, vous ne pouvez pas afficher les informations relatives au CMK sur la console Amazon SNS.  
Demandez au propriétaire du CMK de vous accorder ces autorisations. Pour plus d'informations, consultez [Autorisations d'API AWS KMS  : référence des actions et ressources](https://docs.aws.amazon.com/kms/latest/developerguide/kms-api-permissions-reference.html) dans le *Guide du développeur AWS Key Management Service *.
      + La AWS clé CMK gérée pour Amazon **SNS (par défaut alias/aws/sns**) est sélectionnée par défaut.
**Note**  
Gardez à l'esprit les points suivants :  
La première fois que vous utilisez le AWS Management Console pour spécifier la clé CMK AWS gérée pour Amazon SNS pour un sujet AWS KMS , la clé CMK gérée pour Amazon SNS est créée AWS .
Sinon, la première fois que vous utilisez l'`Publish`action sur un sujet où SSE est activé, la clé CMK AWS gérée est AWS KMS créée pour Amazon SNS.
      + Pour utiliser une clé CMK personnalisée à partir de votre **clé CMK Compte AWS, choisissez le champ Clé principale du client (CMK)**, puis choisissez la clé CMK personnalisée dans la liste.
**Note**  
Pour obtenir des instructions sur la création de clés personnalisées CMKs, voir [Création de clés](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) dans le *guide du AWS Key Management Service développeur*
      + Pour utiliser un ARN CMK personnalisé provenant de votre compte Compte AWS ou d'un autre AWS compte, saisissez-le dans le champ **Clé principale du client (CMK)**.

1. (Facultatif) Par défaut, seul le propriétaire de la rubrique peut publier dans la rubrique ou s'abonner à la rubrique. Pour configurer des autorisations d'accès supplémentaires, développez la section **Politique d'accès**. Pour plus d'informations, consultez [Gestion des identités et des accès dans Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-authentication-and-access-control.html) et [Cas d'exemple pour le contrôle d'accès Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-access-policy-use-cases.html). 
**Note**  
Lorsque vous créez une rubrique à l'aide de la console, la politique par défaut utilise la clé de condition `aws:SourceOwner`. Cette clé est similaire à `aws:SourceAccount`. 

1. (Facultatif) Pour configurer la façon dont Amazon SNS retente la distribution des messages en échec, développez la section **Politique de nouvelle tentative de distribution (HTTP/S)**. Pour plus d'informations, consultez [Nouvelle tentative de distribution des messages Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-message-delivery-retries.html).

1. (Facultatif) Pour configurer la manière dont Amazon SNS enregistre la livraison des messages CloudWatch, développez la section **Enregistrement de l'état de livraison**. Pour plus d'informations, voir [État de distribution des messages Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-topic-attributes.html).

1. (Facultatif) Pour ajouter des balises de métadonnées à la rubrique, développez la section **Balises**, saisissez une **clé** et une **valeur** (facultatif) et choisissez **Ajouter une balise**. Pour plus d'informations, consultez [Identification des rubriques Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-tags.html).

1. Choisissez **Créer une rubrique**.

   Le sujet est créé et la ***MyTopic***page s'affiche.

   Le **Nom** de la rubrique, l'**ARN**, (facultatif) le **Nom d'affichage** et l'ID de compte AWS du **Propriétaire de la rubrique** sont affichés dans la section **Détails**.

1. Copiez l'ARN de rubrique dans le Presse-papiers, par exemple :

   ```
   arn:aws:sns:us-east-2:123456789012:MyTopic
   ```

**Pour abonner une adresse e-mail à la rubrique Amazon SNS**

1. [Ouvrez la console Amazon SNS à l'adresse v3/home. https://console.aws.amazon.com/sns/](https://console.aws.amazon.com/sns/v3/home)

1. Dans le volet de navigation de gauche, choisissez **Abonnements**.

1. Sur la page **Abonnements**, choisissez **Créer un abonnement**.

1. Sur la page **Créer un abonnement**, dans la section **Détails**, procédez comme suit :

   1. Pour **ARN de rubrique**, choisissez l'ARN (Amazon Resource Name) d'une rubrique.

   1. Pour **Protocole**, choisissez un type de point de terminaison.  Les types de point de terminaison disponibles sont les suivants :
      + [HTTP/HTTPS](https://docs.aws.amazon.com/sns/latest/dg/sns-http-https-endpoint-as-subscriber.html)
      + [E-mail/E-mail-JSON](https://docs.aws.amazon.com/sns/latest/dg/sns-email-notifications.html)
      + [Amazon Data Firehose](https://docs.aws.amazon.com/sns/latest/dg/sns-firehose-as-subscriber.html)
      + [Amazon SQS](https://docs.aws.amazon.com/sns/latest/dg/sns-sqs-as-subscriber.html)
**Note**  
Pour vous abonner à une [Rubrique SNS FIFO](https://docs.aws.amazon.com/sns/latest/dg/sns-fifo-topics.html), choisissez cette option.
      + [AWS Lambda](https://docs.aws.amazon.com/sns/latest/dg/sns-lambda-as-subscriber.html)
      + [Point de terminaison de l'application de plateforme](https://docs.aws.amazon.com/sns/latest/dg/sns-mobile-application-as-subscriber.html)
      + [SMS](https://docs.aws.amazon.com/sns/latest/dg/sns-mobile-phone-number-as-subscriber.html)

   1. Pour **Point de terminaison**, saisissez la valeur du point de terminaison, telle qu'une adresse e-mail ou l'ARN d'une file d'attente Amazon SQS.

   1. Points de terminaison Firehose uniquement : pour l'**ARN du rôle** d'abonnement, spécifiez l'ARN du rôle IAM que vous avez créé pour écrire dans les flux de diffusion Firehose. Pour plus d'informations, consultez la section [Conditions préalables à l'abonnement des flux de diffusion Firehose aux rubriques Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/prereqs-kinesis-data-firehose.html).

   1. (Facultatif) Pour Firehose, Amazon SQS et les points de terminaison HTTP/S , vous pouvez également activer la livraison de messages bruts. Pour plus d'informations, consultez [Remise des messages bruts Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-large-payload-raw-message-delivery.html).

   1. (Facultatif) Pour configurer une politique de filtre, développez la section **Politique de filtre d'abonnement**. Pour plus d'informations, consultez les [politiques de filtre d'abonnement Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-subscription-filter-policies.html).

   1. (Facultatif) Pour configurer une file d’attente de lettres mortes pour l’abonnement, développez la section **Politique de reconduite (File d’attente de lettres mortes).** Pour plus d'informations, consultez les files [d'attente de lettres mortes Amazon SNS (](https://docs.aws.amazon.com/sns/latest/dg/sns-dead-letter-queues.html)). DLQs

   1. Choisissez **Créer un abonnement**.

      La console crée l'abonnement et ouvre la page **Détails** de l’abonnement.

### En utilisant le AWS SDKs
<a name="create-snstopic-intro"></a>

Pour utiliser un AWS SDK, vous devez le configurer avec vos informations d'identification. Pour plus d'informations, consultez [la section Les fichiers de configuration et d'identification partagés](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) dans le *guide de référence AWS SDKs et Tools*.

Les exemples de code suivants illustrent comment utiliser `CreateTopic`.

------
#### [ .NET ]

**SDK pour .NET**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/SNS#code-examples). 
Créez une rubrique avec un nom spécifique.  

```
    using System;
    using System.Threading.Tasks;
    using Amazon.SimpleNotificationService;
    using Amazon.SimpleNotificationService.Model;

    /// <summary>
    /// This example shows how to use Amazon Simple Notification Service
    /// (Amazon SNS) to add a new Amazon SNS topic.
    /// </summary>
    public class CreateSNSTopic
    {
        public static async Task Main()
        {
            string topicName = "ExampleSNSTopic";

            IAmazonSimpleNotificationService client = new AmazonSimpleNotificationServiceClient();

            var topicArn = await CreateSNSTopicAsync(client, topicName);
            Console.WriteLine($"New topic ARN: {topicArn}");
        }

        /// <summary>
        /// Creates a new SNS topic using the supplied topic name.
        /// </summary>
        /// <param name="client">The initialized SNS client object used to
        /// create the new topic.</param>
        /// <param name="topicName">A string representing the topic name.</param>
        /// <returns>The Amazon Resource Name (ARN) of the created topic.</returns>
        public static async Task<string> CreateSNSTopicAsync(IAmazonSimpleNotificationService client, string topicName)
        {
            var request = new CreateTopicRequest
            {
                Name = topicName,
            };

            var response = await client.CreateTopicAsync(request);

            return response.TopicArn;
        }
    }
```
Créez une nouvelle rubrique avec un nom et des attributs FIFO et de déduplication spécifiques.  

```
    /// <summary>
    /// Create a new topic with a name and specific FIFO and de-duplication attributes.
    /// </summary>
    /// <param name="topicName">The name for the topic.</param>
    /// <param name="useFifoTopic">True to use a FIFO topic.</param>
    /// <param name="useContentBasedDeduplication">True to use content-based de-duplication.</param>
    /// <returns>The ARN of the new topic.</returns>
    public async Task<string> CreateTopicWithName(string topicName, bool useFifoTopic, bool useContentBasedDeduplication)
    {
        var createTopicRequest = new CreateTopicRequest()
        {
            Name = topicName,
        };

        if (useFifoTopic)
        {
            // Update the name if it is not correct for a FIFO topic.
            if (!topicName.EndsWith(".fifo"))
            {
                createTopicRequest.Name = topicName + ".fifo";
            }

            // Add the attributes from the method parameters.
            createTopicRequest.Attributes = new Dictionary<string, string>
            {
                { "FifoTopic", "true" }
            };
            if (useContentBasedDeduplication)
            {
                createTopicRequest.Attributes.Add("ContentBasedDeduplication", "true");
            }
        }

        var createResponse = await _amazonSNSClient.CreateTopicAsync(createTopicRequest);
        return createResponse.TopicArn;
    }
```
+  Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://docs.aws.amazon.com/goto/DotNetSDKV3/sns-2010-03-31/CreateTopic)à la section *Référence des AWS SDK pour .NET API*. 

------
#### [ C\$1\$1 ]

**SDK pour C\$1\$1**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sns#code-examples). 

```
//! Create an Amazon Simple Notification Service (Amazon SNS) topic.
/*!
  \param topicName: An Amazon SNS topic name.
  \param topicARNResult: String to return the Amazon Resource Name (ARN) for the topic.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
 */
bool AwsDoc::SNS::createTopic(const Aws::String &topicName,
                              Aws::String &topicARNResult,
                              const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::SNS::SNSClient snsClient(clientConfiguration);

    Aws::SNS::Model::CreateTopicRequest request;
    request.SetName(topicName);

    const Aws::SNS::Model::CreateTopicOutcome outcome = snsClient.CreateTopic(request);

    if (outcome.IsSuccess()) {
        topicARNResult = outcome.GetResult().GetTopicArn();
        std::cout << "Successfully created an Amazon SNS topic " << topicName
                  << " with topic ARN '" << topicARNResult
                  << "'." << std::endl;

    }
    else {
        std::cerr << "Error creating topic " << topicName << ":" <<
                  outcome.GetError().GetMessage() << std::endl;
        topicARNResult.clear();
    }

    return outcome.IsSuccess();
}
```
+  Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://docs.aws.amazon.com/goto/SdkForCpp/sns-2010-03-31/CreateTopic)à la section *Référence des AWS SDK pour C\$1\$1 API*. 

------
#### [ CLI ]

**AWS CLI**  
**Pour créer une rubrique SNS**  
L’exemple `create-topic` suivant crée une rubrique SNS nommée `my-topic`.  

```
aws sns create-topic \
    --name my-topic
```
Sortie :  

```
{
    "ResponseMetadata": {
        "RequestId": "1469e8d7-1642-564e-b85d-a19b4b341f83"
    },
    "TopicArn": "arn:aws:sns:us-west-2:123456789012:my-topic"
}
```
Pour plus d'informations, consultez la section [Utilisation de l'interface de ligne de AWS commande avec Amazon SQS et Amazon SNS](https://docs.aws.amazon.com/cli/latest/userguide/cli-sqs-queue-sns-topic.html) dans le Guide de l'utilisateur de *AWS l'interface de ligne de commande*.  
+  Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sns/create-topic.html)à la section *Référence des AWS CLI commandes*. 

------
#### [ Go ]

**Kit SDK pour Go V2**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/workflows/topics_and_queues#code-examples). 

```
import (
	"context"
	"encoding/json"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/sns"
	"github.com/aws/aws-sdk-go-v2/service/sns/types"
)

// SnsActions encapsulates the Amazon Simple Notification Service (Amazon SNS) actions
// used in the examples.
type SnsActions struct {
	SnsClient *sns.Client
}



// CreateTopic creates an Amazon SNS topic with the specified name. You can optionally
// specify that the topic is created as a FIFO topic and whether it uses content-based
// deduplication instead of ID-based deduplication.
func (actor SnsActions) CreateTopic(ctx context.Context, topicName string, isFifoTopic bool, contentBasedDeduplication bool) (string, error) {
	var topicArn string
	topicAttributes := map[string]string{}
	if isFifoTopic {
		topicAttributes["FifoTopic"] = "true"
	}
	if contentBasedDeduplication {
		topicAttributes["ContentBasedDeduplication"] = "true"
	}
	topic, err := actor.SnsClient.CreateTopic(ctx, &sns.CreateTopicInput{
		Name:       aws.String(topicName),
		Attributes: topicAttributes,
	})
	if err != nil {
		log.Printf("Couldn't create topic %v. Here's why: %v\n", topicName, err)
	} else {
		topicArn = *topic.TopicArn
	}

	return topicArn, err
}
```
+  Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/sns#Client.CreateTopic)à la section *Référence des AWS SDK pour Go API*. 

------
#### [ Java ]

**SDK pour Java 2.x**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/sns#code-examples). 

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.CreateTopicRequest;
import software.amazon.awssdk.services.sns.model.CreateTopicResponse;
import software.amazon.awssdk.services.sns.model.SnsException;

/**
 * Before running this Java V2 code example, set up your development
 * environment, including your credentials.
 *
 * For more information, see the following documentation topic:
 *
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class CreateTopic {
    public static void main(String[] args) {
        final String usage = """

                Usage:    <topicName>

                Where:
                   topicName - The name of the topic to create (for example, mytopic).

                """;

        if (args.length != 1) {
            System.out.println(usage);
            System.exit(1);
        }

        String topicName = args[0];
        System.out.println("Creating a topic with name: " + topicName);
        SnsClient snsClient = SnsClient.builder()
                .region(Region.US_EAST_1)
                .build();

        String arnVal = createSNSTopic(snsClient, topicName);
        System.out.println("The topic ARN is" + arnVal);
        snsClient.close();
    }

    public static String createSNSTopic(SnsClient snsClient, String topicName) {
        CreateTopicResponse result;
        try {
            CreateTopicRequest request = CreateTopicRequest.builder()
                    .name(topicName)
                    .build();

            result = snsClient.createTopic(request);
            return result.topicArn();

        } catch (SnsException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return "";
    }
}
```
+  Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://docs.aws.amazon.com/goto/SdkForJavaV2/sns-2010-03-31/CreateTopic)à la section *Référence des AWS SDK for Java 2.x API*. 

------
#### [ JavaScript ]

**SDK pour JavaScript (v3)**  
 Il y en a plus sur GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples). 
Créez le client dans un module séparé et exportez-le.  

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```
Importez le kit SDK et les modules client et appelez l’API.  

```
import { CreateTopicCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicName - The name of the topic to create.
 */
export const createTopic = async (topicName = "TOPIC_NAME") => {
  const response = await snsClient.send(
    new CreateTopicCommand({ Name: topicName }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '087b8ad2-4593-50c4-a496-d7e90b82cf3e',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   TopicArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:TOPIC_NAME'
  // }
  return response;
};
```
+  Pour plus d’informations, consultez le [AWS SDK pour JavaScript Guide du développeur](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-managing-topics.html#sns-examples-managing-topics-createtopic). 
+  Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/CreateTopicCommand)à la section *Référence des AWS SDK pour JavaScript API*. 

------
#### [ Kotlin ]

**SDK pour Kotlin**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/sns#code-examples). 

```
suspend fun createSNSTopic(topicName: String): String {
    val request =
        CreateTopicRequest {
            name = topicName
        }

    SnsClient.fromEnvironment { region = "us-east-1" }.use { snsClient ->
        val result = snsClient.createTopic(request)
        return result.topicArn.toString()
    }
}
```
+  Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://sdk.amazonaws.com/kotlin/api/latest/index.html)à la section *AWS SDK pour la référence de l'API Kotlin*. 

------
#### [ PHP ]

**Kit SDK pour PHP**  
 Il y en a plus sur GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/sns#code-examples). 

```
require 'vendor/autoload.php';

use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;


/**
 * Create a Simple Notification Service topics in your AWS account at the requested region.
 *
 * This code expects that you have AWS credentials set up per:
 * https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
 */

$SnSclient = new SnsClient([
    'profile' => 'default',
    'region' => 'us-east-1',
    'version' => '2010-03-31'
]);

$topicname = 'myTopic';

try {
    $result = $SnSclient->createTopic([
        'Name' => $topicname,
    ]);
    var_dump($result);
} catch (AwsException $e) {
    // output error message if fails
    error_log($e->getMessage());
}
```
+  Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-managing-topics.html#create-a-topic). 
+  Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/CreateTopic)à la section *Référence des AWS SDK pour PHP API*. 

------
#### [ Python ]

**Kit SDK for Python (Boto3)**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/sns#code-examples). 

```
class SnsWrapper:
    """Encapsulates Amazon SNS topic and subscription functions."""

    def __init__(self, sns_resource):
        """
        :param sns_resource: A Boto3 Amazon SNS resource.
        """
        self.sns_resource = sns_resource


    def create_topic(self, name):
        """
        Creates a notification topic.

        :param name: The name of the topic to create.
        :return: The newly created topic.
        """
        try:
            topic = self.sns_resource.create_topic(Name=name)
            logger.info("Created topic %s with ARN %s.", name, topic.arn)
        except ClientError:
            logger.exception("Couldn't create topic %s.", name)
            raise
        else:
            return topic
```

```
class SnsWrapper:
    """Wrapper class for managing Amazon SNS operations."""

    def __init__(self, sns_client: Any) -> None:
        """
        Initialize the SnsWrapper.

        :param sns_client: A Boto3 Amazon SNS client.
        """
        self.sns_client = sns_client

    @classmethod
    def from_client(cls) -> 'SnsWrapper':
        """
        Create an SnsWrapper instance using a default boto3 client.

        :return: An instance of this class.
        """
        sns_client = boto3.client('sns')
        return cls(sns_client)


    def create_topic(
        self, 
        topic_name: str, 
        is_fifo: bool = False, 
        content_based_deduplication: bool = False
    ) -> str:
        """
        Create an SNS topic.

        :param topic_name: The name of the topic to create.
        :param is_fifo: Whether to create a FIFO topic.
        :param content_based_deduplication: Whether to use content-based deduplication for FIFO topics.
        :return: The ARN of the created topic.
        :raises ClientError: If the topic creation fails.
        """
        try:
            # Add .fifo suffix for FIFO topics
            if is_fifo and not topic_name.endswith('.fifo'):
                topic_name += '.fifo'

            attributes = {}
            if is_fifo:
                attributes['FifoTopic'] = 'true'
                if content_based_deduplication:
                    attributes['ContentBasedDeduplication'] = 'true'

            response = self.sns_client.create_topic(
                Name=topic_name,
                Attributes=attributes
            )

            topic_arn = response['TopicArn']
            logger.info(f"Created topic: {topic_name} with ARN: {topic_arn}")
            return topic_arn

        except ClientError as e:
            error_code = e.response.get('Error', {}).get('Code', 'Unknown')
            logger.error(f"Error creating topic {topic_name}: {error_code} - {e}")
            raise
```
+  Pour plus de détails sur l'API, consultez [CreateTopic](https://docs.aws.amazon.com/goto/boto3/sns-2010-03-31/CreateTopic)le *AWS manuel de référence de l'API SDK for Python (Boto3*). 

------
#### [ Ruby ]

**Kit SDK pour Ruby**  
 Il y en a plus sur GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/sns#code-examples). 

```
# This class demonstrates how to create an Amazon Simple Notification Service (SNS) topic.
class SNSTopicCreator
  # Initializes an SNS client.
  #
  # Utilizes the default AWS configuration for region and credentials.
  def initialize
    @sns_client = Aws::SNS::Client.new
  end

  # Attempts to create an SNS topic with the specified name.
  #
  # @param topic_name [String] The name of the SNS topic to create.
  # @return [Boolean] true if the topic was successfully created, false otherwise.
  def create_topic(topic_name)
    @sns_client.create_topic(name: topic_name)
    puts "The topic '#{topic_name}' was successfully created."
    true
  rescue Aws::SNS::Errors::ServiceError => e
    # Handles SNS service errors gracefully.
    puts "Error while creating the topic named '#{topic_name}': #{e.message}"
    false
  end
end

# Example usage:
if $PROGRAM_NAME == __FILE__
  topic_name = 'YourTopicName' # Replace with your topic name
  sns_topic_creator = SNSTopicCreator.new

  puts "Creating the topic '#{topic_name}'..."
  unless sns_topic_creator.create_topic(topic_name)
    puts 'The topic was not created. Stopping program.'
    exit 1
  end
end
```
+  Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/sns-example-create-topic.html). 
+  Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://docs.aws.amazon.com/goto/SdkForRubyV3/sns-2010-03-31/CreateTopic)à la section *Référence des AWS SDK pour Ruby API*. 

------
#### [ Rust ]

**SDK pour Rust**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/sns#code-examples). 

```
async fn make_topic(client: &Client, topic_name: &str) -> Result<(), Error> {
    let resp = client.create_topic().name(topic_name).send().await?;

    println!(
        "Created topic with ARN: {}",
        resp.topic_arn().unwrap_or_default()
    );

    Ok(())
}
```
+  Pour plus de détails sur l'API, voir [CreateTopic](https://docs.rs/aws-sdk-sns/latest/aws_sdk_sns/client/struct.Client.html#method.create_topic)la section de *référence de l'API AWS SDK for Rust*. 

------
#### [ SAP ABAP ]

**Kit SDK pour SAP ABAP**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/sns#code-examples). 

```
    TRY.
        oo_result = lo_sns->createtopic( iv_name = iv_topic_name ). " oo_result is returned for testing purposes. "
        MESSAGE 'SNS topic created' TYPE 'I'.
      CATCH /aws1/cx_snstopiclimitexcdex.
        MESSAGE 'Unable to create more topics. You have reached the maximum number of topics allowed.' TYPE 'E'.
    ENDTRY.
```
+  Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)à la section de référence du *AWS SDK pour l'API SAP ABAP*. 

------
#### [ Swift ]

**Kit SDK pour Swift**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/sns#code-examples). 

```
import AWSSNS

        let config = try await SNSClient.SNSClientConfiguration(region: region)
        let snsClient = SNSClient(config: config)

        let output = try await snsClient.createTopic(
            input: CreateTopicInput(name: name)
        )

        guard let arn = output.topicArn else {
            print("No topic ARN returned by Amazon SNS.")
            return
        }
```
+  Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://sdk.amazonaws.com/swift/api/awssns/latest/documentation/awssns/snsclient/createtopic(input:))à la section *AWS SDK pour la référence de l'API Swift*. 

------

**Note**  
Vous pouvez également utiliser une rubrique Amazon SNS appartenant à un autre compte, mais, dans ce cas, vous devrez créer une politique qui accorde des autorisations d'accès à AWS Config. Pour en savoir plus sur l'octroi d'autorisations à une rubrique Amazon SNS, consultez [Autorisations relatives à la rubrique Amazon SNS](sns-topic-policy.md), puis passez à [Étape 3 : Création d'un rôle IAM](#gs-cli-create-iamrole).

## Étape 3 : Création d'un rôle IAM
<a name="gs-cli-create-iamrole"></a>

**Important**  
**(Recommandé) Utiliser le rôle AWS Config lié au service**  
Il est recommandé d'utiliser le rôle AWS Config lié au service :. `AWSServiceRoleForConfig` Les rôles liés à un service sont prédéfinis et incluent toutes les autorisations nécessaires pour appeler AWS Config d'autres personnes. Services AWS Le rôle AWS Config lié à un service est requis pour les enregistreurs de configuration liés à un service.  
Pour de plus amples informations, veuillez consulter [Utilisation des rôles liés à un service pour AWS Config](https://docs.aws.amazon.com/config/latest/developerguide/using-service-linked-roles.html).

### Utilisation de la console IAM
<a name="create-iamrole"></a>

Vous pouvez utiliser la console IAM pour créer un rôle IAM qui accorde des AWS Config autorisations pour accéder à votre compartiment Amazon S3, accéder à votre rubrique Amazon SNS et obtenir les détails de configuration des ressources prises en charge. AWS Lorsque vous utilisez la console pour créer un rôle IAM, AWS Config attache automatiquement les autorisations requises au rôle pour vous. 

**Note**  
Si vous avez utilisé un AWS service qui utilise AWS Config (tel que AWS Security Hub ou AWS Control Tower) et qu'un AWS Config rôle a déjà été créé, vous devez vous assurer que le rôle IAM que vous utilisez lors de la configuration AWS Config conserve les mêmes privilèges minimaux que le AWS Config rôle déjà créé afin que l'autre AWS service continue de fonctionner comme prévu.   
Par exemple, si AWS Control Tower possède un rôle IAM qui permet de lire AWS Config les objets Amazon S3, vous devez garantir que les mêmes autorisations sont accordées dans le rôle IAM que vous utilisez lors de la configuration. AWS Config Dans le cas contraire, cela pourrait interférer avec les opérations de la tour de AWS contrôle.  
Pour plus d'informations sur les rôles IAM pour AWS Config, consultez [AWS Identity and Access Management](https://docs.aws.amazon.com/config/latest/developerguide/security-iam.html). 

**Pour créer un rôle pour un AWS service**

1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse.

1. Dans le volet de navigation de la console IAM, sélectionnez **Roles** (Rôles), puis **Create role** (Créer un rôle).

1. Pour **Sélectionner une entité de confiance**, choisissez **Service AWS **. 

1. Choisissez le cas d'utilisation que vous souhaitez pour AWS Config : **Config - Customizable**, **Config - Organizations**, **Config** ou **Config - Conformance Packs**. Ensuite, choisissez **Suivant**.

1. Sur la page **Nommer, vérifier et créer**, passez en revue les détails relatifs à votre rôle et choisissez **Créer un rôle**.

### En utilisant le AWS SDKs
<a name="create-iamrole-intro"></a>

Pour utiliser un AWS SDK, vous devez le configurer avec vos informations d'identification. Pour plus d'informations, consultez [la section Les fichiers de configuration et d'identification partagés](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) dans le *guide de référence AWS SDKs et Tools*.

Les exemples de code suivants illustrent comment utiliser `CreateRole`.

------
#### [ .NET ]

**SDK pour .NET**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/IAM#code-examples). 

```
    /// <summary>
    /// Create a new IAM role.
    /// </summary>
    /// <param name="roleName">The name of the IAM role.</param>
    /// <param name="rolePolicyDocument">The name of the IAM policy document
    /// for the new role.</param>
    /// <returns>The Amazon Resource Name (ARN) of the role.</returns>
    public async Task<string> CreateRoleAsync(string roleName, string rolePolicyDocument)
    {
        var request = new CreateRoleRequest
        {
            RoleName = roleName,
            AssumeRolePolicyDocument = rolePolicyDocument,
        };

        var response = await _IAMService.CreateRoleAsync(request);
        return response.Role.Arn;
    }
```
+  Pour plus de détails sur l'API, reportez-vous [CreateRole](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreateRole)à la section *Référence des AWS SDK pour .NET API*. 

------
#### [ Bash ]

**AWS CLI avec le script Bash**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/iam#code-examples). 

```
###############################################################################
# function errecho
#
# This function outputs everything sent to it to STDERR (standard error output).
###############################################################################
function errecho() {
  printf "%s\n" "$*" 1>&2
}

###############################################################################
# function iam_create_role
#
# This function creates an IAM role.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#       -p policy_json -- The assume role policy document.
#
# Returns:
#       The ARN of the role.
#     And:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_role() {
  local role_name policy_document response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_user_access_key"
    echo "Creates an AWS Identity and Access Management (IAM) role."
    echo "  -n role_name   The name of the IAM role."
    echo "  -p policy_json -- The assume role policy document."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      p) policy_document="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_document" ]]; then
    errecho "ERROR: You must provide a policy document with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam create-role \
    --role-name "$role_name" \
    --assume-role-policy-document "$policy_document" \
    --output text \
    --query Role.Arn)

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-role operation failed.\n$response"
    return 1
  fi

  echo "$response"

  return 0
}
```
+  Pour plus de détails sur l'API, reportez-vous [CreateRole](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreateRole)à la section *Référence des AWS CLI commandes*. 

------
#### [ C\$1\$1 ]

**SDK pour C\$1\$1**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/iam#code-examples). 

```
bool AwsDoc::IAM::createIamRole(
        const Aws::String &roleName,
        const Aws::String &policy,
        const Aws::Client::ClientConfiguration &clientConfig) {
    Aws::IAM::IAMClient client(clientConfig);
    Aws::IAM::Model::CreateRoleRequest request;

    request.SetRoleName(roleName);
    request.SetAssumeRolePolicyDocument(policy);

    Aws::IAM::Model::CreateRoleOutcome outcome = client.CreateRole(request);
    if (!outcome.IsSuccess()) {
        std::cerr << "Error creating role. " <<
                  outcome.GetError().GetMessage() << std::endl;
    }
    else {
        const Aws::IAM::Model::Role iamRole = outcome.GetResult().GetRole();
        std::cout << "Created role " << iamRole.GetRoleName() << "\n";
        std::cout << "ID: " << iamRole.GetRoleId() << "\n";
        std::cout << "ARN: " << iamRole.GetArn() << std::endl;
    }

    return outcome.IsSuccess();
}
```
+  Pour plus de détails sur l'API, reportez-vous [CreateRole](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreateRole)à la section *Référence des AWS SDK pour C\$1\$1 API*. 

------
#### [ CLI ]

**AWS CLI**  
**Exemple 1 : pour créer un rôle IAM**  
La commande `create-role` suivante crée un rôle nommé `Test-Role` et lui attache une politique d’approbation.  

```
aws iam create-role \
    --role-name Test-Role \
    --assume-role-policy-document file://Test-Role-Trust-Policy.json
```
Sortie :  

```
{
    "Role": {
        "AssumeRolePolicyDocument": "<URL-encoded-JSON>",
        "RoleId": "AKIAIOSFODNN7EXAMPLE",
        "CreateDate": "2013-06-07T20:43:32.821Z",
        "RoleName": "Test-Role",
        "Path": "/",
        "Arn": "arn:aws:iam::123456789012:role/Test-Role"
    }
}
```
La politique d’approbation est définie sous la forme d’un document JSON dans le fichier *Test-Role-Trust-Policy.json*. (Le nom et l’extension du fichier n’ont aucune importance.) La politique d’approbation doit spécifier un principal.  
Pour attacher une politique des autorisations à un rôle, utilisez la commande `put-role-policy`.  
Pour plus d’informations, consultez [Création de rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html) dans le *Guide de l’utilisateur AWS IAM*.  
**Exemple 2 : pour créer un rôle IAM avec une durée de session maximale spécifiée**  
La commande `create-role` suivante crée un rôle nommé `Test-Role` et définit une durée de session maximale de 7 200 secondes (2 heures).  

```
aws iam create-role \
    --role-name Test-Role \
    --assume-role-policy-document file://Test-Role-Trust-Policy.json \
    --max-session-duration 7200
```
Sortie :  

```
{
    "Role": {
        "Path": "/",
        "RoleName": "Test-Role",
        "RoleId": "AKIAIOSFODNN7EXAMPLE",
        "Arn": "arn:aws:iam::12345678012:role/Test-Role",
        "CreateDate": "2023-05-24T23:50:25+00:00",
        "AssumeRolePolicyDocument": {
            "Version":"2012-10-17",		 	 	 
            "Statement": [
                {
                    "Sid": "Statement1",
                    "Effect": "Allow",
                    "Principal": {
                        "AWS": "arn:aws:iam::12345678012:root"
                    },
                    "Action": "sts:AssumeRole"
                }
            ]
        }
    }
}
```
Pour plus d'informations, consultez la section [Modification de la durée maximale de session (AWS API) d'un rôle](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-api.html#roles-modify_max-session-duration-api) dans le *guide de l'utilisateur AWS IAM*.  
**Exemple 3 : pour créer un rôle IAM avec des balises**  
La commande suivante crée un rôle IAM `Test-Role` avec des balises. Cet exemple utilise l’indicateur de paramètre `--tags` avec les balises au format JSON suivantes : `'{"Key": "Department", "Value": "Accounting"}' '{"Key": "Location", "Value": "Seattle"}'`. L’indicateur `--tags` peut également être utilisé avec des balises au format raccourci : `'Key=Department,Value=Accounting Key=Location,Value=Seattle'`.  

```
aws iam create-role \
    --role-name Test-Role \
    --assume-role-policy-document file://Test-Role-Trust-Policy.json \
    --tags '{"Key": "Department", "Value": "Accounting"}' '{"Key": "Location", "Value": "Seattle"}'
```
Sortie :  

```
{
    "Role": {
        "Path": "/",
        "RoleName": "Test-Role",
        "RoleId": "AKIAIOSFODNN7EXAMPLE",
        "Arn": "arn:aws:iam::123456789012:role/Test-Role",
        "CreateDate": "2023-05-25T23:29:41+00:00",
        "AssumeRolePolicyDocument": {
            "Version":"2012-10-17",		 	 	 
            "Statement": [
                {
                    "Sid": "Statement1",
                    "Effect": "Allow",
                    "Principal": {
                        "AWS": "arn:aws:iam::123456789012:root"
                    },
                    "Action": "sts:AssumeRole"
                }
            ]
        },
        "Tags": [
            {
                "Key": "Department",
                "Value": "Accounting"
            },
            {
                "Key": "Location",
                "Value": "Seattle"
            }
        ]
    }
}
```
Pour plus d’informations, consultez [Étiquette de rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags_roles.html) dans le *Guide de l’utilisateur AWS IAM*.  
+  Pour plus de détails sur l'API, reportez-vous [CreateRole](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html)à la section *Référence des AWS CLI commandes*. 

------
#### [ Go ]

**Kit SDK pour Go V2**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/iam#code-examples). 

```
import (
	"context"
	"encoding/json"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
)

// RoleWrapper encapsulates AWS Identity and Access Management (IAM) role actions
// used in the examples.
// It contains an IAM service client that is used to perform role actions.
type RoleWrapper struct {
	IamClient *iam.Client
}



// CreateRole creates a role that trusts a specified user. The trusted user can assume
// the role to acquire its permissions.
// PolicyDocument shows how to work with a policy document as a data structure and
// serialize it to JSON by using Go's JSON marshaler.
func (wrapper RoleWrapper) CreateRole(ctx context.Context, roleName string, trustedUserArn string) (*types.Role, error) {
	var role *types.Role
	trustPolicy := PolicyDocument{
		Version: "2012-10-17",
		Statement: []PolicyStatement{{
			Effect:    "Allow",
			Principal: map[string]string{"AWS": trustedUserArn},
			Action:    []string{"sts:AssumeRole"},
		}},
	}
	policyBytes, err := json.Marshal(trustPolicy)
	if err != nil {
		log.Printf("Couldn't create trust policy for %v. Here's why: %v\n", trustedUserArn, err)
		return nil, err
	}
	result, err := wrapper.IamClient.CreateRole(ctx, &iam.CreateRoleInput{
		AssumeRolePolicyDocument: aws.String(string(policyBytes)),
		RoleName:                 aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't create role %v. Here's why: %v\n", roleName, err)
	} else {
		role = result.Role
	}
	return role, err
}
```
+  Pour plus de détails sur l'API, reportez-vous [CreateRole](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreateRole)à la section *Référence des AWS SDK pour Go API*. 

------
#### [ Java ]

**SDK pour Java 2.x**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/iam#code-examples). 

```
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import software.amazon.awssdk.services.iam.model.CreateRoleRequest;
import software.amazon.awssdk.services.iam.model.CreateRoleResponse;
import software.amazon.awssdk.services.iam.model.IamException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.iam.IamClient;
import java.io.FileReader;

/*
*   This example requires a trust policy document. For more information, see:
*   https://aws.amazon.com/blogs/security/how-to-use-trust-policies-with-iam-roles/
*
*
*  In addition, set up your development environment, including your credentials.
*
*  For information, see this documentation topic:
*
*  https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */

public class CreateRole {
    public static void main(String[] args) throws Exception {
        final String usage = """
                Usage:
                    <rolename> <fileLocation>\s

                Where:
                    rolename - The name of the role to create.\s
                    fileLocation - The location of the JSON document that represents the trust policy.\s
                """;

        if (args.length != 2) {
            System.out.println(usage);
            System.exit(1);
        }

        String rolename = args[0];
        String fileLocation = args[1];
        Region region = Region.AWS_GLOBAL;
        IamClient iam = IamClient.builder()
                .region(region)
                .build();

        String result = createIAMRole(iam, rolename, fileLocation);
        System.out.println("Successfully created user: " + result);
        iam.close();
    }

    public static String createIAMRole(IamClient iam, String rolename, String fileLocation) throws Exception {
        try {
            JSONObject jsonObject = (JSONObject) readJsonSimpleDemo(fileLocation);
            CreateRoleRequest request = CreateRoleRequest.builder()
                    .roleName(rolename)
                    .assumeRolePolicyDocument(jsonObject.toJSONString())
                    .description("Created using the AWS SDK for Java")
                    .build();

            CreateRoleResponse response = iam.createRole(request);
            System.out.println("The ARN of the role is " + response.role().arn());

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return "";
    }

    public static Object readJsonSimpleDemo(String filename) throws Exception {
        FileReader reader = new FileReader(filename);
        JSONParser jsonParser = new JSONParser();
        return jsonParser.parse(reader);
    }
}
```
+  Pour plus de détails sur l'API, reportez-vous [CreateRole](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreateRole)à la section *Référence des AWS SDK for Java 2.x API*. 

------
#### [ JavaScript ]

**SDK pour JavaScript (v3)**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/iam#code-examples). 
Créez le rôle.  

```
import { CreateRoleCommand, IAMClient } from "@aws-sdk/client-iam";

const client = new IAMClient({});

/**
 *
 * @param {string} roleName
 */
export const createRole = (roleName) => {
  const command = new CreateRoleCommand({
    AssumeRolePolicyDocument: JSON.stringify({
      Version: "2012-10-17",
      Statement: [
        {
          Effect: "Allow",
          Principal: {
            Service: "lambda.amazonaws.com",
          },
          Action: "sts:AssumeRole",
        },
      ],
    }),
    RoleName: roleName,
  });

  return client.send(command);
};
```
+  Pour plus de détails sur l'API, reportez-vous [CreateRole](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreateRoleCommand)à la section *Référence des AWS SDK pour JavaScript API*. 

------
#### [ PHP ]

**Kit SDK pour PHP**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/iam#code-examples). 

```
$uuid = uniqid();
$service = new IAMService();

$assumeRolePolicyDocument = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Principal\": {\"AWS\": \"{$user['Arn']}\"},
                    \"Action\": \"sts:AssumeRole\"
                }]
            }";
$assumeRoleRole = $service->createRole("iam_demo_role_$uuid", $assumeRolePolicyDocument);
echo "Created role: {$assumeRoleRole['RoleName']}\n";

    /**
     * @param string $roleName
     * @param string $rolePolicyDocument
     * @return array
     * @throws AwsException
     */
    public function createRole(string $roleName, string $rolePolicyDocument)
    {
        $result = $this->customWaiter(function () use ($roleName, $rolePolicyDocument) {
            return $this->iamClient->createRole([
                'AssumeRolePolicyDocument' => $rolePolicyDocument,
                'RoleName' => $roleName,
            ]);
        });
        return $result['Role'];
    }
```
+  Pour plus de détails sur l'API, reportez-vous [CreateRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateRole)à la section *Référence des AWS SDK pour PHP API*. 

------
#### [ PowerShell ]

**Outils pour PowerShell V4**  
**Exemple 1 : cet exemple crée un rôle nommé `MyNewRole` et y attache la politique trouvée dans le fichier `NewRoleTrustPolicy.json`. Notez que vous devez utiliser le paramètre booléen `-Raw` pour traiter correctement le fichier de politique JSON. Le document de politique affiché dans la sortie est codé en URL. Il est décodé dans cet exemple à l’aide de la méthode .NET `UrlDecode`.**  

```
$results = New-IAMRole -AssumeRolePolicyDocument (Get-Content -raw NewRoleTrustPolicy.json) -RoleName MyNewRole
$results
```
**Sortie** :  

```
Arn                      : arn:aws:iam::123456789012:role/MyNewRole
AssumeRolePolicyDocument : %7B%0D%0A%20%20%22Version%22%3A%20%222012-10-17%22%2C%0D%0A%20%20%22Statement%22
                           %3A%20%5B%0D%0A%20%20%20%20%7B%0D%0A%20%20%20%20%20%20%22Sid%22%3A%20%22%22%2C
                           %0D%0A%20%20%20%20%20%20%22Effect%22%3A%20%22Allow%22%2C%0D%0A%20%20%20%20%20%20
                           %22Principal%22%3A%20%7B%0D%0A%20%20%20%20%20%20%20%20%22AWS%22%3A%20%22arn%3Aaws
                           %3Aiam%3A%3A123456789012%3ADavid%22%0D%0A%20%20%20%20%20%20%7D%2C%0D%0A%20%20%20
                           %20%20%20%22Action%22%3A%20%22sts%3AAssumeRole%22%0D%0A%20%20%20%20%7D%0D%0A%20
                           %20%5D%0D%0A%7D
CreateDate               : 4/15/2015 11:04:23 AM
Path                     : /
RoleId                   : V5PAJI2KPN4EAEXAMPLE1
RoleName                 : MyNewRole

[System.Reflection.Assembly]::LoadWithPartialName("System.Web.HttpUtility")
[System.Web.HttpUtility]::UrlDecode($results.AssumeRolePolicyDocument)
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::123456789012:David"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
```
+  Pour plus de détails sur l'API, reportez-vous [CreateRole](https://docs.aws.amazon.com/powershell/v4/reference)à la section *Référence des Outils AWS pour PowerShell applets de commande (V4)*. 

**Outils pour PowerShell V5**  
**Exemple 1 : cet exemple crée un rôle nommé `MyNewRole` et y attache la politique trouvée dans le fichier `NewRoleTrustPolicy.json`. Notez que vous devez utiliser le paramètre booléen `-Raw` pour traiter correctement le fichier de politique JSON. Le document de politique affiché dans la sortie est codé en URL. Il est décodé dans cet exemple à l’aide de la méthode .NET `UrlDecode`.**  

```
$results = New-IAMRole -AssumeRolePolicyDocument (Get-Content -raw NewRoleTrustPolicy.json) -RoleName MyNewRole
$results
```
**Sortie** :  

```
Arn                      : arn:aws:iam::123456789012:role/MyNewRole
AssumeRolePolicyDocument : %7B%0D%0A%20%20%22Version%22%3A%20%222012-10-17%22%2C%0D%0A%20%20%22Statement%22
                           %3A%20%5B%0D%0A%20%20%20%20%7B%0D%0A%20%20%20%20%20%20%22Sid%22%3A%20%22%22%2C
                           %0D%0A%20%20%20%20%20%20%22Effect%22%3A%20%22Allow%22%2C%0D%0A%20%20%20%20%20%20
                           %22Principal%22%3A%20%7B%0D%0A%20%20%20%20%20%20%20%20%22AWS%22%3A%20%22arn%3Aaws
                           %3Aiam%3A%3A123456789012%3ADavid%22%0D%0A%20%20%20%20%20%20%7D%2C%0D%0A%20%20%20
                           %20%20%20%22Action%22%3A%20%22sts%3AAssumeRole%22%0D%0A%20%20%20%20%7D%0D%0A%20
                           %20%5D%0D%0A%7D
CreateDate               : 4/15/2015 11:04:23 AM
Path                     : /
RoleId                   : V5PAJI2KPN4EAEXAMPLE1
RoleName                 : MyNewRole

[System.Reflection.Assembly]::LoadWithPartialName("System.Web.HttpUtility")
[System.Web.HttpUtility]::UrlDecode($results.AssumeRolePolicyDocument)
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::123456789012:David"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
```
+  Pour plus de détails sur l'API, reportez-vous [CreateRole](https://docs.aws.amazon.com/powershell/v5/reference)à la section *Référence des Outils AWS pour PowerShell applets de commande (V5)*. 

------
#### [ Python ]

**Kit SDK for Python (Boto3)**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/iam#code-examples). 

```
def create_role(role_name, allowed_services):
    """
    Creates a role that lets a list of specified services assume the role.

    :param role_name: The name of the role.
    :param allowed_services: The services that can assume the role.
    :return: The newly created role.
    """
    trust_policy = {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
            {
                "Effect": "Allow",
                "Principal": {"Service": service},
                "Action": "sts:AssumeRole",
            }
            for service in allowed_services
        ],
    }

    try:
        role = iam.create_role(
            RoleName=role_name, AssumeRolePolicyDocument=json.dumps(trust_policy)
        )
        logger.info("Created role %s.", role.name)
    except ClientError:
        logger.exception("Couldn't create role %s.", role_name)
        raise
    else:
        return role
```
+  Pour plus de détails sur l'API, consultez [CreateRole](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreateRole)le *AWS manuel de référence de l'API SDK for Python (Boto3*). 

------
#### [ Ruby ]

**Kit SDK pour Ruby**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/iam#code-examples). 

```
  # Creates a role and attaches policies to it.
  #
  # @param role_name [String] The name of the role.
  # @param assume_role_policy_document [Hash] The trust relationship policy document.
  # @param policy_arns [Array<String>] The ARNs of the policies to attach.
  # @return [String, nil] The ARN of the new role if successful, or nil if an error occurred.
  def create_role(role_name, assume_role_policy_document, policy_arns)
    response = @iam_client.create_role(
      role_name: role_name,
      assume_role_policy_document: assume_role_policy_document.to_json
    )
    role_arn = response.role.arn

    policy_arns.each do |policy_arn|
      @iam_client.attach_role_policy(
        role_name: role_name,
        policy_arn: policy_arn
      )
    end

    role_arn
  rescue Aws::IAM::Errors::ServiceError => e
    @logger.error("Error creating role: #{e.message}")
    nil
  end
```
+  Pour plus de détails sur l'API, reportez-vous [CreateRole](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreateRole)à la section *Référence des AWS SDK pour Ruby API*. 

------
#### [ Rust ]

**SDK pour Rust**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples). 

```
pub async fn create_role(
    client: &iamClient,
    role_name: &str,
    role_policy_document: &str,
) -> Result<Role, iamError> {
    let response: CreateRoleOutput = loop {
        if let Ok(response) = client
            .create_role()
            .role_name(role_name)
            .assume_role_policy_document(role_policy_document)
            .send()
            .await
        {
            break response;
        }
    };

    Ok(response.role.unwrap())
}
```
+  Pour plus de détails sur l'API, voir [CreateRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_role)la section de *référence de l'API AWS SDK for Rust*. 

------
#### [ SAP ABAP ]

**Kit SDK pour SAP ABAP**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/iam#code-examples). 

```
    TRY.
        oo_result = lo_iam->createrole(
          iv_rolename = iv_role_name
          iv_assumerolepolicydocument = iv_assume_role_policy_document ).
        MESSAGE 'Role created successfully.' TYPE 'I'.
      CATCH /aws1/cx_iamentityalrdyexex.
        MESSAGE 'Role already exists.' TYPE 'E'.
      CATCH /aws1/cx_iammalformedplydocex.
        MESSAGE 'Assume role policy document is malformed.' TYPE 'E'.
      CATCH /aws1/cx_iamlimitexceededex.
        MESSAGE 'Role limit exceeded.' TYPE 'E'.
    ENDTRY.
```
+  Pour plus de détails sur l'API, reportez-vous [CreateRole](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)à la section de référence du *AWS SDK pour l'API SAP ABAP*. 

------
#### [ Swift ]

**Kit SDK pour Swift**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/iam#code-examples). 

```
import AWSIAM
import AWSS3


    public func createRole(name: String, policyDocument: String) async throws -> String {
        let input = CreateRoleInput(
            assumeRolePolicyDocument: policyDocument,
            roleName: name
        )
        do {
            let output = try await client.createRole(input: input)
            guard let role = output.role else {
                throw ServiceHandlerError.noSuchRole
            }
            guard let id = role.roleId else {
                throw ServiceHandlerError.noSuchRole
            }
            return id
        } catch {
            print("ERROR: createRole:", dump(error))
            throw error
        }
    }
```
+  Pour plus de détails sur l'API, reportez-vous [CreateRole](https://sdk.amazonaws.com/swift/api/awsiam/latest/documentation/awsiam/iamclient/createrole(input:))à la section *AWS SDK pour la référence de l'API Swift*. 

------

# En AWS Config commençant par un enregistreur de configuration géré par le client à l'aide du AWS CLI
<a name="gs-cli-subscribe"></a>

Vous pouvez commencer AWS Config par créer un enregistreur de configuration géré par le client. Pour créer un enregistreur de configuration géré par le client avec AWS CLI, utilisez les commandes suivantes : [https://docs.aws.amazon.com/cli/latest/reference/configservice/put-configuration-recorder.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/put-configuration-recorder.html), et [https://docs.aws.amazon.com/cli/latest/reference/configservice/start-configuration-recorder.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/start-configuration-recorder.html).
+ La `put-configuration-recorder` commande crée un enregistreur de configuration géré par le client.
+ La `put-delivery-channel` commande crée un canal de distribution qui AWS Config fournit des informations de configuration à un compartiment S3 et à une rubrique SNS.
+ `start-configuration-recorder`Démarre l'enregistreur de configuration géré par le client. L'enregistreur de configuration géré par le client commencera à enregistrer les modifications de configuration pour les types de ressources que vous spécifiez.

**Topics**
+ [

## Considérations
](#gs-cli-subscribe-considerations)
+ [

## Étape 1 : Exécutez le put-configuration-recorder
](#gs-cli-subscribe-put-configuration-recorder)
+ [

## Étape 2 : Exécuter la put-delivery-channel commande
](#gs-cli-subscribe-put-delivery-channel)
+ [

## Étape 3 : Exécuter la start-configuration-recorder commande
](#gs-cli-subscribe-start-configuration-recorder)

## Considérations
<a name="gs-cli-subscribe-considerations"></a>

**Un compartiment S3, une rubrique SNS et un rôle IAM sont requis**

Pour créer un enregistreur de configuration géré par le client, vous devez créer un compartiment S3, un sujet SNS et un rôle IAM avec des politiques associées comme conditions préalables. Pour configurer vos prérequis pour AWS Config, consultez la section [Conditions préalables](https://docs.aws.amazon.com/config/latest/developerguide/gs-cli-prereq.html).

**Un enregistreur de configuration géré par le client par compte et par région**

Vous ne pouvez avoir qu'un seul enregistreur de configuration géré par le client Compte AWS pour chacun d'entre eux Région AWS.

**Un canal de distribution par compte et par région**

Vous ne pouvez avoir qu'une seule région de canal de distribution Compte AWS pour chacun Région AWS.

**Politiques et résultats en matière de conformité**

Les [politiques IAM et les](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) [autres politiques gérées dans AWS Organizations](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies.html) peuvent avoir une incidence sur le AWS Config fait de disposer des autorisations nécessaires pour enregistrer les modifications de configuration de vos ressources. En outre, les règles évaluent directement la configuration d'une ressource et les règles ne tiennent pas compte de ces politiques lors de l'exécution des évaluations. Assurez-vous que les politiques en vigueur correspondent à la manière dont vous avez l'intention de les utiliser AWS Config.

## Étape 1 : Exécutez le put-configuration-recorder
<a name="gs-cli-subscribe-put-configuration-recorder"></a>

Utilisez la [https://docs.aws.amazon.com/cli/latest/reference/configservice/put-configuration-recorder.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/put-configuration-recorder.html)commande pour créer un enregistreur de configuration géré par le client :

Cette commande utilise les `---recording-group` champs `--configuration-recorder` et.

```
$ aws configservice put-configuration-recorder \
--configuration-recorder file://configurationRecorder.json \
--recording-group file://recordingGroup.json
```

**Le `configuration-recorder` terrain**

Le `configurationRecorder.json` fichier spécifie `name` et `roleArn` la fréquence d'enregistrement par défaut pour l'enregistreur de configuration (`recordingMode`). Vous pouvez également utiliser ce champ pour modifier la fréquence d'enregistrement pour des types de ressources spécifiques.

```
{
  "name": "default",
  "roleARN": "arn:aws:iam::123456789012:role/config-role",
  "recordingMode": {
    "recordingFrequency": CONTINUOUS or DAILY,
    "recordingModeOverrides": [ 
        { 
            "description": "Description you provide for the override",
            "recordingFrequency": CONTINUOUS or DAILY,
            "resourceTypes": [ Comma-separated list of resource types to include in the override ]
        }
    ]
  }
}
```

**Le `recording-group` terrain**

Le `recordingGroup.json` fichier indique quels types de ressources sont enregistrés.

```
{ 
    "allSupported": boolean,
    "exclusionByResourceTypes": { 
        "resourceTypes": [ Comma-separated list of resource types to exclude ]
    },
    "includeGlobalResourceTypes": boolean,
    "recordingStrategy": { 
        "useOnly": "Recording strategy for the configuration recorder"
    },
    "resourceTypes": [ Comma-separated list of resource types to include]
}
```

Pour plus d'informations sur ces champs, reportez-vous [https://docs.aws.amazon.com/cli/latest/reference/configservice/put-configuration-recorder.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/put-configuration-recorder.html)à la *référence des AWS CLI commandes*.

## Étape 2 : Exécuter la put-delivery-channel commande
<a name="gs-cli-subscribe-put-delivery-channel"></a>

Utilisez la [https://docs.aws.amazon.com/cli/latest/reference/configservice/put-delivery-channel.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/put-delivery-channel.html)commande pour créer un canal de diffusion :

Cette commande utilise le `--delivery-channel` champ.

```
$ aws configservice put-delivery-channel --delivery-channel file://deliveryChannel.json
```

**Le `delivery-channel` terrain**

Le `deliveryChannel.json` fichier spécifie les éléments suivants :
+ Le `name` pour le canal de diffusion.
+ Le `s3BucketName` where AWS Config envoie des instantanés de configuration.
+ Le « `snsTopicARN` where » AWS Config envoie des notifications
+ Le `configSnapshotDeliveryProperties` qui définit la fréquence à laquelle il AWS Config fournit des instantanés de configuration et la fréquence à laquelle il invoque des évaluations pour les règles périodiques.

```
{
    "name": "default",
    "s3BucketName": "config-bucket-123456789012",
    "snsTopicARN": "arn:aws:sns:us-east-1:123456789012:config-topic",
    "configSnapshotDeliveryProperties": {
        "deliveryFrequency": "Twelve_Hours"
    }
}
```

Pour plus d'informations sur ces champs, reportez-vous [https://docs.aws.amazon.com/cli/latest/reference/configservice/put-delivery-channel.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/put-delivery-channel.html)à la *référence des AWS CLI commandes*.

## Étape 3 : Exécuter la start-configuration-recorder commande
<a name="gs-cli-subscribe-start-configuration-recorder"></a>

Utilisez la [https://docs.aws.amazon.com/cli/latest/reference/configservice/start-configuration-recorder.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/start-configuration-recorder.html)commande pour démarrer AWS Config :

```
$ aws configservice start-configuration-recorder --configuration-recorder-name configRecorderName
```

Pour plus d'informations sur ces champs, reportez-vous [https://docs.aws.amazon.com/cli/latest/reference/configservice/start-configuration-recorder.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/start-configuration-recorder.html)à la *référence des AWS CLI commandes*.

# Vérifier que le démarrage AWS Config a bien été effectué à l'aide du AWS CLI
<a name="gs-cli-verify-subscribe"></a>

Après avoir démarré AWS Config, vous pouvez utiliser des AWS CLI commandes pour vérifier que le AWS Config est en cours d'exécution et que cela AWS Config a créé un enregistreur de configuration et un canal de diffusion. Vous pouvez également confirmer que AWS Config l'enregistrement et la transmission des configurations au canal de diffusion ont commencé.

**Topics**
+ [

## Étape 1 : vérifier qu'un canal de diffusion est créé
](#gs-cli-verify-channel)
+ [

## Étape 2 : Vérifiez qu'un enregistreur de configuration est créé
](#gs-cli-verify-recorder)
+ [

## Étape 3 : Vérifiez que l'enregistrement AWS Config a commencé
](#gs-cli-verify-config-recording)

## Étape 1 : vérifier qu'un canal de diffusion est créé
<a name="gs-cli-verify-channel"></a>

Utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/configservice/describe-delivery-channels.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/describe-delivery-channels.html) pour vérifier que votre compartiment Amazon S3 et votre rubrique Amazon SNS sont configurés.

Vous pouvez utiliser le `--delivery-channel-names` champ pour spécifier une liste de canaux de diffusion. Si aucun canal de diffusion n'est spécifié, cette commande renvoie les détails de tous les canaux de diffusion associés au compte.

```
$ aws configservice describe-delivery-channels
{
    "DeliveryChannels": [
        {
            "snsTopicARN": "arn:aws:sns:us-west-2:0123456789012:my-config-topic",
            "name": "my-delivery-channel",
            "s3BucketName": "my-config-bucket"
        }
    ]
}
```

## Étape 2 : Vérifiez qu'un enregistreur de configuration est créé
<a name="gs-cli-verify-recorder"></a>

Utilisez la [https://docs.aws.amazon.com/cli/latest/reference/configservice/describe-configuration-recorders.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/describe-configuration-recorders.html)commande pour vérifier qu'un enregistreur de configuration est créé.

Vous pouvez utiliser les `configuration-recorder-names` champs `arn` et pour spécifier une liste d'enregistreurs de configuration. Si aucun enregistreur de configuration n'est spécifié, cette commande renvoie les détails de tous les enregistreurs de configuration associés au compte.

```
$ aws configservice describe-configuration-recorders
{
    "ConfigurationRecorders": [
        {
            "roleARN": "arn:aws:iam::012345678912:role/myConfigRole",
            "name": "default"
        }
    ]
}
```

## Étape 3 : Vérifiez que l'enregistrement AWS Config a commencé
<a name="gs-cli-verify-config-recording"></a>

Utilisez la [https://docs.aws.amazon.com/cli/latest/reference/configservice/describe-configuration-recorder-status.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/describe-configuration-recorder-status.html)commande pour vérifier que l'enregistreur de configuration enregistre correctement les types de ressources concernés.

Vous pouvez utiliser les `configuration-recorder-names` champs `arn` et pour spécifier une liste d'enregistreurs de configuration. Si aucun enregistreur de configuration n'est spécifié, cette commande renvoie les détails de tous les enregistreurs de configuration associés au compte.

```
$ aws configservice describe-configuration-recorder-status
{
    "ConfigurationRecordersStatus": [
        {
            "name": "default",
            "lastStatus": "SUCCESS",
            "lastStopTime": 1414511624.914,
            "lastStartTime": 1414708460.276,
            "recording": true,
            "lastStatusChangeTime": 1414816537.148,
            "lastErrorMessage": "NA",
            "lastErrorCode": "400"
        }
    ]
}
```

La `true` valeur du `recording` champ confirme que l'enregistreur de configuration a commencé à enregistrer les configurations. AWS Config enregistre l'heure en UTC. La sortie est affichée sous forme d'horodatage Unix.