Prerequisiti - AWS Config
Creazione di un bucket Amazon S3Creazione di un argomento Amazon SNSCreazione di un ruolo IAM

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Prerequisiti

Prima di eseguire la configurazione AWS con AWS CLI, devi creare un bucket Amazon S3, un argomento Amazon SNS e un ruolo IAM con policy allegate come prerequisiti. Puoi quindi utilizzare il AWS CLI per specificare il bucket, l'argomento e il ruolo per. AWS Config Segui questa procedura per configurare i prerequisiti per AWS Config.

Creazione di un bucket Amazon S3

Se disponi già di un bucket Amazon S3 nell'account e desideri utilizzarlo, puoi ignorare questo passaggio e passare direttamente a Creazione di un argomento Amazon SNS.

Per creare un bucket

  1. Apri la console Amazon S3 all'indirizzo https://console.aws.amazon.com/s3/.

  2. Seleziona Crea bucket.

  3. In Bucket name (Nome bucket), immettere un nome conforme a DNS per il bucket.

    Il nome del bucket deve:

    • Essere univoco in tutto Amazon S3.

    • Deve contenere da 3 a 63 caratteri

    • Non contiene caratteri maiuscoli.

    • Iniziare con una lettera minuscola o un numero.

    Una volta creato il bucket, non è possibile modificarne il nome. Assicurati che il nome assegnato al bucket sia univoco tra tutti i nomi di bucket esistenti in Amazon S3. Per ulteriori informazioni sulle regole e le convenzioni di denominazione dei bucket, consulta Restrizioni e limitazioni dei bucket nella Guida per l'utente di Amazon Simple Storage Service.

    Importante

    Evita di includere informazioni sensibili nel nome del bucket. Il nome bucket è visibile nell'URL che punta agli oggetti nel bucket.

  4. In Regione, scegli la AWS regione in cui desideri che risieda il bucket.

    Scegliere una regione nelle vicinanze per ridurre al minimo la latenza e i costi o rispondere a requisiti normativi. Gli oggetti archiviati in una regione non la lasciano mai a meno che non vengano trasferiti esplicitamente in un'altra regione. Per un elenco delle AWS regioni Amazon S3, consulta gli endpoint AWS di servizio nel. Riferimenti generali di Amazon Web Services

  5. In Bucket settings for Block Public Access (Impostazioni bucket per blocco dell'accesso pubblico), scegliere le impostazioni del blocco dell'accesso pubblico che si desidera applicare al bucket.

    Si consiglia di lasciare tutte le impostazioni abilitate, a meno che non si sappia che è necessario disattivarne una o più per il caso d'uso, ad esempio per ospitare un sito Web pubblico. Le impostazioni di blocco dell'accesso pubblico abilitate per il bucket saranno abilitate anche per tutti i punti di accesso creati nel bucket. Per ulteriori informazioni sul blocco dell'accesso pubblico, consulta Blocco dell’accesso pubblico di Amazon S3 nella Guida per l'utente di Amazon Simple Storage Service.

  6. (Facoltativo) Se si desidera abilitare il Blocco degli oggetti S3:

    1. Scegliere Advanced settings (Impostazioni avanzate) e leggere il messaggio visualizzato.

      Importante

      È possibile abilitare il blocco oggetti S3 per un bucket solo quando lo si crea. Se si abilita il blocco oggetti per il bucket, non è possibile disabilitarlo in un secondo momento. L'abilitazione del blocco oggetti consente anche la funzione Versioni multiple del bucket. Dopo aver abilitato il blocco oggetti per il bucket, è necessario configurare le impostazioni di blocco oggetti prima che tutti gli oggetti nel bucket vengano protetti. Per ulteriori informazioni sulla configurazione della protezione per gli oggetti, consulta Configurazione di Object Lock S3 utilizzando la console Amazon S3.

    2. Se si desidera abilitare il blocco oggetti, immettere abilita nella casella di testo e scegliere Confirm (Conferma).

    Per ulteriori informazioni sulla funzionalità Object Lock S3, consulta Utilizzo di Object Lock S3 nella Guida per l'utente di Amazon Simple Storage Service.

  7. Seleziona Crea bucket.

Quando utilizzi gli AWS SDK per creare un bucket, devi creare un client e quindi utilizzare il client per inviare una richiesta di creazione di un bucket. Come best practice, crea il client e il bucket nella stessa Regione AWS. Se non specifichi una regione quando crei un client o un bucket, Amazon S3 utilizza la regione predefinita Stati Uniti orientali (Virginia settentrionale).

Per creare un client per accedere a un endpoint dual-stack, devi specificare un. Regione AWS Per ulteriori informazioni, consulta Endpoint dual-stack Amazon S3. Per un elenco di quelli disponibili Regioni AWS, consulta Regioni ed endpoint in. Riferimenti generali di AWS

Quando si crea un client, la regione viene mappata all'endpoint specifico della regione. Il client utilizza questo endpoint per comunicare con Amazon S3: s3.<region>.amazonaws.com. Se la tua regione è stata lanciata dopo il 20 marzo 2019, il tuo client e il tuo bucket devono trovarsi nella stessa regione. Puoi comunque utilizzare un client nella regione Stati Uniti orientali (Virginia settentrionale) per creare un bucket in qualsiasi regione lanciata prima del 20 marzo 2019. Per ulteriori informazioni, consulta Endpoint legacy.

Questi esempi di codice AWS SDK eseguono le seguenti attività:

  • Creazione di un client specificando esplicitamente una Regione AWS - Nell'esempio, il client utilizza l'endpoint s3.us-west-2.amazonaws.com per comunicare con Amazon S3. Puoi specificare qualsiasi Regione AWS. Per un elenco di Regioni AWS, consulta Regioni ed endpoint nel Riferimento AWS generale.

  • Inviare una richiesta di creazione di bucket specificando solo il nome del bucket - Il client invia ad Amazon S3 la richiesta di creare il bucket nella regione in cui hai creato un client.

  • Recupero delle informazioni sulla posizione del bucket - Amazon S3 memorizza le informazioni sulla posizione del bucket nella risorsa secondaria posizione associata al bucket.

Java

Questo esempio mostra come creare un bucket Amazon S3 utilizzando la AWS SDK for Java. Per istruzioni su come creare e testare un esempio di utilizzo, consulta Test degli esempi di codice Java di Amazon S3. 


import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.CreateBucketRequest;
import com.amazonaws.services.s3.model.GetBucketLocationRequest;

import java.io.IOException;

public class CreateBucket2 {

    public static void main(String[] args) throws IOException {
        Regions clientRegion = Regions.DEFAULT_REGION;
        String bucketName = "*** Bucket name ***";

        try {
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .withCredentials(new ProfileCredentialsProvider())
                    .withRegion(clientRegion)
                    .build();

            if (!s3Client.doesBucketExistV2(bucketName)) {
                // Because the CreateBucketRequest object doesn't specify a region, the
                // bucket is created in the region specified in the client.
                s3Client.createBucket(new CreateBucketRequest(bucketName));

                // Verify that the bucket was created by retrieving it and checking its
                // location.
                String bucketLocation = s3Client.getBucketLocation(new GetBucketLocationRequest(bucketName));
                System.out.println("Bucket location: " + bucketLocation);
            }
        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process
            // it and returned an error response.
            e.printStackTrace();
        } catch (SdkClientException e) {
            // Amazon S3 couldn't be contacted for a response, or the client
            // couldn't parse the response from Amazon S3.
            e.printStackTrace();
        }
    }
}
.NET

Per informazioni su come creare e testare un esempio di utilizzo, consulta Esecuzione degli esempi di codice .NET di Amazon S3.

using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using Amazon.S3.Util;
using System;
using System.Threading.Tasks;

namespace Amazon.DocSamples.S3
{
    class CreateBucketTest
    {
        private const string bucketName = "*** bucket name ***";
        // Specify your bucket region (an example region is shown).
        private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
        private static IAmazonS3 s3Client;
        public static void Main()
        {
            s3Client = new AmazonS3Client(bucketRegion);
            CreateBucketAsync().Wait();
        }

        static async Task CreateBucketAsync()
        {
            try
            {
                if (!(await AmazonS3Util.DoesS3BucketExistAsync(s3Client, bucketName)))
                {
                    var putBucketRequest = new PutBucketRequest
                    {
                        BucketName = bucketName,
                        UseClientRegion = true
                    };

                    PutBucketResponse putBucketResponse = await s3Client.PutBucketAsync(putBucketRequest);
                }
                // Retrieve the bucket location.
                string bucketLocation = await FindBucketLocationAsync(s3Client);
            }
            catch (AmazonS3Exception e)
            {
                Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
            }
            catch (Exception e)
            {
                Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
            }
        }
        static async Task<string> FindBucketLocationAsync(IAmazonS3 client)
        {
            string bucketLocation;
            var request = new GetBucketLocationRequest()
            {
                BucketName = bucketName
            };
            GetBucketLocationResponse response = await client.GetBucketLocationAsync(request);
            bucketLocation = response.Location.ToString();
            return bucketLocation;
        }
    }
}
Ruby

Per informazioni su come creare e testare un esempio di utilizzo, consulta Utilizzo dell' AWS SDK for Ruby - Versione 3. 

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__

Puoi anche usare AWS Command Line Interface (AWS CLI) per creare un bucket S3. Per ulteriori informazioni, consulta create-bucket nella Guida di riferimento ai comandi della AWS CLI .

Per informazioni su AWS CLI, consulta What is the? AWS Command Line Interface nella Guida AWS Command Line Interface per l'utente.

Nota

Puoi anche utilizzare un bucket Amazon S3 di un altro account, ma in questo caso potrebbe essere necessario creare una policy che conceda al bucket le autorizzazioni di accesso a AWS Config. Per informazioni sulla concessione di autorizzazioni a un bucket Amazon S3, consulta Autorizzazioni per il bucket Amazon S3 per il canale di distribuzione AWS Config e vai quindi a Creazione di un argomento Amazon SNS.

Creazione di un argomento Amazon SNS

Se nell'account è già presente un argomento Amazon SNS che desideri utilizzare, puoi ignorare questo passaggio e passare direttamente a Creazione di un ruolo IAM.

Come creare un argomento Amazon SNS

  1. Apri la console Amazon SNS all'indirizzo https://console.aws.amazon.com/sns/v3/home.

  2. Esegui una di queste operazioni:

    • Se non è mai stato creato alcun argomento in Account AWS precedenza, leggi la descrizione di Amazon SNS nella home page.

    • Se gli argomenti sono già stati creati sotto il tuo Account AWS nome, nel pannello di navigazione, scegli Argomenti.

  3. Nella pagina Topics (Argomenti), seleziona Create new topic (Crea nuovo argomento).

  4. Nella pagina Create topic (Crea argomento), nella sezione Details (Dettagli), eseguire queste operazioni:

    1. Per Type (Tipo), scegli un tipo di argomento (standard o FIFO).

    2. Immetti un nome per l'argomento. Per un Argomento FIFO, aggiungere .fifo alla fine del nome.

    3. (Facoltativo) Compilare il Display name (Nome visualizzato) per l'argomento.

    4. (Facoltativo) Per un argomento FIFO, puoi scegliere Deduplicazione dei messaggi basata sul contenuto per abilitare la deduplicazione predefinita dei messaggi. Per ulteriori informazioni, consulta Deduplicazione dei messaggi per argomenti FIFO.

  5. (Facoltativo) Espandere la sezione Encryption (Crittografia) e procedere come segue. Per ulteriori informazioni, consultare Crittografia dei dati inattivi.

    1. Scegliere Enable encryption (Abilita crittografia).

    2. Specificare la chiave master del cliente (CMK). Per ulteriori informazioni, consulta Termini chiave.

      Per ciascun tipo di CMK vengono visualizzati i valori Description (Descrizione), Account e CMK ARN (ARN CMK).

      Importante

      Se non sei il proprietario della CMK, oppure se effettui l'accesso con un account che non dispone delle autorizzazioni kms:ListAliases e kms:DescribeKey, non puoi visualizzare le informazioni sulla CMK sulla console Amazon SNS.

      Chiedi al proprietario della CMK di riconoscerti queste autorizzazioni. Per esempi e ulteriori informazioni consulta AWS KMS Autorizzazioni API: e Documentazione su operazioni e risorse nella AWS Key Management Service Guida per sviluppatori.

      • L'alias/aws/sns della CMK AWS gestita per Amazon SNS (predefinito) è selezionata per impostazione predefinita.

        Nota

        Ricorda quanto segue:

        • La prima volta che usi AWS Management Console per specificare la CMK AWS gestita per Amazon SNS per un argomento AWS KMS , crea AWS la CMK gestita per Amazon SNS.

        • In alternativa, la prima volta che utilizzi l'Publishazione su un argomento con SSE abilitato, AWS KMS crea la CMK AWS gestita per Amazon SNS.

      • Per utilizzare una CMK personalizzata dal tuo AWS account, scegli il campo Customer master key (CMK), quindi scegli la CMK personalizzata dall'elenco.

        Nota

        Per istruzioni sulla creazione di CMK personalizzate, consulta Creazione chiavi nella AWS Key Management Service Guida per sviluppatori

      • Per utilizzare un ARN CMK personalizzato dal AWS tuo account o da AWS un altro account, inseriscilo nel campo Customer master key (CMK).

  6. (Facoltativo) Per impostazione predefinita, solo il proprietario dell'argomento può pubblicare o sottoscrivere l'argomento. Per configurare autorizzazioni di accesso aggiuntive, espandi la sezione Access policy (Policy di accesso) . Per ulteriori informazioni, consulta Identity and Access Management in Amazon SNS ed Esempi di casi per il controllo degli accessi Amazon SNS.

    Nota

    Quando crei un argomento utilizzando la console, la policy predefinita utilizza la chiave di condizione aws:SourceOwner. Questa chiave è analoga a aws:SourceAccount.

  7. (Facoltativo) Per configurare il modo in cui Amazon SNS riprova a consegnare i messaggi non recapitati, espandere la sezione Delivery retry policy (HTTP/S) (Policy nuovi tentativi di consegna [HTTP/S]). Per ulteriori informazioni, consulta Tentativi di consegna dei messaggi di Amazon SNS.

  8. (Facoltativo) Per configurare il modo in cui Amazon SNS registra la consegna dei messaggi CloudWatch, espandi la sezione Registrazione dello stato di consegna. Per ulteriori informazioni, consulta Stato di consegna dei messaggi di Amazon SNS.

  9. (facoltativo) Per aggiungere tag di metadati all'argomento, espandere la sezione Tags (Tag), immettere una Key (Chiave) e un Value (Valore) (opzionale) e scegliere Add tag (Aggiungi tag). Per ulteriori informazioni, consulta Assegnazione di tag all'argomento Amazon SNS.

  10. Scegli Create topic (Crea argomento).

    L'argomento viene creato e la MyTopicpagina viene visualizzata.

    L'argomento Nome, ARN, (opzionale) Display name (Nome visualizzato), e proprietario dell'argomento's AWS l'ID account viene visualizzato nella sezione Dettagli.

  11. Copiare l'ARN dell'argomento negli appunti, ad esempio:

    arn:aws:sns:us-east-2:123456789012:MyTopic
Per sottoscrivere un indirizzo e-mail all'argomento Amazon SNS

  1. Apri la console Amazon SNS all'indirizzo https://console.aws.amazon.com/sns/v3/home.

  2. Nel pannello di navigazione sinistro scegli Sottoscrizioni.

  3. Nella pagina Sottoscrizioni scegli Crea sottoscrizione.

  4. Nella pagina Crea sottoscrizione, nella sezione Dettagli, eseguire queste operazioni:

    1. Per argomento ARN, scegli l'Amazon Resource Name (ARN) di un argomento.

    2. Per Protocollo, scegli un tipo di endpoint. I tipi di endpoint disponibili sono:

    3. Per Endpoint, inserisci il valore dell'endpoint, ad esempio un indirizzo e-mail o l'ARN di una coda Amazon SQS.

    4. Solo endpoint Firehose: per il ruolo di sottoscrizione ARN, specifica l'ARN del ruolo IAM che hai creato per la scrittura nei flussi di distribuzione Firehose. Per ulteriori informazioni, consulta gli argomenti Prerequisiti per la sottoscrizione dei flussi di distribuzione di Firehose ad Amazon SNS.

    5. (Facoltativo) Per gli endpoint Firehose, Amazon SQS, HTTP/S, puoi anche abilitare il recapito di messaggi non elaborati. Per ulteriori informazioni, consulta Consegna di messaggi non elaborati Amazon SNS.

    6. (Facoltativo) Per configurare un criterio di filtro, espandere la sezione policy di filtro della sottoscrizione. Per ulteriori informazioni, consulta Policy di filtro degli abbonamenti Amazon SNS.

    7. (Facoltativo) Per configurare una coda DLQ per la sottoscrizione, espandere la sezione Policy di redrive (coda DLQ). Per ulteriori informazioni, consulta Code DLQ (DLQ) Amazon SNS.

    8. Scegli Create Subscription (Crea sottoscrizione).

      La console crea la sottoscrizione e apre la pagina dettagli della sottoscrizione.

Per utilizzare un AWS SDK, devi configurarlo con le tue credenziali. Per ulteriori informazioni, consulta File di configurazione e credenziali condivisi nella AWS Guida SDK e strumenti di riferimento.

Gli esempi di codice seguenti mostrano come creare un argomento Amazon SNS.

.NET
AWS SDK for .NET
Nota

C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS.

Crea un argomento con un nome di specifico.

    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;
        }
    }

