Étape 1 : Création d'un compartiment Amazon S3 Étape 2 : Création d'un SNS sujet Amazon Étape 3 : Création d'un IAM rôle

Conditions préalables à la configuration AWS Config avec le AWS CLI

Avant de procéder à la configuration AWS avec le AWS CLI, vous devez créer un compartiment Amazon S3, une SNS rubrique Amazon et un IAM rôle avec des politiques associées comme conditions préalables. Vous pouvez ensuite utiliser 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.

Rubriques

Étape 1 : Création d'un compartiment Amazon S3
Étape 2 : Création d'un SNS sujet Amazon
Étape 3 : Création d'un IAM rôle

Étape 1 : Création d'un compartiment Amazon S3

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'un SNS sujet Amazon.

Pour créer un compartiment

Ouvrez la console Amazon S3 à l'adresse https://console.aws.amazon.com/s3/.
Choisissez Créer un compartiment.
Dans Nom du compartiment, entrez un nom DNS compatible 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 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.
Dans Région, sélectionnez AWS Région dans laquelle vous souhaitez que le compartiment 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 d'Amazon S3 AWS Régions, voir AWS points de terminaison de service dans Référence générale d'Amazon Web Services.
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 dans le Guide de l'utilisateur Amazon Simple Storage Service.
(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.
2. 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 dans le Guide de l'utilisateur Amazon Simple Storage Service.
Choisissez Créer un compartiment.

Lorsque vous utilisez le AWS SDKspour créer un bucket, vous devez créer un client, puis utiliser le client pour envoyer une demande de création d'un bucket. La meilleure pratique consiste à créer votre client et votre bucket dans le même espace Région AWS. Si vous ne spécifiez pas de région lorsque vous créez un client ou un compartiment, Amazon S3 utilise la région USA Est (Virginie du Nord) 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 la section Points de terminaison à double pile Amazon S3. Pour une liste des produits disponibles Régions AWS, voir Régions et points de terminaison 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.

Ces AWS SDKles exemples de code exécutent les tâches suivantes :

Créez un client en spécifiant explicitement un Région AWS— Dans l'exemple, le client utilise le s3.us-west-2.amazonaws.com point de terminaison pour communiquer avec Amazon S3. Vous pouvez spécifier n'importe quel Région AWS. Pour une liste des Régions AWS, voir Régions et points de terminaison dans le AWS Référence générale.
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 montrent comment utiliserCreateBucket.

.NET

AWS SDK for .NET

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.



        /// <summary>
        /// Shows how to create a new Amazon S3 bucket.
        /// </summary>
        /// <param name="client">An initialized Amazon S3 client object.</param>
        /// <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 static async Task<bool> CreateBucketAsync(IAmazonS3 client, string bucketName)
        {
            try
            {
                var request = new PutBucketRequest
                {
                    BucketName = bucketName,
                    UseClientRegion = true,
                };

                var response = await client.PutBucketAsync(request);
                return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
            }
            catch (AmazonS3Exception ex)
            {
                Console.WriteLine($"Error creating bucket: '{ex.Message}'");
                return false;
            }
        }

Créez un compartiment avec le verrouillage des objets 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 API plus de détails, voir CreateBucketdans AWS SDK for .NET APIRéférence.

Bash

AWS CLI avec le script Bash

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


###############################################################################
# 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 API plus de détails, voir CreateBucketdans AWS CLI Référence de commande.

C++

SDKpour C++

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


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 API plus de détails, voir CreateBucketdans AWS SDK for C++ APIRéférence.

CLI

AWS CLI

Exemple 1 : pour créer un bucket

L'create-bucketexemple suivant crée un compartiment nommé my-bucket :


aws s3api create-bucket \
    --bucket my-bucket \
    --region us-east-1

Sortie :


{
    "Location": "/my-bucket"
}

Pour plus d'informations, consultez la section Création d'un compartiment dans le guide de l'utilisateur Amazon S3.

Exemple 2 : pour créer un bucket avec l'obligation du propriétaire

L'create-bucketexemple suivant crée un bucket nommé my-bucket qui utilise le paramètre imposé par le propriétaire du bucket pour S3 Object Ownership.


aws s3api create-bucket \
    --bucket my-bucket \
    --region us-east-1 \
    --object-ownership BucketOwnerEnforced

Sortie :


{
    "Location": "/my-bucket"
}

Pour plus d'informations, consultez la section Contrôle de la propriété des objets et désactivation ACLs dans le guide de l'utilisateur Amazon S3.

Exemple 3 : Pour créer un bucket en dehors de la région ``us-east-1``

L'create-bucketexemple suivant crée un compartiment nommé my-bucket dans la eu-west-1 région. Les régions situées en dehors de us-east-1 doivent être spécifiées afin de créer le compartiment dans la région souhaitée. LocationConstraint


aws s3api create-bucket \
    --bucket my-bucket \
    --region eu-west-1 \
    --create-bucket-configuration LocationConstraint=eu-west-1

Sortie :


{
    "Location": "http://my-bucket.s3.amazonaws.com/"
}

Pour plus d'informations, consultez la section Création d'un compartiment dans le guide de l'utilisateur Amazon S3.

Pour API plus de détails, voir CreateBucketdans AWS CLI Référence de commande.

Go

SDKpour Go V2

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.

Créez un bucket avec la configuration par défaut.



// 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(name string, region string) error {
	_, err := basics.S3Client.CreateBucket(context.TODO(), &s3.CreateBucketInput{
		Bucket: aws.String(name),
		CreateBucketConfiguration: &types.CreateBucketConfiguration{
			LocationConstraint: types.BucketLocationConstraint(region),
		},
	})
	if err != nil {
		log.Printf("Couldn't create bucket %v in Region %v. Here's why: %v\n",
			name, region, err)
	}
	return err
}