Crea un nuovo argomento con un nome e attributi FIFO e di deduplicazione specifici.

    /// <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;
    }

  • Per i dettagli sull'API, consulta la CreateTopicsezione AWS SDK for .NET API Reference.

C++
SDK per C++
Nota

C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 

//! 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();
}

  • Per i dettagli sull'API, consulta la CreateTopicsezione AWS SDK for C++ API Reference.

CLI
AWS CLI

Creazione di un argomento SNS

Nell'esempio create-topic seguente viene creato un argomento SNS denominato my-topic.

aws sns create-topic \
    --name my-topic

Output:

{
    "ResponseMetadata": {
        "RequestId": "1469e8d7-1642-564e-b85d-a19b4b341f83"
    },
    "TopicArn": "arn:aws:sns:us-west-2:123456789012:my-topic"
}

Per ulteriori informazioni, consulta Using the AWS Command Line Interface with Amazon SQS e Amazon SNS nella Command Line Interface AWS User Guide.

  • Per i dettagli sull'API, consulta AWS CLI Command CreateTopicReference.

Go
SDK per Go V2
Nota

C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 


// 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
}

  • Per i dettagli sull'API, consulta la CreateTopicsezione AWS SDK for Go API Reference.

Java
SDK per Java 2.x
Nota

C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 

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 "";
    }
}

  • Per i dettagli sull'API, consulta la CreateTopicsezione AWS SDK for Java 2.x API Reference.