Créez un compartiment avec verrouillage d'objets et attendez qu'il existe.



// 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 API plus de détails, voir CreateBucketdans AWS SDK for Go APIRéférence.

Java

SDKpour Java 2.x

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.

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 des objets 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 API plus de détails, voir CreateBucketdans AWS SDK for Java 2.x APIRéférence.

JavaScript

SDKpour JavaScript (v3)

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.

Créer le compartiment.


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

const client = new S3Client({});

export const main = async () => {
  const command = 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: "bucket-name",
  });

  try {
    const { Location } = await client.send(command);
    console.log(`Bucket created with location ${Location}`);
  } catch (err) {
    console.error(err);
  }
};

Pour plus d’informations, consultez .AWS SDK for JavaScript Guide du développeur.
Pour API plus de détails, voir CreateBucketdans AWS SDK for JavaScript APIRéférence.

Kotlin

SDKpour Kotlin

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


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

    S3Client { region = "us-east-1" }.use { s3 ->
        s3.createBucket(request)
        println("$bucketName is ready")
    }
}

Pour API plus de détails, voir CreateBucketdans AWS SDKpour API référence à Kotlin.

PHP

SDK pour PHP

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.

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 API plus de détails, voir CreateBucketdans AWS SDK for PHP APIRéférence.

Python

SDKpour Python (Boto3)

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.

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 API plus de détails, voir CreateBucketdans AWS SDKpour Python (Boto3) Reference. API

Ruby