JavaScript
SDK per JavaScript (v3)
Nota

C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l’esecuzione nel Repository di esempi di codice AWS.

Creare il client in un modulo separato ed esportarlo.

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({});

Importare l'SDK e i moduli client e chiamare 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;
};
Kotlin
SDK per Kotlin
Nota

C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 

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()
    }
}

  • Per i dettagli sull'API, CreateTopicconsulta AWS SDK for Kotlin API reference.

PHP
SDK per PHP
Nota

C'è altro su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 

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());
}
Python
SDK per Python (Boto3)
Nota

C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 

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

  • Per i dettagli sull'API, consulta CreateTopic AWSSDK for Python (Boto3) API Reference.

Ruby
SDK per Ruby
Nota

C'è di più su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 

# 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
Rust
SDK per Rust
Nota

C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 

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(())
}

  • Per i dettagli sulle API, consulta la CreateTopicguida di riferimento all'API AWS SDK for Rust.

SAP ABAP
SDK per SAP ABAP
Nota

C'è di più su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 

    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.

  • Per i dettagli sulle API, CreateTopicconsulta AWS SDK for SAP ABAP API reference.

Puoi anche usare il AWS Command Line Interface (AWS CLI) per creare un argomento Amazon SNS. Per ulteriori informazioni, consulta create-topic nella Guida di riferimento ai comandi di AWS CLI .

Per informazioni su AWS CLI, consulta What is the AWS Command Line Interface? nella Guida AWS Command Line Interface per l'utente.

Nota

Puoi utilizzare anche un argomento Amazon SNS di un altro account, ma in questo caso potrebbe essere necessario creare una policy che conceda all'argomento le autorizzazioni di accesso a AWS Config. Per informazioni sulla concessione di autorizzazioni a un argomento Amazon SNS, consulta Autorizzazioni per l'argomento Amazon SNS e quindi vai a Creazione di un ruolo IAM.

Creazione di un ruolo IAM

Puoi utilizzare la console IAM per creare un ruolo IAM che conceda AWS Config le autorizzazioni per accedere al tuo bucket Amazon S3, accedere all'argomento Amazon SNS e ottenere dettagli di configurazione per le risorse supportate. AWS Quando utilizzi la console per creare un ruolo IAM, AWS Config collega automaticamente al ruolo le autorizzazioni richieste per tuo conto.

Nota

Se hai utilizzato un AWS servizio che utilizza AWS Config (come AWS Security Hub o AWS Control Tower) e un AWS Config ruolo è già stato creato, assicurati che il ruolo IAM che usi durante la configurazione AWS Config mantenga gli stessi privilegi minimi del AWS Config ruolo già creato in modo che l'altro AWS servizio continui a funzionare come previsto.