SDKpour Ruby

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


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("doc-example-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 API plus de détails, voir CreateBucketdans AWS SDK for Ruby APIRéférence.

Rust

SDKpour Rust

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


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 API plus de détails, voir CreateBucketdans AWS SDKpour API référence à Rust.

SAP ABAP

SDKpour SAP ABAP

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


    TRY.
        lo_s3->createbucket(
            iv_bucket = iv_bucket_name
        ).
        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 API plus de détails, voir CreateBucketdans AWS SDKà titre SAP ABAP API de référence.

Swift

SDKpour Swift

Note

Il s'agit de la documentation d'avant-première d'une SDK version préliminaire. Elle est susceptible d’être modifiée.

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


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 API plus de détails, voir CreateBucketdans AWS SDKpour API référence à Swift.

Note

Vous pouvez également utiliser un compartiment Amazon S3 provenant 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 plus d'informations sur l'octroi d'autorisations à un compartiment Amazon S3Autorisations pour le compartiment Amazon S3 pour AWS Config Canal de livraison, consultez, puis rendez-vous surÉtape 2 : Création d'un SNS sujet Amazon.

Étape 2 : Création d'un SNS sujet Amazon

Si vous avez déjà un SNS sujet Amazon dans votre compte et que vous souhaitez l'utiliser, ignorez cette étape et passez àÉtape 3 : Création d'un IAM rôle.

Pour créer un SNS sujet Amazon

Ouvrez la SNS console Amazon sur https://console.aws.amazon.com/sns/v3/home.
Effectuez l’une des actions suivantes :
- Si aucun sujet n'a jamais été créé sous votre Compte AWS avant, lisez la description d'Amazon SNS sur la page d'accueil.
- Si des sujets ont été créés sous votre Compte AWS avant, dans le panneau de navigation, de sélectionner Sujets.
Sur la page Rubriques, choisissez Créer une rubrique.
Sur la page Créer une rubrique, dans la section Détails, procédez comme suit :
1. Pour Type, choisissez un type de sujet (Standard ou FIFO).
2. Entrez un Nom pour la rubrique. Pour un FIFOsujet, ajoutez .fifo à la fin du nom.
3. (Facultatif) Entrez un Nom d'affichage pour votre rubrique.
4. (Facultatif) Pour un FIFO sujet, vous pouvez choisir la déduplication des messages basée sur le contenu pour activer la déduplication des messages par défaut. Pour plus d'informations, voir Déduplication des messages pour les FIFO rubriques.
(Facultatif) Développez la section Chiffrement et effectuez les opérations suivantes. Pour plus d'informations, consultez Chiffrement au repos.
1. Choisissez Activer le chiffrement.
2. Spécifiez la clé principale du client (CMK). Pour plus d'informations, veuillez consulter la rubrique Termes clés.
  
  Pour chaque CMK type, la description, le compte et le numéro CMKARN1 sont affichés.
  
  Important
  Si vous n'êtes pas le propriétaire duCMK, ou si vous vous connectez avec un compte ne disposant pas des kms:DescribeKey autorisations kms:ListAliases et, vous ne pourrez pas consulter les informations le concernant CMK sur la SNS console Amazon.
  Demandez au propriétaire de vous CMK accorder ces autorisations. Pour de plus amples informations, veuillez consulter le .AWS KMS APIAutorisations : référence aux actions et aux ressources dans le AWS Key Management Service Guide du développeur.
  - Le AWS géré CMK pour Amazon SNS (par défaut) alias/aws/sns est sélectionné par défaut.
    Note
    Gardez à l'esprit les points suivants :
    
    La première fois que vous utilisez AWS Management Console pour spécifier le AWS géré CMK pour Amazon SNS pour un sujet, AWS KMS crée le AWS géré CMK pour AmazonSNS.
    
    Sinon, la première fois que vous utilisez l'Publishaction sur un sujet SSE activé, AWS KMS crée le AWS géré CMK pour AmazonSNS.
  - Pour utiliser une personnalisation CMK de votre Compte AWS, choisissez le champ Clé principale du client (CMK), puis sélectionnez le paramètre personnalisé CMK dans la liste.
    
    Note
    Pour obtenir des instructions sur la création de clés personnaliséesCMKs, consultez la section Création de clés dans AWS Key Management Service Guide du développeur
  - Pour utiliser une personnalisation CMK ARN de votre Compte AWS ou d'un autre AWS compte, saisissez-le dans le champ Clé principale du client (CMK).
(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 sur Amazon SNS et Exemples de cas pour le contrôle SNS d'accès Amazon.

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.
(Facultatif) Pour configurer la manière dont Amazon SNS tente à nouveau les tentatives de livraison de messages ayant échoué, développez la section Politique de nouvelles tentatives de livraison (HTTP/S). Pour plus d'informations, consultez la section Rétentatives de livraison des SNS messages Amazon.
(Facultatif) Pour configurer la manière dont Amazon SNS enregistre l'envoi des messages CloudWatch, développez la section Enregistrement du statut de livraison. Pour plus d'informations, consultez l'état de livraison des SNS messages Amazon.
(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 la section Balisage des SNS rubriques Amazon.
Choisissez Créer une rubrique.

Le sujet est créé et MyTopicla page s'affiche.

Le nom du sujet ARN, le nom d'affichage (facultatif) et le nom du propriétaire du sujet AWS L'identifiant du compte est affiché dans la section Détails.
Copiez le sujet ARN dans le presse-papiers, par exemple :
```
arn:aws:sns:us-east-2:123456789012:MyTopic
```

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

Ouvrez la SNS console Amazon sur https://console.aws.amazon.com/sns/v3/home.
Dans le volet de navigation de gauche, choisissez Abonnements.
Sur la page Abonnements, choisissez Créer un abonnement.
Sur la page Créer un abonnement, dans la section Détails, procédez comme suit :
1. Pour le sujet ARN, choisissez le nom de la ressource Amazon (ARN) d'un sujet.
2. Pour Protocole, choisissez un type de point de terminaison. Les types de point de terminaison disponibles sont les suivants :
  - HTTP/HTTPS
  - Courriel/E-Mail- JSON
  - Amazon Data Firehose
  - Amazon SQS
    
    Note
    Pour vous abonner à un SNSFIFOsujet, choisissez cette option.
  - AWS Lambda
  - Point de terminaison de l'application de plateforme
  - SMS
3. Pour Endpoint, entrez la valeur du point de terminaison, telle qu'une adresse e-mail ou celle ARN d'une SQS file d'attente Amazon.
4. Points de terminaison Firehose uniquement : pour le rôle d'abonnement ARN, spécifiez le ARN IAM rôle 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
5. (Facultatif) Pour les points de terminaison FirehoseSQS, Amazon, HTTP /S, vous pouvez également activer la livraison de messages bruts. Pour plus d'informations, consultez Amazon SNS Raw Message Delivery.
6. (Facultatif) Pour configurer une politique de filtre, développez la section Politique de filtre d'abonnement. Pour plus d'informations, consultez les politiques de filtrage des SNS abonnements Amazon.
7. (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 Amazon SNS dead-letter queues (). DLQs
8. Choisissez Create subscription (Créer un abonnement).
  
  La console crée l'abonnement et ouvre la page Détails de l’abonnement.

Pour utiliser un AWS SDK, vous devez le configurer avec vos informations d'identification. Pour plus d'informations, voir Les fichiers de configuration et d'informations d'identification partagés dans le AWS SDKset guide de référence sur les outils.

Les exemples de code suivants montrent comment utiliserCreateTopic.

.NET

AWS SDK for .NET

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.

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 un nouveau sujet avec un nom et des attributs spécifiques FIFO et de déduplication.


    /// <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 API plus de détails, voir CreateTopicdans AWS SDK for .NET APIRéférence.

C++

SDKpour C++

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


//! 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 API plus de détails, voir CreateTopicdans AWS SDK for C++ APIRéférence.

CLI

AWS CLI

Pour créer une rubrique SNS

L'create-topicexemple suivant crée une SNS rubrique nomméemy-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, voir Utilisation du AWS Interface de ligne de commande avec Amazon SQS et Amazon SNS dans le AWS Guide de l'utilisateur de l'interface de ligne de commande.

Pour API plus de détails, voir CreateTopicdans AWS CLI Référence de commande.

Go

SDKpour Go V2

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.



// 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(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(context.TODO(), &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 API plus de détails, voir CreateTopicdans AWS SDK for Go APIRéférence.

Java

SDKpour Java 2.x

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


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 API plus de détails, voir CreateTopicdans AWS SDK for Java 2.x APIRéférence.

JavaScript

SDKpour JavaScript (v3)

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.

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 SDK les modules client et appelez leAPI.


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 .AWS SDK for JavaScript Guide du développeur.
Pour API plus de détails, voir CreateTopicdans AWS SDK for JavaScript APIRéférence.

Kotlin

SDKpour Kotlin

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


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

    SnsClient { region = "us-east-1" }.use { snsClient ->
        val result = snsClient.createTopic(request)
        return result.topicArn.toString()
    }
}

Pour API plus de détails, voir CreateTopicdans AWS SDKpour API référence à Kotlin.

PHP

SDK pour PHP

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


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 .AWS SDK for PHP Guide du développeur.
Pour API plus de détails, voir CreateTopicdans AWS SDK for PHP APIRéférence.

Python

SDKpour Python (Boto3)

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


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

Pour API plus de détails, voir CreateTopicdans AWS SDKpour Python (Boto3) Reference. API

Ruby

SDKpour Ruby

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


# 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 .AWS SDK for Ruby Guide du développeur.
Pour API plus de détails, voir CreateTopicdans AWS SDK for Ruby APIRéférence.

Rust

SDKpour Rust

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


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 API plus de détails, voir CreateTopicdans AWS SDKpour API référence à Rust.

SAP ABAP

SDKpour SAP ABAP

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


    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 API plus de détails, voir CreateTopicdans AWS SDKà titre SAP ABAP API de référence.

Note

Vous pouvez également utiliser un SNS sujet Amazon dans un autre compte, mais dans ce cas, vous devrez peut-être créer une politique pour le sujet qui accorde des autorisations d'accès à AWS Config. Pour plus d'informations sur l'octroi d'autorisations pour un SNS sujet Amazon, consultez Autorisations pour le SNS sujet Amazon puis rendez-vous surÉtape 3 : Création d'un IAM rôle.

Étape 3 : Création d'un IAM rôle

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

Note

Si vous avez utilisé un AWS service qui utilise AWS Config (tels que AWS Security Hub ou AWS Control Tower) et un AWS Config le rôle a déjà été créé, vous devez vous assurer que le IAM rôle que vous utilisez lors de la configuration AWS Config conserve les mêmes privilèges minimaux que ceux déjà créés AWS Config rôle dans l'ordre de l'autre AWS le service doit continuer à fonctionner comme prévu.

Par exemple, si AWS Control Tower a un IAM rôle qui permet AWS Config pour lire les objets Amazon S3, vous devez vous assurer que les mêmes autorisations sont accordées dans le IAM rôle que vous utilisez lors de la configuration AWS Config. Dans le cas contraire, cela pourrait interférer avec AWS Les opérations de la tour de contrôle.

Pour plus d'informations sur IAM les rôles pour AWS Config, voir AWS Identity and Access Management.

Pour créer un rôle pour un AWS web

Connectez-vous au AWS Management Console et ouvrez la IAM console à l'adresse https://console.aws.amazon.com/iam/.
Dans le volet de navigation de la IAM console, sélectionnez Rôles, puis sélectionnez Créer un rôle.
Pour Sélectionner une entité de confiance, sélectionnez AWS service.
Choisissez le cas d'utilisation que vous souhaitez AWS Config: Config - Personnalisable, Config - Organizations, Config ou Config - Packs de conformité. Ensuite, choisissez Suivant.
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.

Les exemples de code suivants montrent comment utiliserCreateRole.

.NET

AWS SDK for .NET

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


    /// <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 API plus de détails, voir CreateRoledans AWS SDK for .NET APIRéférence.

Bash

AWS CLI avec le script Bash

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


###############################################################################
# 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 API plus de détails, voir CreateRoledans AWS CLI Référence de commande.

C++

SDKpour C++

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


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 API plus de détails, voir CreateRoledans AWS SDK for C++ APIRéférence.

CLI

AWS CLI

Exemple 1 : pour créer un IAM rôle

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 de confiance est définie sous forme de JSON document 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 la section Création de IAM rôles dans le AWS IAM Guide de l’utilisateur.

Exemple 2 : pour créer un IAM rôle 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, voir Modification de la durée maximale de session d'un rôle (AWS API) dans le AWS IAM Guide de l’utilisateur.

Exemple 3 : pour créer un IAM rôle avec des balises

La commande suivante crée un IAM rôle Test-Role avec des balises. Cet exemple utilise l'indicateur de --tags paramètre avec les balises au JSON format 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 la section Marquage IAM des rôles dans le AWS IAM Guide de l’utilisateur.

Pour API plus de détails, voir CreateRoledans AWS CLI Référence de commande.

Go

SDKpour Go V2

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.



// 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(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(context.TODO(), &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 API plus de détails, voir CreateRoledans AWS SDK for Go APIRéférence.

Java

SDKpour Java 2.x

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


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 API plus de détails, voir CreateRoledans AWS SDK for Java 2.x APIRéférence.

JavaScript

SDKpour JavaScript (v3)

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.

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 API plus de détails, voir CreateRoledans AWS SDK for JavaScript APIRéférence.

PHP

SDK pour PHP

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


$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 API plus de détails, voir CreateRoledans AWS SDK for PHP APIRéférence.

PowerShell

Outils pour PowerShell

Exemple 1 : Cet exemple crée un nouveau rôle nommé MyNewRole et y attache la politique trouvée dans le fichierNewRoleTrustPolicy.json. Notez que vous devez utiliser le paramètre -Raw switch pour traiter correctement le fichier JSON de régulation. Le document de politique affiché dans la sortie est URL codé. Il est décodé dans cet exemple avec leUrlDecode. NETméthode.


$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 API plus de détails, voir CreateRoledans AWS Tools for PowerShell Référence de l'applet de commande.

Python

SDKpour Python (Boto3)

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


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 API plus de détails, voir CreateRoledans AWS SDKpour Python (Boto3) Reference. API

Ruby

SDKpour Ruby

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


  # 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 API plus de détails, voir CreateRoledans AWS SDK for Ruby APIRéférence.

Rust

SDKpour Rust

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


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 API plus de détails, voir CreateRoledans AWS SDKpour API référence à Rust.

Swift

SDKpour Swift

Note

Il s'agit de la documentation d'avant-première d'une SDK version préliminaire. Elle est susceptible d’être modifiée.

Note

Il y en a plus à ce sujet GitHub. Consultez l'exemple complet et apprenez à configurer et à exécuter dans AWS Référentiel d'exemples de code.


import AWSIAM

    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 {
            throw error
        }
    }

Pour API plus de détails, voir CreateRoledans AWS SDKpour API référence à Swift.

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

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

Conventions de rédaction

Configuration (AWS CLI)

Démarrage en cours AWS Config

Conditions préalables à la configuration AWS Config avec le AWS CLI

Rubriques

Étape 1 : Création d'un compartiment Amazon S3

Pour créer un compartiment

Important

Important

Note

Note

Note

Note

Note

Note

Note

Note

Note

Note

Note

Note

Note

Note

Note

Étape 2 : Création d'un SNS sujet Amazon

Pour créer un SNS sujet Amazon

Important

Note

Note

Note

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

Note

Note

Note

Note

Note

Note

Note

Note

Note

Note

Note

Note

Note

Étape 3 : Création d'un IAM rôle

Note

Pour créer un rôle pour un AWS web

Note

Note

Note

Note

Note

Note

Note

Note

Note

Note

Note

Note