Ad esempio, se AWS Control Tower ha un ruolo IAM che AWS Config consente di leggere oggetti Amazon S3, dovresti garantire che vengano concesse le stesse autorizzazioni all'interno del ruolo IAM che usi durante la configurazione. AWS Config In caso contrario, potrebbe interferire con le operazioni AWS di Control Tower.

Per ulteriori informazioni sui ruoli IAM per AWS Config, consulta AWS Identity and Access Management.

Per creare un ruolo per un AWS servizio

  1. Accedi AWS Management Console e apri la console IAM all'indirizzo https://console.aws.amazon.com/iam/.

  2. Nel pannello di navigazione della console IAM, scegliere Ruoli e quindi Crea ruolo.

  3. In Seleziona tipo di entità attendibile, scegli Servizio AWS .

  4. Scegli il caso d'uso che desideri AWS Config: Config - Customizable, Config - Organizations, Config o Config - Conformance Packs. Quindi, seleziona Next (Successivo).

  5. Nella pagina Nomina, verifica e crea, controlla i dettagli del ruolo e seleziona Crea ruolo.

Per utilizzare un AWS SDK, devi configurarlo con le tue credenziali. Per ulteriori informazioni, consulta File di configurazione e credenziali condivisi nella Guida di riferimento per SDK AWS e strumenti.

Gli esempi di codice seguenti mostrano come creare un ruolo IAM.

.NET
AWS SDK for .NET
Nota

C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 

    /// <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;
    }

  • Per i dettagli sull'API, consulta la CreateRolesezione AWS SDK for .NET API Reference.

Bash
AWS CLI con lo script Bash
Nota

C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 

###############################################################################
# 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
}
C++
SDK per C++
Nota

C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 

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();
}

  • Per i dettagli sull'API, consulta la CreateRolesezione AWS SDK for C++ API Reference.

CLI
AWS CLI

Esempio 1: Come creare un ruolo IAM

Il comando create-role seguente crea un ruolo denominato Test-Role e collega una policy di attendibilità a tale ruolo.

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

Output:

{
    "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 policy di attendibilità è definita come documento JSON nel file Test-Role-Trust-Policy.json. (Il nome e l'estensione del file non hanno importanza.) La policy di attendibilità deve specificare un principale.

Per collegare una policy di autorizzazioni a un ruolo, usa il comando put-role-policy.

Per ulteriori informazioni, consulta Creazione di ruoli IAM nella Guida per l’utente IAM AWS .

Esempio 2: Come creare un ruolo IAM con una durata massima della sessione specificata

Il comando create-role seguente crea un ruolo denominato Test-Role e imposta una durata massima della sessione di 7200 secondi (2 ore).

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

Output:

{
    "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"
                }
            ]
        }
    }
}

Per ulteriori informazioni, consulta Modificare la durata massima della sessione (AWS API) di un ruolo nella Guida per l'utente AWS IAM.

Esempio 3: Come creare un ruolo IAM con tag

Il comando seguente crea un ruolo IAM Test-Role con tag. Questo esempio utilizza il flag del parametro --tags con i seguenti tag in formato JSON: '{"Key": "Department", "Value": "Accounting"}' '{"Key": "Location", "Value": "Seattle"}'. In alternativa, il flag --tags può essere utilizzato con tag in formato abbreviato: '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"}'

Output:

{
    "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"
            }
        ]
    }
}

Per ulteriori informazioni, consulta Applicazione di tag a ruoli IAM nella Guida per l'utente di IAM AWS .

Go
SDK per Go V2
Nota

C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 


// 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
}

  • Per i dettagli sull'API, consulta la CreateRolesezione AWS SDK for Go API Reference.

Java
SDK per Java 2.x
Nota

C'è di più su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 

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);
    }
}

  • Per i dettagli sull'API, consulta la CreateRolesezione AWS SDK for Java 2.x API Reference.

JavaScript
SDK per JavaScript (v3)
Nota

C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS.

Crea il ruolo.

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);
};

  • Per i dettagli sull'API, consulta la CreateRolesezione AWS SDK for JavaScript API Reference.

PHP
SDK per PHP
Nota

C'è di più su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 

$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'];
    }

  • Per i dettagli sull'API, consulta la CreateRolesezione AWS SDK for PHP API Reference.

Python
SDK per Python (Boto3)
Nota

C'è di più su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 

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

  • Per i dettagli sull'API, consulta CreateRole AWSSDK for Python (Boto3) API Reference.

Ruby
SDK per Ruby
Nota

C'è di più su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 

  # 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

  • Per i dettagli sull'API, consulta la CreateRolesezione AWS SDK for Ruby API Reference.

Rust
SDK per Rust
Nota

C'è di più su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 

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())
}

  • Per i dettagli sulle API, consulta la CreateRoleguida di riferimento all'API AWS SDK for Rust.

Swift
SDK per Swift
Nota

Si tratta di una documentazione di pre-rilascio di un SDK nella versione di anteprima. ed è soggetta a modifiche.

Nota

C'è di più su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS. 

    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
        }
    }

  • Per i dettagli sull'API, consulta la CreateRoleguida di riferimento all'API AWS SDK for Swift.

Puoi anche usare il AWS Command Line Interface (AWS CLI) per creare un ruolo IAM. Per ulteriori informazioni, consulta create-role nella Guida di riferimento ai comandi di AWS CLI . È quindi possibile allegare una policy al ruolo con il attach-role-policycomando.

Per informazioni su AWS CLI, consulta What is the AWS Command Line Interface? nella Guida AWS Command Line Interface per l'utente.